This is an archive of the discontinued LLVM Phabricator instance.

Differential D92826

[clang][cli] CompilerInvocationTest: rename member variable in fixture
ClosedPublic

Authored by jansvoboda11 on Dec 8 2020, 3:52 AM.

Details

Reviewers
dexonsmith
a.sidorin
Commits
rGf825ec86e14b: [clang][cli] CompilerInvocationTest: rename member variable in fixture
Summary

Depends on D92825.

Diff Detail

Revision Contents

PathSize
clang/
unittests/
Frontend/
70 lines

Diff 310431

clang/unittests/Frontend/CompilerInvocationTest.cpp

Show All 21 Lines
using ::testing::StrNe; using ::testing::StrNe;
namespace { namespace {
class CommandLineTest : public ::testing::Test { class CommandLineTest : public ::testing::Test {
public: public:
IntrusiveRefCntPtr<DiagnosticsEngine> Diags; IntrusiveRefCntPtr<DiagnosticsEngine> Diags;
SmallVector<const char *, 32> GeneratedArgs; SmallVector<const char *, 32> GeneratedArgs;
SmallVector<std::string, 32> GeneratedArgsStorage; SmallVector<std::string, 32> GeneratedArgsStorage;
CompilerInvocation CInvok; CompilerInvocation Invocation;
const char *operator()(const Twine &Arg) { const char *operator()(const Twine &Arg) {
return GeneratedArgsStorage.emplace_back(Arg.str()).c_str(); return GeneratedArgsStorage.emplace_back(Arg.str()).c_str();
} }
CommandLineTest() CommandLineTest()
: Diags(CompilerInstance::createDiagnostics(new DiagnosticOptions())) {} : Diags(CompilerInstance::createDiagnostics(new DiagnosticOptions())) {}
}; };
TEST_F(CommandLineTest, OptIsInitializedWithCustomDefaultValue) { TEST_F(CommandLineTest, OptIsInitializedWithCustomDefaultValue) {
const char *Args[] = {"clang", "-xc++"}; const char *Args[] = {"clang", "-xc++"};
CompilerInvocation::CreateFromArgs(CInvok, Args, *Diags); CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags);
ASSERT_TRUE(CInvok.getFrontendOpts().UseTemporary); ASSERT_TRUE(Invocation.getFrontendOpts().UseTemporary);
} }
TEST_F(CommandLineTest, OptOfNegativeFlagIsPopulatedWithFalse) { TEST_F(CommandLineTest, OptOfNegativeFlagIsPopulatedWithFalse) {
const char *Args[] = {"clang", "-xc++", "-fno-temp-file"}; const char *Args[] = {"clang", "-xc++", "-fno-temp-file"};
CompilerInvocation::CreateFromArgs(CInvok, Args, *Diags); CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags);
ASSERT_FALSE(CInvok.getFrontendOpts().UseTemporary); ASSERT_FALSE(Invocation.getFrontendOpts().UseTemporary);
} }
TEST_F(CommandLineTest, OptsOfImpliedPositiveFlagArePopulatedWithTrue) { TEST_F(CommandLineTest, OptsOfImpliedPositiveFlagArePopulatedWithTrue) {
const char *Args[] = {"clang", "-xc++", "-cl-unsafe-math-optimizations"}; const char *Args[] = {"clang", "-xc++", "-cl-unsafe-math-optimizations"};
CompilerInvocation::CreateFromArgs(CInvok, Args, *Diags); CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags);
// Explicitly provided flag. // Explicitly provided flag.
ASSERT_TRUE(CInvok.getLangOpts()->CLUnsafeMath); ASSERT_TRUE(Invocation.getLangOpts()->CLUnsafeMath);
// Flags directly implied by explicitly provided flag. // Flags directly implied by explicitly provided flag.
ASSERT_TRUE(CInvok.getCodeGenOpts().LessPreciseFPMAD); ASSERT_TRUE(Invocation.getCodeGenOpts().LessPreciseFPMAD);
ASSERT_TRUE(CInvok.getLangOpts()->UnsafeFPMath); ASSERT_TRUE(Invocation.getLangOpts()->UnsafeFPMath);
// Flag transitively implied by explicitly provided flag. // Flag transitively implied by explicitly provided flag.
ASSERT_TRUE(CInvok.getLangOpts()->AllowRecip); ASSERT_TRUE(Invocation.getLangOpts()->AllowRecip);
} }
TEST_F(CommandLineTest, CanGenerateCC1CommandLineFlag) { TEST_F(CommandLineTest, CanGenerateCC1CommandLineFlag) {
const char *Args[] = {"clang", "-xc++", "-fmodules-strict-context-hash", "-"}; const char *Args[] = {"clang", "-xc++", "-fmodules-strict-context-hash", "-"};
CompilerInvocation::CreateFromArgs(CInvok, Args, *Diags); CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags);
CInvok.generateCC1CommandLine(GeneratedArgs, *this); Invocation.generateCC1CommandLine(GeneratedArgs, *this);
ASSERT_THAT(GeneratedArgs, Contains(StrEq("-fmodules-strict-context-hash"))); ASSERT_THAT(GeneratedArgs, Contains(StrEq("-fmodules-strict-context-hash")));
} }
TEST_F(CommandLineTest, CanGenerateCC1CommandLineSeparate) { TEST_F(CommandLineTest, CanGenerateCC1CommandLineSeparate) {
const char *TripleCStr = "i686-apple-darwin9"; const char *TripleCStr = "i686-apple-darwin9";
const char *Args[] = {"clang", "-xc++", "-triple", TripleCStr, "-"}; const char *Args[] = {"clang", "-xc++", "-triple", TripleCStr, "-"};
CompilerInvocation::CreateFromArgs(CInvok, Args, *Diags); CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags);
CInvok.generateCC1CommandLine(GeneratedArgs, *this); Invocation.generateCC1CommandLine(GeneratedArgs, *this);
ASSERT_THAT(GeneratedArgs, Contains(StrEq(TripleCStr))); ASSERT_THAT(GeneratedArgs, Contains(StrEq(TripleCStr)));
} }
TEST_F(CommandLineTest, CanGenerateCC1CommandLineSeparateRequiredPresent) { TEST_F(CommandLineTest, CanGenerateCC1CommandLineSeparateRequiredPresent) {
const std::string DefaultTriple = const std::string DefaultTriple =
llvm::Triple::normalize(llvm::sys::getDefaultTargetTriple()); llvm::Triple::normalize(llvm::sys::getDefaultTargetTriple());
const char *Args[] = {"clang", "-xc++", "-triple", DefaultTriple.c_str(), const char *Args[] = {"clang", "-xc++", "-triple", DefaultTriple.c_str(),
"-"}; "-"};
CompilerInvocation::CreateFromArgs(CInvok, Args, *Diags); CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags);
CInvok.generateCC1CommandLine(GeneratedArgs, *this); Invocation.generateCC1CommandLine(GeneratedArgs, *this);
// Triple should always be emitted even if it is the default // Triple should always be emitted even if it is the default
ASSERT_THAT(GeneratedArgs, Contains(StrEq(DefaultTriple.c_str()))); ASSERT_THAT(GeneratedArgs, Contains(StrEq(DefaultTriple.c_str())));
} }
TEST_F(CommandLineTest, CanGenerateCC1CommandLineSeparateRequiredAbsent) { TEST_F(CommandLineTest, CanGenerateCC1CommandLineSeparateRequiredAbsent) {
const std::string DefaultTriple = const std::string DefaultTriple =
llvm::Triple::normalize(llvm::sys::getDefaultTargetTriple()); llvm::Triple::normalize(llvm::sys::getDefaultTargetTriple());
const char *Args[] = {"clang", "-xc++", "-"}; const char *Args[] = {"clang", "-xc++", "-"};
CompilerInvocation::CreateFromArgs(CInvok, Args, *Diags); CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags);
CInvok.generateCC1CommandLine(GeneratedArgs, *this); Invocation.generateCC1CommandLine(GeneratedArgs, *this);
// Triple should always be emitted even if it is the default // Triple should always be emitted even if it is the default
ASSERT_THAT(GeneratedArgs, Contains(StrEq(DefaultTriple.c_str()))); ASSERT_THAT(GeneratedArgs, Contains(StrEq(DefaultTriple.c_str())));
} }
TEST_F(CommandLineTest, CanGenerateCC1CommandLineSeparateEnum) { TEST_F(CommandLineTest, CanGenerateCC1CommandLineSeparateEnum) {
const char *RelocationModelCStr = "static"; const char *RelocationModelCStr = "static";
const char *Args[] = {"clang", "-xc++", "-mrelocation-model", const char *Args[] = {"clang", "-xc++", "-mrelocation-model",
RelocationModelCStr, "-"}; RelocationModelCStr, "-"};
CompilerInvocation::CreateFromArgs(CInvok, Args, *Diags); CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags);
CInvok.generateCC1CommandLine(GeneratedArgs, *this); Invocation.generateCC1CommandLine(GeneratedArgs, *this);
// Non default relocation model // Non default relocation model
ASSERT_THAT(GeneratedArgs, Contains(StrEq(RelocationModelCStr))); ASSERT_THAT(GeneratedArgs, Contains(StrEq(RelocationModelCStr)));
GeneratedArgs.clear(); GeneratedArgs.clear();
RelocationModelCStr = "pic"; RelocationModelCStr = "pic";
Args[3] = RelocationModelCStr; Args[3] = RelocationModelCStr;
CompilerInvocation CInvok1; CompilerInvocation Invocation2;
CompilerInvocation::CreateFromArgs(CInvok1, Args, *Diags); CompilerInvocation::CreateFromArgs(Invocation2, Args, *Diags);
CInvok1.generateCC1CommandLine(GeneratedArgs, *this); Invocation2.generateCC1CommandLine(GeneratedArgs, *this);
ASSERT_THAT(GeneratedArgs, Each(StrNe(RelocationModelCStr))); ASSERT_THAT(GeneratedArgs, Each(StrNe(RelocationModelCStr)));
} }
TEST_F(CommandLineTest, NotPresentNegativeFlagNotGenerated) { TEST_F(CommandLineTest, NotPresentNegativeFlagNotGenerated) {
const char *Args[] = {"clang", "-xc++"}; const char *Args[] = {"clang", "-xc++"};
CompilerInvocation::CreateFromArgs(CInvok, Args, *Diags); CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags);
CInvok.generateCC1CommandLine(GeneratedArgs, *this); Invocation.generateCC1CommandLine(GeneratedArgs, *this);
ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-fno-temp-file")))); ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-fno-temp-file"))));
} }
TEST_F(CommandLineTest, PresentNegativeFlagGenerated) { TEST_F(CommandLineTest, PresentNegativeFlagGenerated) {
const char *Args[] = {"clang", "-xc++", "-fno-temp-file"}; const char *Args[] = {"clang", "-xc++", "-fno-temp-file"};
CompilerInvocation::CreateFromArgs(CInvok, Args, *Diags); CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags);
CInvok.generateCC1CommandLine(GeneratedArgs, *this); Invocation.generateCC1CommandLine(GeneratedArgs, *this);
ASSERT_THAT(GeneratedArgs, Contains(StrEq("-fno-temp-file"))); ASSERT_THAT(GeneratedArgs, Contains(StrEq("-fno-temp-file")));
} }
TEST_F(CommandLineTest, NotPresentAndNotImpliedNotGenerated) { TEST_F(CommandLineTest, NotPresentAndNotImpliedNotGenerated) {
const char *Args[] = {"clang", "-xc++"}; const char *Args[] = {"clang", "-xc++"};
CompilerInvocation::CreateFromArgs(CInvok, Args, *Diags); CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags);
CInvok.generateCC1CommandLine(GeneratedArgs, *this); Invocation.generateCC1CommandLine(GeneratedArgs, *this);
// Missing options are not generated. // Missing options are not generated.
ASSERT_THAT(GeneratedArgs, ASSERT_THAT(GeneratedArgs,
Not(Contains(StrEq("-cl-unsafe-math-optimizations")))); Not(Contains(StrEq("-cl-unsafe-math-optimizations"))));
ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-cl-mad-enable")))); ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-cl-mad-enable"))));
ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-menable-unsafe-fp-math")))); ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-menable-unsafe-fp-math"))));
} }
TEST_F(CommandLineTest, NotPresentAndImpliedNotGenerated) { TEST_F(CommandLineTest, NotPresentAndImpliedNotGenerated) {
const char *Args[] = {"clang", "-xc++", "-cl-unsafe-math-optimizations"}; const char *Args[] = {"clang", "-xc++", "-cl-unsafe-math-optimizations"};
CompilerInvocation::CreateFromArgs(CInvok, Args, *Diags); CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags);
CInvok.generateCC1CommandLine(GeneratedArgs, *this); Invocation.generateCC1CommandLine(GeneratedArgs, *this);
// Missing options that were implied are not generated. // Missing options that were implied are not generated.
ASSERT_THAT(GeneratedArgs, Contains(StrEq("-cl-unsafe-math-optimizations"))); ASSERT_THAT(GeneratedArgs, Contains(StrEq("-cl-unsafe-math-optimizations")));
ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-cl-mad-enable")))); ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-cl-mad-enable"))));
ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-menable-unsafe-fp-math")))); ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-menable-unsafe-fp-math"))));
} }
TEST_F(CommandLineTest, PresentAndImpliedNotGenerated) { TEST_F(CommandLineTest, PresentAndImpliedNotGenerated) {
const char *Args[] = {"clang", "-xc++", "-cl-unsafe-math-optimizations", const char *Args[] = {"clang", "-xc++", "-cl-unsafe-math-optimizations",
"-cl-mad-enable", "-menable-unsafe-fp-math"}; "-cl-mad-enable", "-menable-unsafe-fp-math"};
CompilerInvocation::CreateFromArgs(CInvok, Args, *Diags); CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags);
CInvok.generateCC1CommandLine(GeneratedArgs, *this); Invocation.generateCC1CommandLine(GeneratedArgs, *this);
// Present options that were also implied are not generated. // Present options that were also implied are not generated.
ASSERT_THAT(GeneratedArgs, Contains(StrEq("-cl-unsafe-math-optimizations"))); ASSERT_THAT(GeneratedArgs, Contains(StrEq("-cl-unsafe-math-optimizations")));
ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-cl-mad-enable")))); ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-cl-mad-enable"))));
ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-menable-unsafe-fp-math")))); ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-menable-unsafe-fp-math"))));
} }
TEST_F(CommandLineTest, PresentAndNotImpliedGenerated) { TEST_F(CommandLineTest, PresentAndNotImpliedGenerated) {
const char *Args[] = {"clang", "-xc++", "-cl-mad-enable", const char *Args[] = {"clang", "-xc++", "-cl-mad-enable",
"-menable-unsafe-fp-math"}; "-menable-unsafe-fp-math"};
CompilerInvocation::CreateFromArgs(CInvok, Args, *Diags); CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags);
CInvok.generateCC1CommandLine(GeneratedArgs, *this); Invocation.generateCC1CommandLine(GeneratedArgs, *this);
// Present options that were not implied are generated. // Present options that were not implied are generated.
ASSERT_THAT(GeneratedArgs, Contains(StrEq("-cl-mad-enable"))); ASSERT_THAT(GeneratedArgs, Contains(StrEq("-cl-mad-enable")));
ASSERT_THAT(GeneratedArgs, Contains(StrEq("-menable-unsafe-fp-math"))); ASSERT_THAT(GeneratedArgs, Contains(StrEq("-menable-unsafe-fp-math")));
} }
} // anonymous namespace } // anonymous namespace