This is an archive of the discontinued LLVM Phabricator instance.

Differential D104460

[clang][lex] NFC: Extract source variable in minimizer tests
AbandonedPublic

Authored by jansvoboda11 on Jun 17 2021, 6:37 AM.

Details

Reviewers
Bigcheese
dexonsmith
arphaman
Summary

This patch extracts the to-be-minimized source strings into variables. This will be useful in a follow up patch.

Depends on D104459.

Diff Detail

Event Timeline

jansvoboda11 requested review of this revision.Jun 17 2021, 6:37 AM
jansvoboda11 created this revision.
Herald added a project: Restricted Project. · View Herald TranscriptJun 17 2021, 6:37 AM
Herald added a subscriber: cfe-commits. · View Herald Transcript
jansvoboda11 abandoned this revision.Jun 17 2021, 7:32 AM

Found a way to do the thing in a follow up with less churn. Sorry for the noise.

Harbormaster completed remote builds in B109701: Diff 352706.Jun 17 2021, 3:39 PM

Revision Contents

PathSize
clang/
unittests/
Lex/
388 lines

Diff 352706

clang/unittests/Lex/DependencyDirectivesSourceMinimizerTest.cpp

Show All 24 Lines
} // end namespace clang } // end namespace clang
namespace { namespace {
TEST(MinimizeSourceToDependencyDirectivesTest, Empty) { TEST(MinimizeSourceToDependencyDirectivesTest, Empty) {
SmallVector<char, 128> Out; SmallVector<char, 128> Out;
SmallVector<Token, 4> Tokens; SmallVector<Token, 4> Tokens;
ASSERT_FALSE(minimizeSourceToDependencyDirectives("", Out, Tokens)); StringRef Source = "";
ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out, Tokens));
EXPECT_TRUE(Out.empty()); EXPECT_TRUE(Out.empty());
ASSERT_EQ(1u, Tokens.size()); ASSERT_EQ(1u, Tokens.size());
ASSERT_EQ(pp_eof, Tokens.back().K); ASSERT_EQ(pp_eof, Tokens.back().K);
ASSERT_FALSE( Source = "abc def\nxyz";
minimizeSourceToDependencyDirectives("abc def\nxyz", Out, Tokens)); ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out, Tokens));
EXPECT_TRUE(Out.empty()); EXPECT_TRUE(Out.empty());
ASSERT_EQ(1u, Tokens.size()); ASSERT_EQ(1u, Tokens.size());
ASSERT_EQ(pp_eof, Tokens.back().K); ASSERT_EQ(pp_eof, Tokens.back().K);
} }
TEST(MinimizeSourceToDependencyDirectivesTest, AllTokens) { TEST(MinimizeSourceToDependencyDirectivesTest, AllTokens) {
SmallVector<char, 128> Out; SmallVector<char, 128> Out;
SmallVector<Token, 4> Tokens; SmallVector<Token, 4> Tokens;
Show All 39 LinesTEST(MinimizeSourceToDependencyDirectivesTest, AllTokens) {
EXPECT_EQ(cxx_import_decl, Tokens[18].K); EXPECT_EQ(cxx_import_decl, Tokens[18].K);
EXPECT_EQ(pp_eof, Tokens[19].K); EXPECT_EQ(pp_eof, Tokens[19].K);
} }
TEST(MinimizeSourceToDependencyDirectivesTest, Define) { TEST(MinimizeSourceToDependencyDirectivesTest, Define) {
SmallVector<char, 128> Out; SmallVector<char, 128> Out;
SmallVector<Token, 4> Tokens; SmallVector<Token, 4> Tokens;
ASSERT_FALSE( StringRef Source = "#define MACRO";
minimizeSourceToDependencyDirectives("#define MACRO", Out, Tokens)); ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out, Tokens));
EXPECT_STREQ("#define MACRO", Out.data()); EXPECT_STREQ("#define MACRO", Out.data());
ASSERT_EQ(2u, Tokens.size()); ASSERT_EQ(2u, Tokens.size());
ASSERT_EQ(pp_define, Tokens.front().K); ASSERT_EQ(pp_define, Tokens.front().K);
} }
TEST(MinimizeSourceToDependencyDirectivesTest, DefineSpacing) { TEST(MinimizeSourceToDependencyDirectivesTest, DefineSpacing) {
SmallVector<char, 128> Out; SmallVector<char, 128> Out;
ASSERT_FALSE( StringRef Source = "#define MACRO\n\n\n";
minimizeSourceToDependencyDirectives("#define MACRO\n\n\n", Out)); ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
EXPECT_STREQ("#define MACRO\n", Out.data()); EXPECT_STREQ("#define MACRO\n", Out.data());
ASSERT_FALSE( Source = "#define MACRO \n\n\n";
minimizeSourceToDependencyDirectives("#define MACRO \n\n\n", Out)); ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
EXPECT_STREQ("#define MACRO\n", Out.data()); EXPECT_STREQ("#define MACRO\n", Out.data());
ASSERT_FALSE( Source = "#define MACRO a \n\n\n";
minimizeSourceToDependencyDirectives("#define MACRO a \n\n\n", Out)); ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
EXPECT_STREQ("#define MACRO a\n", Out.data()); EXPECT_STREQ("#define MACRO a\n", Out.data());
ASSERT_FALSE( Source = "#define MACRO\n\n\n";
minimizeSourceToDependencyDirectives("#define MACRO\n\n\n", Out)); ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
EXPECT_STREQ("#define MACRO\n", Out.data()); EXPECT_STREQ("#define MACRO\n", Out.data());
} }
TEST(MinimizeSourceToDependencyDirectivesTest, DefineMacroArguments) { TEST(MinimizeSourceToDependencyDirectivesTest, DefineMacroArguments) {
SmallVector<char, 128> Out; SmallVector<char, 128> Out;
ASSERT_FALSE(minimizeSourceToDependencyDirectives("#define MACRO()", Out)); StringRef Source = "#define MACRO()";
ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
EXPECT_STREQ("#define MACRO()", Out.data()); EXPECT_STREQ("#define MACRO()", Out.data());
ASSERT_FALSE( Source = "#define MACRO(a, b...)";
minimizeSourceToDependencyDirectives("#define MACRO(a, b...)", Out)); ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
EXPECT_STREQ("#define MACRO(a,b...)\n", Out.data()); EXPECT_STREQ("#define MACRO(a,b...)\n", Out.data());
ASSERT_FALSE( Source = "#define MACRO content";
minimizeSourceToDependencyDirectives("#define MACRO content", Out)); ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
EXPECT_STREQ("#define MACRO content", Out.data()); EXPECT_STREQ("#define MACRO content", Out.data());
ASSERT_FALSE(minimizeSourceToDependencyDirectives( Source = "#define MACRO con tent ";
"#define MACRO con tent ", Out)); ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
EXPECT_STREQ("#define MACRO con tent\n", Out.data()); EXPECT_STREQ("#define MACRO con tent\n", Out.data());
ASSERT_FALSE(minimizeSourceToDependencyDirectives( Source = "#define MACRO() con tent ";
"#define MACRO() con tent ", Out)); ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
EXPECT_STREQ("#define MACRO() con tent\n", Out.data()); EXPECT_STREQ("#define MACRO() con tent\n", Out.data());
} }
TEST(MinimizeSourceToDependencyDirectivesTest, DefineInvalidMacroArguments) { TEST(MinimizeSourceToDependencyDirectivesTest, DefineInvalidMacroArguments) {
SmallVector<char, 128> Out; SmallVector<char, 128> Out;
ASSERT_FALSE(minimizeSourceToDependencyDirectives("#define MACRO((a))", Out)); StringRef Source = "#define MACRO((a))";
ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
EXPECT_STREQ("#define MACRO\n", Out.data()); EXPECT_STREQ("#define MACRO\n", Out.data());
ASSERT_FALSE(minimizeSourceToDependencyDirectives("#define MACRO(", Out)); Source = "#define MACRO(";
ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
EXPECT_STREQ("#define MACRO\n", Out.data()); EXPECT_STREQ("#define MACRO\n", Out.data());
ASSERT_FALSE( Source = "#define MACRO(a * b)";
minimizeSourceToDependencyDirectives("#define MACRO(a * b)", Out)); ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
EXPECT_STREQ("#define MACRO\n", Out.data()); EXPECT_STREQ("#define MACRO\n", Out.data());
} }
TEST(MinimizeSourceToDependencyDirectivesTest, DefineHorizontalWhitespace) { TEST(MinimizeSourceToDependencyDirectivesTest, DefineHorizontalWhitespace) {
SmallVector<char, 128> Out; SmallVector<char, 128> Out;
ASSERT_FALSE(minimizeSourceToDependencyDirectives( StringRef Source = "#define MACRO(\t)\tcon \t tent\t";
"#define MACRO(\t)\tcon \t tent\t", Out)); ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
EXPECT_STREQ("#define MACRO() con \t tent\n", Out.data()); EXPECT_STREQ("#define MACRO() con \t tent\n", Out.data());
ASSERT_FALSE(minimizeSourceToDependencyDirectives( Source = "#define MACRO(\f)\fcon \f tent\f";
"#define MACRO(\f)\fcon \f tent\f", Out)); ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
EXPECT_STREQ("#define MACRO() con \f tent\n", Out.data()); EXPECT_STREQ("#define MACRO() con \f tent\n", Out.data());
ASSERT_FALSE(minimizeSourceToDependencyDirectives( Source = "#define MACRO(\v)\vcon \v tent\v";
"#define MACRO(\v)\vcon \v tent\v", Out)); ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
EXPECT_STREQ("#define MACRO() con \v tent\n", Out.data()); EXPECT_STREQ("#define MACRO() con \v tent\n", Out.data());
ASSERT_FALSE(minimizeSourceToDependencyDirectives( Source = "#define MACRO \t\v\f\v\t con\f\t\vtent\v\f \v";
"#define MACRO \t\v\f\v\t con\f\t\vtent\v\f \v", Out)); ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
EXPECT_STREQ("#define MACRO con\f\t\vtent\n", Out.data()); EXPECT_STREQ("#define MACRO con\f\t\vtent\n", Out.data());
} }
TEST(MinimizeSourceToDependencyDirectivesTest, DefineMultilineArgs) { TEST(MinimizeSourceToDependencyDirectivesTest, DefineMultilineArgs) {
SmallVector<char, 128> Out; SmallVector<char, 128> Out;
ASSERT_FALSE( StringRef Source = "#define MACRO(a \\\n"
minimizeSourceToDependencyDirectives("#define MACRO(a \\\n" " )";
" )", ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
Out));
EXPECT_STREQ("#define MACRO(a)\n", Out.data()); EXPECT_STREQ("#define MACRO(a)\n", Out.data());
ASSERT_FALSE( Source = "#define MACRO(a, \\\n"
minimizeSourceToDependencyDirectives("#define MACRO(a, \\\n"
" b) \\\n" " b) \\\n"
" call((a), \\\n" " call((a), \\\n"
" (b))", " (b))";
Out)); ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
EXPECT_STREQ("#define MACRO(a,b) call((a), (b))\n", Out.data()); EXPECT_STREQ("#define MACRO(a,b) call((a), (b))\n", Out.data());
} }
TEST(MinimizeSourceToDependencyDirectivesTest, TEST(MinimizeSourceToDependencyDirectivesTest,
DefineMultilineArgsCarriageReturn) { DefineMultilineArgsCarriageReturn) {
SmallVector<char, 128> Out; SmallVector<char, 128> Out;
ASSERT_FALSE( StringRef Source = "#define MACRO(a, \\\r"
minimizeSourceToDependencyDirectives("#define MACRO(a, \\\r"
" b) \\\r" " b) \\\r"
" call((a), \\\r" " call((a), \\\r"
" (b))", " (b))";
Out)); ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
EXPECT_STREQ("#define MACRO(a,b) call((a), (b))\n", Out.data()); EXPECT_STREQ("#define MACRO(a,b) call((a), (b))\n", Out.data());
} }
TEST(MinimizeSourceToDependencyDirectivesTest, DefineMultilineArgsStringize) { TEST(MinimizeSourceToDependencyDirectivesTest, DefineMultilineArgsStringize) {
SmallVector<char, 128> Out; SmallVector<char, 128> Out;
ASSERT_FALSE(minimizeSourceToDependencyDirectives("#define MACRO(a,b) \\\n" StringRef Source = "#define MACRO(a,b) \\\n"
" #a \\\n" " #a \\\n"
" #b", " #b";
Out)); ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
EXPECT_STREQ("#define MACRO(a,b) #a #b\n", Out.data()); EXPECT_STREQ("#define MACRO(a,b) #a #b\n", Out.data());
} }
TEST(MinimizeSourceToDependencyDirectivesTest, TEST(MinimizeSourceToDependencyDirectivesTest,
DefineMultilineArgsCarriageReturnNewline) { DefineMultilineArgsCarriageReturnNewline) {
SmallVector<char, 128> Out; SmallVector<char, 128> Out;
ASSERT_FALSE( StringRef Source = "#define MACRO(a, \\\r\n"
minimizeSourceToDependencyDirectives("#define MACRO(a, \\\r\n"
" b) \\\r\n" " b) \\\r\n"
" call((a), \\\r\n" " call((a), \\\r\n"
" (b))", " (b))";
Out)); ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
EXPECT_STREQ("#define MACRO(a,b) call((a), (b))\n", Out.data()); EXPECT_STREQ("#define MACRO(a,b) call((a), (b))\n", Out.data());
} }
TEST(MinimizeSourceToDependencyDirectivesTest, TEST(MinimizeSourceToDependencyDirectivesTest,
DefineMultilineArgsNewlineCarriageReturn) { DefineMultilineArgsNewlineCarriageReturn) {
SmallVector<char, 128> Out; SmallVector<char, 128> Out;
ASSERT_FALSE( StringRef Source = "#define MACRO(a, \\\n\r"
minimizeSourceToDependencyDirectives("#define MACRO(a, \\\n\r"
" b) \\\n\r" " b) \\\n\r"
" call((a), \\\n\r" " call((a), \\\n\r"
" (b))", " (b))";
Out)); ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
EXPECT_STREQ("#define MACRO(a,b) call((a), (b))\n", Out.data()); EXPECT_STREQ("#define MACRO(a,b) call((a), (b))\n", Out.data());
} }
TEST(MinimizeSourceToDependencyDirectivesTest, DefineNumber) { TEST(MinimizeSourceToDependencyDirectivesTest, DefineNumber) {
SmallVector<char, 128> Out; SmallVector<char, 128> Out;
ASSERT_TRUE(minimizeSourceToDependencyDirectives("#define 0\n", Out)); StringRef Source = "#define 0\n";
ASSERT_TRUE(minimizeSourceToDependencyDirectives(Source, Out));
} }
TEST(MinimizeSourceToDependencyDirectivesTest, DefineNoName) { TEST(MinimizeSourceToDependencyDirectivesTest, DefineNoName) {
SmallVector<char, 128> Out; SmallVector<char, 128> Out;
ASSERT_TRUE(minimizeSourceToDependencyDirectives("#define &\n", Out)); StringRef Source = "#define &\n";
ASSERT_TRUE(minimizeSourceToDependencyDirectives(Source, Out));
} }
TEST(MinimizeSourceToDependencyDirectivesTest, DefineNoWhitespace) { TEST(MinimizeSourceToDependencyDirectivesTest, DefineNoWhitespace) {
SmallVector<char, 128> Out; SmallVector<char, 128> Out;
ASSERT_FALSE(minimizeSourceToDependencyDirectives("#define AND&\n", Out)); StringRef Source = "#define AND&\n";
ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
EXPECT_STREQ("#define AND&\n", Out.data()); EXPECT_STREQ("#define AND&\n", Out.data());
ASSERT_FALSE(minimizeSourceToDependencyDirectives("#define AND\\\n" Source = "#define AND\\\n"
"&\n", "&\n";
Out)); ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
EXPECT_STREQ("#define AND &\n", Out.data()); EXPECT_STREQ("#define AND &\n", Out.data());
} }
TEST(MinimizeSourceToDependencyDirectivesTest, MultilineComment) { TEST(MinimizeSourceToDependencyDirectivesTest, MultilineComment) {
SmallVector<char, 128> Out; SmallVector<char, 128> Out;
ASSERT_FALSE( StringRef Source = "#define MACRO a/*\n"
minimizeSourceToDependencyDirectives("#define MACRO a/*\n"
" /*\n" " /*\n"
"#define MISSING abc\n" "#define MISSING abc\n"
" /*\n" " /*\n"
" /* something */ \n" " /* something */ \n"
"#include /* \"def\" */ <abc> \n", "#include /* \"def\" */ <abc> \n";
Out)); ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
EXPECT_STREQ("#define MACRO a\n" EXPECT_STREQ("#define MACRO a\n"
"#include <abc>\n", "#include <abc>\n",
Out.data()); Out.data());
} }
TEST(MinimizeSourceToDependencyDirectivesTest, MultilineCommentInStrings) { TEST(MinimizeSourceToDependencyDirectivesTest, MultilineCommentInStrings) {
SmallVector<char, 128> Out; SmallVector<char, 128> Out;
ASSERT_FALSE(minimizeSourceToDependencyDirectives("#define MACRO1 \"/*\"\n" StringRef Source = "#define MACRO1 \"/*\"\n"
"#define MACRO2 \"*/\"\n", "#define MACRO2 \"*/\"\n";
Out)); ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
EXPECT_STREQ("#define MACRO1 \"/*\"\n" EXPECT_STREQ("#define MACRO1 \"/*\"\n"
"#define MACRO2 \"*/\"\n", "#define MACRO2 \"*/\"\n",
Out.data()); Out.data());
} }
TEST(MinimizeSourceToDependencyDirectivesTest, Ifdef) { TEST(MinimizeSourceToDependencyDirectivesTest, Ifdef) {
SmallVector<char, 128> Out; SmallVector<char, 128> Out;
ASSERT_FALSE(minimizeSourceToDependencyDirectives("#ifdef A\n" StringRef Source = "#ifdef A\n"
"#define B\n" "#define B\n"
"#endif\n", "#endif\n";
Out)); ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
EXPECT_STREQ("#ifdef A\n" EXPECT_STREQ("#ifdef A\n"
"#define B\n" "#define B\n"
"#endif\n", "#endif\n",
Out.data()); Out.data());
ASSERT_FALSE(minimizeSourceToDependencyDirectives("#ifdef A\n" Source = "#ifdef A\n"
"#define B\n" "#define B\n"
"#elif B\n" "#elif B\n"
"#define C\n" "#define C\n"
"#elif C\n" "#elif C\n"
"#define D\n" "#define D\n"
"#else\n" "#else\n"
"#define E\n" "#define E\n"
"#endif\n", "#endif\n";
Out)); ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
EXPECT_STREQ("#ifdef A\n" EXPECT_STREQ("#ifdef A\n"
"#define B\n" "#define B\n"
"#elif B\n" "#elif B\n"
"#define C\n" "#define C\n"
"#elif C\n" "#elif C\n"
"#define D\n" "#define D\n"
"#else\n" "#else\n"
"#define E\n" "#define E\n"
"#endif\n", "#endif\n",
Out.data()); Out.data());
} }
TEST(MinimizeSourceToDependencyDirectivesTest, Elifdef) { TEST(MinimizeSourceToDependencyDirectivesTest, Elifdef) {
SmallVector<char, 128> Out; SmallVector<char, 128> Out;
ASSERT_FALSE(minimizeSourceToDependencyDirectives("#ifdef A\n" StringRef Source = "#ifdef A\n"
"#define B\n" "#define B\n"
"#elifdef C\n" "#elifdef C\n"
"#define D\n" "#define D\n"
"#endif\n", "#endif\n";
Out)); ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
EXPECT_STREQ("#ifdef A\n" EXPECT_STREQ("#ifdef A\n"
"#define B\n" "#define B\n"
"#elifdef C\n" "#elifdef C\n"
"#define D\n" "#define D\n"
"#endif\n", "#endif\n",
Out.data()); Out.data());
ASSERT_FALSE(minimizeSourceToDependencyDirectives("#ifdef A\n" Source = "#ifdef A\n"
"#define B\n" "#define B\n"
"#elifdef B\n" "#elifdef B\n"
"#define C\n" "#define C\n"
"#elifndef C\n" "#elifndef C\n"
"#define D\n" "#define D\n"
"#else\n" "#else\n"
"#define E\n" "#define E\n"
"#endif\n", "#endif\n";
Out)); ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
EXPECT_STREQ("#ifdef A\n" EXPECT_STREQ("#ifdef A\n"
"#define B\n" "#define B\n"
"#elifdef B\n" "#elifdef B\n"
"#define C\n" "#define C\n"
"#elifndef C\n" "#elifndef C\n"
"#define D\n" "#define D\n"
"#else\n" "#else\n"
"#define E\n" "#define E\n"
"#endif\n", "#endif\n",
Out.data()); Out.data());
} }
TEST(MinimizeSourceToDependencyDirectivesTest, EmptyIfdef) { TEST(MinimizeSourceToDependencyDirectivesTest, EmptyIfdef) {
SmallVector<char, 128> Out; SmallVector<char, 128> Out;
ASSERT_FALSE(minimizeSourceToDependencyDirectives("#ifdef A\n" StringRef Source = "#ifdef A\n"
"void skip();\n" "void skip();\n"
"#elif B\n" "#elif B\n"
"#elif C\n" "#elif C\n"
"#else D\n" "#else D\n"
"#endif\n", "#endif\n";
Out)); ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
EXPECT_STREQ("#ifdef A\n" EXPECT_STREQ("#ifdef A\n"
"#elif B\n" "#elif B\n"
"#elif C\n" "#elif C\n"
"#endif\n", "#endif\n",
Out.data()); Out.data());
} }
TEST(MinimizeSourceToDependencyDirectivesTest, EmptyElifdef) { TEST(MinimizeSourceToDependencyDirectivesTest, EmptyElifdef) {
SmallVector<char, 128> Out; SmallVector<char, 128> Out;
ASSERT_FALSE(minimizeSourceToDependencyDirectives("#ifdef A\n" StringRef Source = "#ifdef A\n"
"void skip();\n" "void skip();\n"
"#elifdef B\n" "#elifdef B\n"
"#elifndef C\n" "#elifndef C\n"
"#else D\n" "#else D\n"
"#endif\n", "#endif\n";
Out)); ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
EXPECT_STREQ("#ifdef A\n" EXPECT_STREQ("#ifdef A\n"
"#elifdef B\n" "#elifdef B\n"
"#elifndef C\n" "#elifndef C\n"
"#endif\n", "#endif\n",
Out.data()); Out.data());
} }
TEST(MinimizeSourceToDependencyDirectivesTest, Pragma) { TEST(MinimizeSourceToDependencyDirectivesTest, Pragma) {
SmallVector<char, 128> Out; SmallVector<char, 128> Out;
ASSERT_FALSE(minimizeSourceToDependencyDirectives("#pragma A\n", Out)); StringRef Source = "#pragma A\n";
ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
EXPECT_STREQ("", Out.data()); EXPECT_STREQ("", Out.data());
ASSERT_FALSE(minimizeSourceToDependencyDirectives("#pragma clang\n", Out)); Source = "#pragma clang\n";
ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
EXPECT_STREQ("", Out.data()); EXPECT_STREQ("", Out.data());
ASSERT_FALSE( Source = "#pragma clang module\n";
minimizeSourceToDependencyDirectives("#pragma clang module\n", Out)); ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
EXPECT_STREQ("", Out.data()); EXPECT_STREQ("", Out.data());
ASSERT_FALSE(minimizeSourceToDependencyDirectives( Source = "#pragma clang module impor\n";
"#pragma clang module impor\n", Out)); ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
EXPECT_STREQ("", Out.data()); EXPECT_STREQ("", Out.data());
ASSERT_FALSE(minimizeSourceToDependencyDirectives( Source = "#pragma clang module import\n";
"#pragma clang module import\n", Out)); ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
EXPECT_STREQ("#pragma clang module import\n", Out.data()); EXPECT_STREQ("#pragma clang module import\n", Out.data());
} }
TEST(MinimizeSourceToDependencyDirectivesTest, Include) { TEST(MinimizeSourceToDependencyDirectivesTest, Include) {
SmallVector<char, 128> Out; SmallVector<char, 128> Out;
ASSERT_FALSE(minimizeSourceToDependencyDirectives("#include \"A\"\n", Out)); StringRef Source = "#include \"A\"\n";
ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
EXPECT_STREQ("#include \"A\"\n", Out.data()); EXPECT_STREQ("#include \"A\"\n", Out.data());
ASSERT_FALSE(minimizeSourceToDependencyDirectives("#include <A>\n", Out)); Source = "#include <A>\n";
ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
EXPECT_STREQ("#include <A>\n", Out.data()); EXPECT_STREQ("#include <A>\n", Out.data());
ASSERT_FALSE( Source = "#include_next <A>\n";
minimizeSourceToDependencyDirectives("#include_next <A>\n", Out)); ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
EXPECT_STREQ("#include_next <A>\n", Out.data()); EXPECT_STREQ("#include_next <A>\n", Out.data());
ASSERT_FALSE(minimizeSourceToDependencyDirectives("#import <A>\n", Out)); Source = "#import <A>\n";
ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
EXPECT_STREQ("#import <A>\n", Out.data()); EXPECT_STREQ("#import <A>\n", Out.data());
ASSERT_FALSE( Source = "#__include_macros <A>\n";
minimizeSourceToDependencyDirectives("#__include_macros <A>\n", Out)); ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
EXPECT_STREQ("#__include_macros <A>\n", Out.data()); EXPECT_STREQ("#__include_macros <A>\n", Out.data());
} }
TEST(MinimizeSourceToDependencyDirectivesTest, AtImport) { TEST(MinimizeSourceToDependencyDirectivesTest, AtImport) {
SmallVector<char, 128> Out; SmallVector<char, 128> Out;
ASSERT_FALSE(minimizeSourceToDependencyDirectives("@import A;\n", Out)); StringRef Source = "@import A;\n";
ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
EXPECT_STREQ("@import A;\n", Out.data()); EXPECT_STREQ("@import A;\n", Out.data());
ASSERT_FALSE(minimizeSourceToDependencyDirectives(" @ import A;\n", Out)); Source = " @ import A;\n";
ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
EXPECT_STREQ("@import A;\n", Out.data()); EXPECT_STREQ("@import A;\n", Out.data());
ASSERT_FALSE(minimizeSourceToDependencyDirectives("@import A\n;", Out)); Source = "@import A\n;";
ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
EXPECT_STREQ("@import A;\n", Out.data()); EXPECT_STREQ("@import A;\n", Out.data());
ASSERT_FALSE(minimizeSourceToDependencyDirectives("@import A.B;\n", Out)); Source = "@import A.B;\n";
ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
EXPECT_STREQ("@import A.B;\n", Out.data()); EXPECT_STREQ("@import A.B;\n", Out.data());
ASSERT_FALSE(minimizeSourceToDependencyDirectives( Source = "@import /*x*/ A /*x*/ . /*x*/ B /*x*/ \n /*x*/ ; /*x*/";
"@import /*x*/ A /*x*/ . /*x*/ B /*x*/ \n /*x*/ ; /*x*/", Out)); ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
EXPECT_STREQ("@import A.B;\n", Out.data()); EXPECT_STREQ("@import A.B;\n", Out.data());
} }
TEST(MinimizeSourceToDependencyDirectivesTest, AtImportFailures) { TEST(MinimizeSourceToDependencyDirectivesTest, AtImportFailures) {
SmallVector<char, 128> Out; SmallVector<char, 128> Out;
ASSERT_TRUE(minimizeSourceToDependencyDirectives("@import A\n", Out)); StringRef Source = "@import A\n";
ASSERT_TRUE(minimizeSourceToDependencyDirectives("@import MACRO(A);\n", Out)); ASSERT_TRUE(minimizeSourceToDependencyDirectives(Source, Out));
ASSERT_TRUE(minimizeSourceToDependencyDirectives("@import \" \";\n", Out)); Source = "@import MACRO(A);\n";
ASSERT_TRUE(minimizeSourceToDependencyDirectives(Source, Out));
Source = "@import \" \";\n";
ASSERT_TRUE(minimizeSourceToDependencyDirectives(Source, Out));
} }
TEST(MinimizeSourceToDependencyDirectivesTest, RawStringLiteral) { TEST(MinimizeSourceToDependencyDirectivesTest, RawStringLiteral) {
SmallVector<char, 128> Out; SmallVector<char, 128> Out;
ASSERT_FALSE(minimizeSourceToDependencyDirectives("#ifndef GUARD\n" StringRef Source = "#ifndef GUARD\n"
"#define GUARD\n" "#define GUARD\n"
"R\"()\"\n" "R\"()\"\n"
"#endif\n", "#endif\n";
Out)); ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
EXPECT_STREQ("#ifndef GUARD\n" EXPECT_STREQ("#ifndef GUARD\n"
"#define GUARD\n" "#define GUARD\n"
"#endif\n", "#endif\n",
Out.data()); Out.data());
bool RawStringLiteralResult = minimizeSourceToDependencyDirectives( Source = "#ifndef GUARD\n"
"#ifndef GUARD\n"
"#define GUARD\n" "#define GUARD\n"
R"raw(static constexpr char bytes[] = R"(-?:\,[]{}#&*!|>'"%@`)";)raw" R"raw(static constexpr char bytes[] = R"(-?:\,[]{}#&*!|>'"%@`)";)raw"
"\n" "\n"
"#endif\n", "#endif\n";
Out); ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
ASSERT_FALSE(RawStringLiteralResult);
EXPECT_STREQ("#ifndef GUARD\n" EXPECT_STREQ("#ifndef GUARD\n"
"#define GUARD\n" "#define GUARD\n"
"#endif\n", "#endif\n",
Out.data()); Out.data());
bool RawStringLiteralResult2 = minimizeSourceToDependencyDirectives( Source =
"#ifndef GUARD\n" "#ifndef GUARD\n"
"#define GUARD\n" "#define GUARD\n"
R"raw(static constexpr char bytes[] = R"abc(-?:\,[]{}#&*!|>'"%@`)abc";)raw" R"raw(static constexpr char bytes[] = R"abc(-?:\,[]{}#&*!|>'"%@`)abc";)raw"
"\n" "\n"
"#endif\n", "#endif\n";
Out); ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
ASSERT_FALSE(RawStringLiteralResult2);
EXPECT_STREQ("#ifndef GUARD\n" EXPECT_STREQ("#ifndef GUARD\n"
"#define GUARD\n" "#define GUARD\n"
"#endif\n", "#endif\n",
Out.data()); Out.data());
} }
TEST(MinimizeSourceToDependencyDirectivesTest, SplitIdentifier) { TEST(MinimizeSourceToDependencyDirectivesTest, SplitIdentifier) {
SmallVector<char, 128> Out; SmallVector<char, 128> Out;
ASSERT_FALSE(minimizeSourceToDependencyDirectives("#if\\\n" StringRef Source = "#if\\\n"
"ndef GUARD\n" "ndef GUARD\n"
"#define GUARD\n" "#define GUARD\n"
"#endif\n", "#endif\n";
Out)); ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
EXPECT_STREQ("#ifndef GUARD\n" EXPECT_STREQ("#ifndef GUARD\n"
"#define GUARD\n" "#define GUARD\n"
"#endif\n", "#endif\n",
Out.data()); Out.data());
ASSERT_FALSE(minimizeSourceToDependencyDirectives("#define GUA\\\n" Source = "#define GUA\\\n"
"RD\n", "RD\n";
Out)); ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
EXPECT_STREQ("#define GUARD\n", Out.data()); EXPECT_STREQ("#define GUARD\n", Out.data());
ASSERT_FALSE(minimizeSourceToDependencyDirectives("#define GUA\\\r" Source = "#define GUA\\\r"
"RD\n", "RD\n";
Out)); ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
EXPECT_STREQ("#define GUARD\n", Out.data()); EXPECT_STREQ("#define GUARD\n", Out.data());
ASSERT_FALSE(minimizeSourceToDependencyDirectives("#define GUA\\\n" Source = "#define GUA\\\n"
" RD\n", " RD\n";
Out)); ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
EXPECT_STREQ("#define GUA RD\n", Out.data()); EXPECT_STREQ("#define GUA RD\n", Out.data());
} }
TEST(MinimizeSourceToDependencyDirectivesTest, TEST(MinimizeSourceToDependencyDirectivesTest,
WhitespaceAfterLineContinuationSlash) { WhitespaceAfterLineContinuationSlash) {
SmallVector<char, 128> Out; SmallVector<char, 128> Out;
ASSERT_FALSE(minimizeSourceToDependencyDirectives("#define A 1 + \\ \n" StringRef Source = "#define A 1 + \\ \n"
"2 + \\\t\n" "2 + \\\t\n"
"3\n", "3\n";
Out)); ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
EXPECT_STREQ("#define A 1 + 2 + 3\n", Out.data()); EXPECT_STREQ("#define A 1 + 2 + 3\n", Out.data());
} }
TEST(MinimizeSourceToDependencyDirectivesTest, PoundWarningAndError) { TEST(MinimizeSourceToDependencyDirectivesTest, PoundWarningAndError) {
SmallVector<char, 128> Out; SmallVector<char, 128> Out;
for (auto Source : { for (StringRef Source : {
"#warning '\n#include <t.h>\n", "#warning '\n#include <t.h>\n",
"#warning \"\n#include <t.h>\n", "#warning \"\n#include <t.h>\n",
"#warning /*\n#include <t.h>\n", "#warning /*\n#include <t.h>\n",
"#warning \\\n#include <t.h>\n#include <t.h>\n", "#warning \\\n#include <t.h>\n#include <t.h>\n",
"#error '\n#include <t.h>\n", "#error '\n#include <t.h>\n",
"#error \"\n#include <t.h>\n", "#error \"\n#include <t.h>\n",
"#error /*\n#include <t.h>\n", "#error /*\n#include <t.h>\n",
"#error \\\n#include <t.h>\n#include <t.h>\n", "#error \\\n#include <t.h>\n#include <t.h>\n",
}) { }) {
ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out)); ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
EXPECT_STREQ("#include <t.h>\n", Out.data()); EXPECT_STREQ("#include <t.h>\n", Out.data());
} }
for (auto Source : { for (StringRef Source : {
"#warning \\\n#include <t.h>\n", "#warning \\\n#include <t.h>\n",
"#error \\\n#include <t.h>\n", "#error \\\n#include <t.h>\n",
}) { }) {
ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out)); ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
EXPECT_STREQ("", Out.data()); EXPECT_STREQ("", Out.data());
} }
for (auto Source : { for (StringRef Source : {
"#if MACRO\n#warning '\n#endif\n", "#if MACRO\n#warning '\n#endif\n",
"#if MACRO\n#warning \"\n#endif\n", "#if MACRO\n#warning \"\n#endif\n",
"#if MACRO\n#warning /*\n#endif\n", "#if MACRO\n#warning /*\n#endif\n",
"#if MACRO\n#error '\n#endif\n", "#if MACRO\n#error '\n#endif\n",
"#if MACRO\n#error \"\n#endif\n", "#if MACRO\n#error \"\n#endif\n",
"#if MACRO\n#error /*\n#endif\n", "#if MACRO\n#error /*\n#endif\n",
}) { }) {
ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out)); ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out));
▲ Show 20 Lines • Show All 233 Lines • Show Last 20 Lines