compiler_wrapper/clang_tidy_flag_test.go

// Copyright 2019 The Chromium OS Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

package main

import (
	"errors"
	"fmt"
	"io"
	"path"
	"strings"
	"testing"
)

func TestClangTidyBasename(t *testing.T) {
	withClangTidyTestContext(t, func(ctx *testContext) {
		testData := []struct {
			in  string
			out string
		}{
			{"./x86_64-cros-linux-gnu-clang", ".*/clang-tidy"},
			{"./x86_64-cros-linux-gnu-clang++", ".*/clang-tidy"},
		}

		var clangTidyCmd *command
		ctx.cmdMock = func(cmd *command, stdin io.Reader, stdout io.Writer, stderr io.Writer) error {
			if ctx.cmdCount == 2 {
				clangTidyCmd = cmd
			}
			return nil
		}

		for _, tt := range testData {
			ctx.cmdCount = 0
			clangTidyCmd = nil
			ctx.must(callCompiler(ctx, ctx.cfg,
				ctx.newCommand(tt.in, mainCc)))
			if ctx.cmdCount != 3 {
				t.Errorf("expected 3 calls. Got: %d", ctx.cmdCount)
			}
			if err := verifyPath(clangTidyCmd, tt.out); err != nil {
				t.Error(err)
			}
		}
	})
}

func TestClangTidyClangResourceDir(t *testing.T) {
	withClangTidyTestContext(t, func(ctx *testContext) {
		ctx.cmdMock = func(cmd *command, stdin io.Reader, stdout io.Writer, stderr io.Writer) error {
			switch ctx.cmdCount {
			case 1:
				if err := verifyPath(cmd, "usr/bin/clang"); err != nil {
					t.Error(err)
				}
				if err := verifyArgOrder(cmd, "--print-resource-dir"); err != nil {
					t.Error(err)
				}
				fmt.Fprint(stdout, "someResourcePath")
				return nil
			case 2:
				if err := verifyPath(cmd, "usr/bin/clang-tidy"); err != nil {
					return err
				}
				if err := verifyArgOrder(cmd, "-resource-dir=someResourcePath", mainCc); err != nil {
					return err
				}
				return nil
			case 3:
				if err := verifyPath(cmd, "usr/bin/clang"); err != nil {
					t.Error(err)
				}
				return nil
			default:
				t.Fatalf("unexpected command %#v", cmd)
				return nil
			}
		}
		ctx.must(callCompiler(ctx, ctx.cfg,
			ctx.newCommand(clangX86_64, mainCc)))
		if ctx.cmdCount != 3 {
			t.Errorf("expected 3 calls. Got: %d", ctx.cmdCount)
		}
	})
}

func TestClangTidyArgOrder(t *testing.T) {
	withClangTidyTestContext(t, func(ctx *testContext) {
		ctx.cmdMock = func(cmd *command, stdin io.Reader, stdout io.Writer, stderr io.Writer) error {
			if ctx.cmdCount == 2 {
				if err := verifyArgOrder(cmd, "-checks=.*", mainCc, "--", "-resource-dir=.*", mainCc, "--some_arg"); err != nil {
					return err
				}
			}
			return nil
		}
		ctx.must(callCompiler(ctx, ctx.cfg,
			ctx.newCommand(clangX86_64, mainCc, "--some_arg")))
		if ctx.cmdCount != 3 {
			t.Errorf("expected 3 calls. Got: %d", ctx.cmdCount)
		}
	})
}

func TestForwardStdOutAndStderrFromClangTidyCall(t *testing.T) {
	withClangTidyTestContext(t, func(ctx *testContext) {
		ctx.cmdMock = func(cmd *command, stdin io.Reader, stdout io.Writer, stderr io.Writer) error {
			if ctx.cmdCount == 2 {
				fmt.Fprint(stdout, "somemessage")
				fmt.Fprint(stderr, "someerror")
			}
			return nil
		}
		ctx.must(callCompiler(ctx, ctx.cfg,
			ctx.newCommand(clangX86_64, mainCc)))
		if ctx.stdoutString() != "somemessage" {
			t.Errorf("stdout was not forwarded. Got: %s", ctx.stdoutString())
		}
		if ctx.stderrString() != "someerror" {
			t.Errorf("stderr was not forwarded. Got: %s", ctx.stderrString())
		}
	})
}

