3dba4d2c60
Generated codes like cpp code from *.ll for *.yy files always run clang-tidy, when generated code has warning, where is no way to fix it. So, disable clang-tidy for generated code. Bug: 162909698 Test: go test android/soong/cc Change-Id: I0fee137d6170ef4bf6cf641abad572e448aceaa1
273 lines
8.8 KiB
Go
273 lines
8.8 KiB
Go
// Copyright 2022 Google Inc. All rights reserved.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
package cc
|
|
|
|
import (
|
|
"fmt"
|
|
"strings"
|
|
"testing"
|
|
|
|
"android/soong/android"
|
|
)
|
|
|
|
func TestTidyFlagsWarningsAsErrors(t *testing.T) {
|
|
// The "tidy_flags" property should not contain -warnings-as-errors.
|
|
type testCase struct {
|
|
libName, bp string
|
|
errorMsg string // a negative test; must have error message
|
|
flags []string // must have substrings in tidyFlags
|
|
noFlags []string // must not have substrings in tidyFlags
|
|
}
|
|
|
|
testCases := []testCase{
|
|
{
|
|
"libfoo1",
|
|
`cc_library_shared { // no warnings-as-errors, good tidy_flags
|
|
name: "libfoo1",
|
|
srcs: ["foo.c"],
|
|
tidy_flags: ["-header-filter=dir1/"],
|
|
}`,
|
|
"",
|
|
[]string{"-header-filter=dir1/"},
|
|
[]string{"-warnings-as-errors"},
|
|
},
|
|
{
|
|
"libfoo2",
|
|
`cc_library_shared { // good use of tidy_checks_as_errors
|
|
name: "libfoo2",
|
|
srcs: ["foo.c"],
|
|
tidy_checks_as_errors: ["xyz-*", "abc"],
|
|
}`,
|
|
"",
|
|
[]string{
|
|
"-header-filter=^", // there is a default header filter
|
|
"-warnings-as-errors='xyz-*',abc,${config.TidyGlobalNoErrorChecks}",
|
|
},
|
|
[]string{},
|
|
},
|
|
}
|
|
if NoWarningsAsErrorsInTidyFlags {
|
|
testCases = append(testCases, testCase{
|
|
"libfoo3",
|
|
`cc_library_shared { // bad use of -warnings-as-errors in tidy_flags
|
|
name: "libfoo3",
|
|
srcs: ["foo.c"],
|
|
tidy_flags: [
|
|
"-header-filters=.*",
|
|
"-warnings-as-errors=xyz-*",
|
|
],
|
|
}`,
|
|
`module "libfoo3" .*: tidy_flags: should not contain .*;` +
|
|
` use tidy_checks_as_errors instead`,
|
|
[]string{},
|
|
[]string{},
|
|
})
|
|
}
|
|
for _, test := range testCases {
|
|
if test.errorMsg != "" {
|
|
testCcError(t, test.errorMsg, test.bp)
|
|
continue
|
|
}
|
|
variant := "android_arm64_armv8-a_shared"
|
|
ctx := testCc(t, test.bp)
|
|
t.Run("caseTidyFlags", func(t *testing.T) {
|
|
flags := ctx.ModuleForTests(test.libName, variant).Rule("clangTidy").Args["tidyFlags"]
|
|
for _, flag := range test.flags {
|
|
if !strings.Contains(flags, flag) {
|
|
t.Errorf("tidyFlags %v for %s does not contain %s.", flags, test.libName, flag)
|
|
}
|
|
}
|
|
for _, flag := range test.noFlags {
|
|
if strings.Contains(flags, flag) {
|
|
t.Errorf("tidyFlags %v for %s should not contain %s.", flags, test.libName, flag)
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestTidyChecks(t *testing.T) {
|
|
// The "tidy_checks" property defines additional checks appended
|
|
// to global default. But there are some checks disabled after
|
|
// the local tidy_checks.
|
|
bp := `
|
|
cc_library_shared { // has global checks + extraGlobalChecks
|
|
name: "libfoo_1",
|
|
srcs: ["foo.c"],
|
|
}
|
|
cc_library_shared { // has only local checks + extraGlobalChecks
|
|
name: "libfoo_2",
|
|
srcs: ["foo.c"],
|
|
tidy_checks: ["-*", "xyz-*"],
|
|
}
|
|
cc_library_shared { // has global checks + local checks + extraGlobalChecks
|
|
name: "libfoo_3",
|
|
srcs: ["foo.c"],
|
|
tidy_checks: ["-abc*", "xyz-*", "mycheck"],
|
|
}
|
|
cc_library_shared { // has only local checks after "-*" + extraGlobalChecks
|
|
name: "libfoo_4",
|
|
srcs: ["foo.c"],
|
|
tidy_checks: ["-abc*", "xyz-*", "mycheck", "-*", "xyz-*"],
|
|
}`
|
|
ctx := testCc(t, bp)
|
|
|
|
globalChecks := "-checks=${config.TidyDefaultGlobalChecks},"
|
|
firstXyzChecks := "-checks='-*','xyz-*',"
|
|
localXyzChecks := "'-*','xyz-*'"
|
|
localAbcChecks := "'-abc*','xyz-*',mycheck"
|
|
extraGlobalChecks := ",${config.TidyGlobalNoChecks}"
|
|
testCases := []struct {
|
|
libNumber int // 1,2,3,...
|
|
checks []string // must have substrings in -checks
|
|
noChecks []string // must not have substrings in -checks
|
|
}{
|
|
{1, []string{globalChecks, extraGlobalChecks}, []string{localXyzChecks, localAbcChecks}},
|
|
{2, []string{firstXyzChecks, extraGlobalChecks}, []string{globalChecks, localAbcChecks}},
|
|
{3, []string{globalChecks, localAbcChecks, extraGlobalChecks}, []string{localXyzChecks}},
|
|
{4, []string{firstXyzChecks, extraGlobalChecks}, []string{globalChecks, localAbcChecks}},
|
|
}
|
|
t.Run("caseTidyChecks", func(t *testing.T) {
|
|
variant := "android_arm64_armv8-a_shared"
|
|
for _, test := range testCases {
|
|
libName := fmt.Sprintf("libfoo_%d", test.libNumber)
|
|
flags := ctx.ModuleForTests(libName, variant).Rule("clangTidy").Args["tidyFlags"]
|
|
splitFlags := strings.Split(flags, " ")
|
|
foundCheckFlag := false
|
|
for _, flag := range splitFlags {
|
|
if strings.HasPrefix(flag, "-checks=") {
|
|
foundCheckFlag = true
|
|
for _, check := range test.checks {
|
|
if !strings.Contains(flag, check) {
|
|
t.Errorf("tidyFlags for %s does not contain %s.", libName, check)
|
|
}
|
|
}
|
|
for _, check := range test.noChecks {
|
|
if strings.Contains(flag, check) {
|
|
t.Errorf("tidyFlags for %s should not contain %s.", libName, check)
|
|
}
|
|
}
|
|
break
|
|
}
|
|
}
|
|
if !foundCheckFlag {
|
|
t.Errorf("tidyFlags for %s does not contain -checks=.", libName)
|
|
}
|
|
}
|
|
})
|
|
}
|
|
|
|
func TestWithTidy(t *testing.T) {
|
|
// When WITH_TIDY=1 or (ALLOW_LOCAL_TIDY_TRUE=1 and local tidy:true)
|
|
// a C++ library should depend on .tidy files.
|
|
testCases := []struct {
|
|
withTidy, allowLocalTidyTrue string // "_" means undefined
|
|
needTidyFile []bool // for {libfoo_0, libfoo_1} and {libbar_0, libbar_1}
|
|
}{
|
|
{"_", "_", []bool{false, false, false}},
|
|
{"_", "0", []bool{false, false, false}},
|
|
{"_", "1", []bool{false, true, false}},
|
|
{"_", "true", []bool{false, true, false}},
|
|
{"0", "_", []bool{false, false, false}},
|
|
{"0", "1", []bool{false, true, false}},
|
|
{"1", "_", []bool{true, true, false}},
|
|
{"1", "false", []bool{true, true, false}},
|
|
{"1", "1", []bool{true, true, false}},
|
|
{"true", "_", []bool{true, true, false}},
|
|
}
|
|
bp := `
|
|
cc_library_shared {
|
|
name: "libfoo_0", // depends on .tidy if WITH_TIDY=1
|
|
srcs: ["foo.c"],
|
|
}
|
|
cc_library_shared { // depends on .tidy if WITH_TIDY=1 or ALLOW_LOCAL_TIDY_TRUE=1
|
|
name: "libfoo_1",
|
|
srcs: ["foo.c"],
|
|
tidy: true,
|
|
}
|
|
cc_library_shared { // no .tidy
|
|
name: "libfoo_2",
|
|
srcs: ["foo.c"],
|
|
tidy: false,
|
|
}
|
|
cc_library_static {
|
|
name: "libbar_0", // depends on .tidy if WITH_TIDY=1
|
|
srcs: ["bar.c"],
|
|
}
|
|
cc_library_static { // depends on .tidy if WITH_TIDY=1 or ALLOW_LOCAL_TIDY_TRUE=1
|
|
name: "libbar_1",
|
|
srcs: ["bar.c"],
|
|
tidy: true,
|
|
}
|
|
cc_library_static { // no .tidy
|
|
name: "libbar_2",
|
|
srcs: ["bar.c"],
|
|
tidy: false,
|
|
}`
|
|
for index, test := range testCases {
|
|
testName := fmt.Sprintf("case%d,%v,%v", index, test.withTidy, test.allowLocalTidyTrue)
|
|
t.Run(testName, func(t *testing.T) {
|
|
testEnv := map[string]string{}
|
|
if test.withTidy != "_" {
|
|
testEnv["WITH_TIDY"] = test.withTidy
|
|
}
|
|
if test.allowLocalTidyTrue != "_" {
|
|
testEnv["ALLOW_LOCAL_TIDY_TRUE"] = test.allowLocalTidyTrue
|
|
}
|
|
ctx := android.GroupFixturePreparers(prepareForCcTest, android.FixtureMergeEnv(testEnv)).RunTestWithBp(t, bp)
|
|
for n := 0; n < 3; n++ {
|
|
checkLibraryRule := func(foo, variant, ruleName string) {
|
|
libName := fmt.Sprintf("lib%s_%d", foo, n)
|
|
tidyFile := "out/soong/.intermediates/" + libName + "/" + variant + "/obj/" + foo + ".tidy"
|
|
depFiles := ctx.ModuleForTests(libName, variant).Rule(ruleName).Validations.Strings()
|
|
if test.needTidyFile[n] {
|
|
android.AssertStringListContains(t, libName+" needs .tidy file", depFiles, tidyFile)
|
|
} else {
|
|
android.AssertStringListDoesNotContain(t, libName+" does not need .tidy file", depFiles, tidyFile)
|
|
}
|
|
}
|
|
checkLibraryRule("foo", "android_arm64_armv8-a_shared", "ld")
|
|
checkLibraryRule("bar", "android_arm64_armv8-a_static", "ar")
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestWithGeneratedCode(t *testing.T) {
|
|
bp := `
|
|
cc_library_shared {
|
|
name: "libfoo",
|
|
srcs: ["foo_1.y", "foo_2.yy", "foo_3.l", "foo_4.ll", "foo_5.proto",
|
|
"foo_6.aidl", "foo_7.rscript", "foo_8.fs", "foo_9.sysprop",
|
|
"foo_src.cpp"],
|
|
tidy: true,
|
|
}`
|
|
variant := "android_arm64_armv8-a_shared"
|
|
|
|
testEnv := map[string]string{}
|
|
testEnv["ALLOW_LOCAL_TIDY_TRUE"] = "1"
|
|
|
|
ctx := android.GroupFixturePreparers(prepareForCcTest, android.FixtureMergeEnv(testEnv)).RunTestWithBp(t, bp)
|
|
|
|
t.Run("tidy should be only run for source code, not for generated code", func(t *testing.T) {
|
|
depFiles := ctx.ModuleForTests("libfoo", variant).Rule("ld").Validations.Strings()
|
|
|
|
tidyFileForCpp := "out/soong/.intermediates/libfoo/" + variant + "/obj/foo_src.tidy"
|
|
|
|
android.AssertArrayString(t,
|
|
"only one .tidy file for source code should exist for libfoo",
|
|
[]string{tidyFileForCpp}, depFiles)
|
|
})
|
|
}
|