func TestIgnoreNonZeroExitCodeFromClangTidy(t *testing.T) {
	withClangTidyTestContext(t, func(ctx *testContext) {
		ctx.cmdMock = func(cmd *command, stdin io.Reader, stdout io.Writer, stderr io.Writer) error {
			if ctx.cmdCount == 2 {
				return newExitCodeError(23)
			}
			return nil
		}
		ctx.must(callCompiler(ctx, ctx.cfg,
			ctx.newCommand(clangX86_64, mainCc)))
		stderr := ctx.stderrString()
		if err := verifyNonInternalError(stderr, "clang-tidy failed"); err != nil {
			t.Error(err)
		}
	})
}

func TestReportGeneralErrorsFromClangTidy(t *testing.T) {
	withClangTidyTestContext(t, func(ctx *testContext) {
		ctx.cmdMock = func(cmd *command, stdin io.Reader, stdout io.Writer, stderr io.Writer) error {
			if ctx.cmdCount == 2 {
				return errors.New("someerror")
			}
			return nil
		}
		stderr := ctx.mustFail(callCompiler(ctx, ctx.cfg,
			ctx.newCommand(clangX86_64, mainCc)))
		if err := verifyInternalError(stderr); err != nil {
			t.Fatal(err)
		}
		if !strings.Contains(stderr, "someerror") {
			t.Errorf("unexpected error. Got: %s", stderr)
		}
	})
}

func TestOmitClangTidyForGcc(t *testing.T) {
	withClangTidyTestContext(t, func(ctx *testContext) {
		ctx.must(callCompiler(ctx, ctx.cfg,
			ctx.newCommand(gccX86_64, mainCc)))
		if ctx.cmdCount > 1 {
			t.Errorf("expected 1 command. Got: %d", ctx.cmdCount)
		}
	})
}

func TestOmitClangTidyForGccWithClangSyntax(t *testing.T) {
	withClangTidyTestContext(t, func(ctx *testContext) {
		ctx.must(callCompiler(ctx, ctx.cfg,
			ctx.newCommand(gccX86_64, "-clang-syntax", mainCc)))
		if ctx.cmdCount > 2 {
			t.Errorf("expected 2 commands. Got: %d", ctx.cmdCount)
		}
	})
}

func TestUseClangTidyBasedOnFileExtension(t *testing.T) {
	withClangTidyTestContext(t, func(ctx *testContext) {
		testData := []struct {
			args      []string
			clangTidy bool
		}{
			{[]string{"main.cc"}, true},
			{[]string{"main.cc"}, true},
			{[]string{"main.C"}, true},
			{[]string{"main.cxx"}, true},
			{[]string{"main.c++"}, true},
			{[]string{"main.xy"}, false},
			{[]string{"-o", "main.cc"}, false},
			{[]string{}, false},
		}
		for _, tt := range testData {
			ctx.cmdCount = 0
			ctx.must(callCompiler(ctx, ctx.cfg,
				ctx.newCommand(clangX86_64, tt.args...)))
			if ctx.cmdCount > 1 && !tt.clangTidy {
				t.Errorf("expected a call to clang tidy but got none for args %s", tt.args)
			}
			if ctx.cmdCount == 1 && tt.clangTidy {
				t.Errorf("expected no call to clang tidy but got one for args %s", tt.args)
			}
		}
	})
}

func TestOmitCCacheWithClangTidy(t *testing.T) {
	withClangTidyTestContext(t, func(ctx *testContext) {
		ctx.cfg.useCCache = true

		ctx.cmdMock = func(cmd *command, stdin io.Reader, stdout io.Writer, stderr io.Writer) error {
			switch ctx.cmdCount {
			case 1:
				if err := verifyPath(cmd, "usr/bin/clang"); err != nil {
					t.Error(err)
				}
				return nil
			case 2:
				if err := verifyPath(cmd, "usr/bin/clang-tidy"); err != nil {
					return err
				}
				return nil
			default:
				return nil
			}
		}
		cmd := ctx.must(callCompiler(ctx, ctx.cfg,
			ctx.newCommand(clangX86_64, mainCc)))
		if ctx.cmdCount != 3 {
			t.Errorf("expected 3 calls. Got: %d", ctx.cmdCount)
		}
		if err := verifyPath(cmd, "usr/bin/clang"); err != nil {
			t.Error(err)
		}
	})
}

func TestPartiallyOmitGomaWithClangTidy(t *testing.T) {
	withClangTidyTestContext(t, func(ctx *testContext) {
		gomaPath := path.Join(ctx.tempDir, "gomacc")
		// Create a file so the gomacc path is valid.
		ctx.writeFile(gomaPath, "")
		ctx.env = append(ctx.env, "GOMACC_PATH="+gomaPath)

		ctx.cmdMock = func(cmd *command, stdin io.Reader, stdout io.Writer, stderr io.Writer) error {
			switch ctx.cmdCount {
			case 1:
				if err := verifyPath(cmd, "usr/bin/clang"); err != nil {
					t.Error(err)
				}
				return nil
			case 2:
				if err := verifyPath(cmd, "usr/bin/clang-tidy"); err != nil {
					return err
				}
				return nil
			default:
				return nil
			}
		}
		cmd := ctx.must(callCompiler(ctx, ctx.cfg,
			ctx.newCommand(clangX86_64, mainCc)))
		if ctx.cmdCount != 3 {
			t.Errorf("expected 3 calls. Got: %d", ctx.cmdCount)
		}
		if err := verifyPath(cmd, gomaPath); err != nil {
			t.Error(err)
		}
	})
}

func TestTriciumClangTidyIsProperlyDetectedFromEnv(t *testing.T) {
	withClangTidyTestContext(t, func(ctx *testContext) {
		ctx.env = []string{"WITH_TIDY=tricium"}
		ctx.cmdMock = func(cmd *command, stdin io.Reader, stdout io.Writer, stderr io.Writer) error {
			switch ctx.cmdCount {
			case 1:
				if err := verifyPath(cmd, "usr/bin/clang"); err != nil {
					t.Error(err)
				}
				return nil
			case 2:
				if err := verifyPath(cmd, "usr/bin/clang-tidy"); err != nil {
					return err
				}

				hasFixesFile := false
				for _, arg := range cmd.Args {
					if path := strings.TrimPrefix(arg, "--export-fixes="); path != arg {
						hasFixesFile = true
						if !strings.HasPrefix(path, ctx.cfg.triciumNitsDir+"/") {
							t.Errorf("fixes file was %q; expected it to be in %q", path, ctx.cfg.triciumNitsDir)
						}
						break
					}
				}

				if !hasFixesFile {
					t.Error("no fixes file was provided to a tricium invocation")
				}

				return nil
			default:
				return nil
			}
		}
		cmd := ctx.must(callCompiler(ctx, ctx.cfg,
			ctx.newCommand(clangX86_64, mainCc)))
		if ctx.cmdCount != 3 {
			t.Errorf("expected 3 calls. Got: %d", ctx.cmdCount)
		}
		if err := verifyPath(cmd, "usr/bin/clang"); err != nil {
			t.Error(err)
		}
	})
}

func TestTriciumClangTidySkipsProtobufFiles(t *testing.T) {
	withClangTidyTestContext(t, func(ctx *testContext) {
		ctx.env = []string{"WITH_TIDY=tricium"}
		cmd := ctx.must(callCompiler(ctx, ctx.cfg,
			ctx.newCommand(clangX86_64, mainCc+".pb.cc")))
		if ctx.cmdCount != 1 {
			t.Errorf("expected tricium clang-tidy to not execute on a protobuf file")
		}
		if err := verifyPath(cmd, "usr/bin/clang"); err != nil {
			t.Error(err)
		}
	})
}

func testClangTidyFiltersClangTidySpecificFlagsWithPresetEnv(t *testing.T, ctx *testContext) {
	addedFlag := "--some_clang_tidy=flag"
	ctx.cmdMock = func(cmd *command, stdin io.Reader, stdout io.Writer, stderr io.Writer) error {
		switch ctx.cmdCount {
		case 1:
			if err := verifyPath(cmd, "usr/bin/clang"); err != nil {
				t.Error(err)
			} else if err := verifyArgCount(cmd, 0, addedFlag); err != nil {
				t.Error(err)
			}
			return nil
		case 2:
			if err := verifyPath(cmd, "usr/bin/clang-tidy"); err != nil {
				t.Error(err)
			} else if verifyArgCount(cmd, 1, addedFlag); err != nil {
				t.Error(err)
			}
			return nil
		default:
			return nil
		}
	}
	cmd := ctx.must(callCompiler(ctx, ctx.cfg, ctx.newCommand(clangX86_64, mainCc, "-clang-tidy-flag="+addedFlag)))
	if ctx.cmdCount != 3 {
		t.Errorf("expected 3 calls. Got: %d", ctx.cmdCount)
	}
	if err := verifyPath(cmd, "usr/bin/clang"); err != nil {
		t.Error(err)
	}
}

func TestClangTidyFiltersClangTidySpecificFlagsForTricium(t *testing.T) {
	withClangTidyTestContext(t, func(ctx *testContext) {
		ctx.env = []string{"WITH_TIDY=tricium"}
		testClangTidyFiltersClangTidySpecificFlagsWithPresetEnv(t, ctx)
	})
}

func TestClangTidyFiltersClangTidySpecificFlags(t *testing.T) {
	withClangTidyTestContext(t, func(ctx *testContext) {
		testClangTidyFiltersClangTidySpecificFlagsWithPresetEnv(t, ctx)
	})
}

func TestClangTidyFlagsAreFilteredFromGccInvocations(t *testing.T) {
	withTestContext(t, func(ctx *testContext) {
		cmd := ctx.must(callCompiler(ctx, ctx.cfg, ctx.newCommand(gccX86_64, mainCc, "-clang-tidy-flag=--foo")))
		if err := verifyArgCount(cmd, 0, ".*--foo.*"); err != nil {
			t.Error(err)
		}
	})
}

func TestTriciumReportsClangTidyCrashesGracefully(t *testing.T) {
	withClangTidyTestContext(t, func(ctx *testContext) {
		ctx.env = []string{"WITH_TIDY=tricium"}
		ctx.cmdMock = func(cmd *command, stdin io.Reader, stdout io.Writer, stderr io.Writer) error {
			switch ctx.cmdCount {
			case 1:
				if err := verifyPath(cmd, "usr/bin/clang"); err != nil {
					t.Error(err)
				}
				return nil
			case 2:
				if err := verifyPath(cmd, "usr/bin/clang-tidy"); err != nil {
					return err
				}

				if _, err := io.WriteString(stdout, clangTidyCrashSubstring); err != nil {
					return err
				}
				return nil
			case 3:
				if err := verifyPath(cmd, "usr/bin/clang"); err != nil {
					t.Error(err)
				}

				args := cmd.Args
				if len(args) < 3 {
					t.Errorf("insufficient number of args provided; got %d; want at least 3", len(args))
					return nil
				}

				lastArgs := args[len(args)-3:]
				eArg, oArg, outFileArg := lastArgs[0], lastArgs[1], lastArgs[2]
				if eArg != "-E" {
					t.Errorf("got eArg=%q; wanted -E", eArg)
				}

				if oArg != "-o" {
					t.Errorf("got oArg=%q; wanted -o", oArg)
				}

				wantPrefix := path.Join(ctx.cfg.crashArtifactsDir, "clang-tidy")
				if !strings.HasPrefix(outFileArg, wantPrefix) {
					t.Errorf("got out file %q; wanted one starting with %q", outFileArg, wantPrefix)
				}

				return nil
			default:
				return nil
			}
		}
		ctx.must(callCompiler(ctx, ctx.cfg, ctx.newCommand(clangX86_64, mainCc)))
		if ctx.cmdCount != 4 {
			t.Errorf("expected 3 calls. Got: %d", ctx.cmdCount)
		}
	})
}

func withClangTidyTestContext(t *testing.T, work func(ctx *testContext)) {
	withTestContext(t, func(ctx *testContext) {
		ctx.env = []string{"WITH_TIDY=1"}
		work(ctx)
	})
}