forked from OSchip/llvm-project
430 lines
13 KiB
C++
430 lines
13 KiB
C++
//===- unittest/Format/FormatTestCSharp.cpp - Formatting tests for CSharp -===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "FormatTestUtils.h"
|
|
#include "clang/Format/Format.h"
|
|
#include "llvm/Support/Debug.h"
|
|
#include "gtest/gtest.h"
|
|
|
|
#define DEBUG_TYPE "format-test"
|
|
|
|
namespace clang {
|
|
namespace format {
|
|
|
|
class FormatTestCSharp : public ::testing::Test {
|
|
protected:
|
|
static std::string format(llvm::StringRef Code, unsigned Offset,
|
|
unsigned Length, const FormatStyle &Style) {
|
|
LLVM_DEBUG(llvm::errs() << "---\n");
|
|
LLVM_DEBUG(llvm::errs() << Code << "\n\n");
|
|
std::vector<tooling::Range> Ranges(1, tooling::Range(Offset, Length));
|
|
tooling::Replacements Replaces = reformat(Style, Code, Ranges);
|
|
auto Result = applyAllReplacements(Code, Replaces);
|
|
EXPECT_TRUE(static_cast<bool>(Result));
|
|
LLVM_DEBUG(llvm::errs() << "\n" << *Result << "\n\n");
|
|
return *Result;
|
|
}
|
|
|
|
static std::string
|
|
format(llvm::StringRef Code,
|
|
const FormatStyle &Style = getMicrosoftStyle(FormatStyle::LK_CSharp)) {
|
|
return format(Code, 0, Code.size(), Style);
|
|
}
|
|
|
|
static FormatStyle getStyleWithColumns(unsigned ColumnLimit) {
|
|
FormatStyle Style = getMicrosoftStyle(FormatStyle::LK_CSharp);
|
|
Style.ColumnLimit = ColumnLimit;
|
|
return Style;
|
|
}
|
|
|
|
static void verifyFormat(
|
|
llvm::StringRef Code,
|
|
const FormatStyle &Style = getMicrosoftStyle(FormatStyle::LK_CSharp)) {
|
|
EXPECT_EQ(Code.str(), format(Code, Style)) << "Expected code is not stable";
|
|
EXPECT_EQ(Code.str(), format(test::messUp(Code), Style));
|
|
}
|
|
};
|
|
|
|
TEST_F(FormatTestCSharp, CSharpClass) {
|
|
verifyFormat("public class SomeClass\n"
|
|
"{\n"
|
|
" void f()\n"
|
|
" {\n"
|
|
" }\n"
|
|
" int g()\n"
|
|
" {\n"
|
|
" return 0;\n"
|
|
" }\n"
|
|
" void h()\n"
|
|
" {\n"
|
|
" while (true)\n"
|
|
" f();\n"
|
|
" for (;;)\n"
|
|
" f();\n"
|
|
" if (true)\n"
|
|
" f();\n"
|
|
" }\n"
|
|
"}");
|
|
}
|
|
|
|
TEST_F(FormatTestCSharp, AccessModifiers) {
|
|
verifyFormat("public String toString()\n"
|
|
"{\n"
|
|
"}");
|
|
verifyFormat("private String toString()\n"
|
|
"{\n"
|
|
"}");
|
|
verifyFormat("protected String toString()\n"
|
|
"{\n"
|
|
"}");
|
|
verifyFormat("internal String toString()\n"
|
|
"{\n"
|
|
"}");
|
|
|
|
verifyFormat("public override String toString()\n"
|
|
"{\n"
|
|
"}");
|
|
verifyFormat("private override String toString()\n"
|
|
"{\n"
|
|
"}");
|
|
verifyFormat("protected override String toString()\n"
|
|
"{\n"
|
|
"}");
|
|
verifyFormat("internal override String toString()\n"
|
|
"{\n"
|
|
"}");
|
|
|
|
verifyFormat("internal static String toString()\n"
|
|
"{\n"
|
|
"}");
|
|
}
|
|
|
|
TEST_F(FormatTestCSharp, NoStringLiteralBreaks) {
|
|
verifyFormat("foo("
|
|
"\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
|
|
"aaaaaa\");");
|
|
}
|
|
|
|
TEST_F(FormatTestCSharp, CSharpVerbatiumStringLiterals) {
|
|
verifyFormat("foo(@\"aaaaaaaa\\abc\\aaaa\");");
|
|
// @"ABC\" + ToString("B") - handle embedded \ in literal string at
|
|
// the end
|
|
//
|
|
/*
|
|
* After removal of Lexer change we are currently not able
|
|
* To handle these cases
|
|
verifyFormat("string s = @\"ABC\\\" + ToString(\"B\");");
|
|
verifyFormat("string s = @\"ABC\"\"DEF\"\"GHI\"");
|
|
verifyFormat("string s = @\"ABC\"\"DEF\"\"\"");
|
|
verifyFormat("string s = @\"ABC\"\"DEF\"\"\" + abc");
|
|
*/
|
|
}
|
|
|
|
TEST_F(FormatTestCSharp, CSharpInterpolatedStringLiterals) {
|
|
verifyFormat("foo($\"aaaaaaaa{aaa}aaaa\");");
|
|
verifyFormat("foo($\"aaaa{A}\");");
|
|
verifyFormat(
|
|
"foo($\"aaaa{A}"
|
|
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\");");
|
|
verifyFormat("Name = $\"{firstName} {lastName}\";");
|
|
|
|
// $"ABC\" + ToString("B") - handle embedded \ in literal string at
|
|
// the end
|
|
verifyFormat("string s = $\"A{abc}BC\" + ToString(\"B\");");
|
|
verifyFormat("$\"{domain}\\\\{user}\"");
|
|
verifyFormat(
|
|
"var verbatimInterpolated = $@\"C:\\Users\\{userName}\\Documents\\\";");
|
|
}
|
|
|
|
TEST_F(FormatTestCSharp, CSharpFatArrows) {
|
|
verifyFormat("Task serverTask = Task.Run(async() => {");
|
|
verifyFormat("public override string ToString() => \"{Name}\\{Age}\";");
|
|
}
|
|
|
|
TEST_F(FormatTestCSharp, CSharpNullConditional) {
|
|
FormatStyle Style = getGoogleStyle(FormatStyle::LK_CSharp);
|
|
Style.SpaceBeforeParens = FormatStyle::SBPO_Always;
|
|
|
|
verifyFormat(
|
|
"public Person(string firstName, string lastName, int? age=null)");
|
|
|
|
verifyFormat("foo () {\n"
|
|
" switch (args?.Length) {}\n"
|
|
"}",
|
|
Style);
|
|
|
|
verifyFormat("switch (args?.Length) {}", Style);
|
|
|
|
verifyFormat("public static void Main(string[] args)\n"
|
|
"{\n"
|
|
" string dirPath = args?[0];\n"
|
|
"}");
|
|
|
|
Style.SpaceBeforeParens = FormatStyle::SBPO_Never;
|
|
|
|
verifyFormat("switch(args?.Length) {}", Style);
|
|
}
|
|
|
|
TEST_F(FormatTestCSharp, Attributes) {
|
|
verifyFormat("[STAThread]\n"
|
|
"static void Main(string[] args)\n"
|
|
"{\n"
|
|
"}");
|
|
|
|
verifyFormat("[TestMethod]\n"
|
|
"private class Test\n"
|
|
"{\n"
|
|
"}");
|
|
|
|
verifyFormat("[TestMethod]\n"
|
|
"protected class Test\n"
|
|
"{\n"
|
|
"}");
|
|
|
|
verifyFormat("[TestMethod]\n"
|
|
"internal class Test\n"
|
|
"{\n"
|
|
"}");
|
|
|
|
verifyFormat("[TestMethod]\n"
|
|
"class Test\n"
|
|
"{\n"
|
|
"}");
|
|
|
|
verifyFormat("[TestMethod]\n"
|
|
"[DeploymentItem(\"Test.txt\")]\n"
|
|
"public class Test\n"
|
|
"{\n"
|
|
"}");
|
|
|
|
verifyFormat("[System.AttributeUsage(System.AttributeTargets.Method)]\n"
|
|
"[System.Runtime.InteropServices.ComVisible(true)]\n"
|
|
"public sealed class STAThreadAttribute : Attribute\n"
|
|
"{\n"
|
|
"}");
|
|
|
|
verifyFormat("[Verb(\"start\", HelpText = \"Starts the server listening on "
|
|
"provided port\")]\n"
|
|
"class Test\n"
|
|
"{\n"
|
|
"}");
|
|
|
|
verifyFormat("[TestMethod]\n"
|
|
"public string Host\n"
|
|
"{\n"
|
|
" set;\n"
|
|
" get;\n"
|
|
"}");
|
|
|
|
verifyFormat("[TestMethod(\"start\", HelpText = \"Starts the server "
|
|
"listening on provided host\")]\n"
|
|
"public string Host\n"
|
|
"{\n"
|
|
" set;\n"
|
|
" get;\n"
|
|
"}");
|
|
}
|
|
|
|
TEST_F(FormatTestCSharp, CSharpUsing) {
|
|
FormatStyle Style = getGoogleStyle(FormatStyle::LK_CSharp);
|
|
Style.SpaceBeforeParens = FormatStyle::SBPO_Always;
|
|
verifyFormat("public void foo () {\n"
|
|
" using (StreamWriter sw = new StreamWriter (filenameA)) {}\n"
|
|
" using () {}\n"
|
|
"}",
|
|
Style);
|
|
|
|
// Ensure clang-format affects top-level snippets correctly.
|
|
verifyFormat("using (StreamWriter sw = new StreamWriter (filenameB)) {}",
|
|
Style);
|
|
|
|
Style.SpaceBeforeParens = FormatStyle::SBPO_Never;
|
|
verifyFormat("public void foo() {\n"
|
|
" using(StreamWriter sw = new StreamWriter(filenameB)) {}\n"
|
|
" using() {}\n"
|
|
"}",
|
|
Style);
|
|
|
|
// Ensure clang-format affects top-level snippets correctly.
|
|
verifyFormat("using(StreamWriter sw = new StreamWriter(filenameB)) {}",
|
|
Style);
|
|
|
|
Style.SpaceBeforeParens = FormatStyle::SBPO_ControlStatements;
|
|
verifyFormat("public void foo() {\n"
|
|
" using (StreamWriter sw = new StreamWriter(filenameA)) {}\n"
|
|
" using () {}\n"
|
|
"}",
|
|
Style);
|
|
|
|
// Ensure clang-format affects top-level snippets correctly.
|
|
verifyFormat("using (StreamWriter sw = new StreamWriter(filenameB)) {}",
|
|
Style);
|
|
|
|
Style.SpaceBeforeParens = FormatStyle::SBPO_NonEmptyParentheses;
|
|
verifyFormat("public void foo() {\n"
|
|
" using (StreamWriter sw = new StreamWriter (filenameA)) {}\n"
|
|
" using() {}\n"
|
|
"}",
|
|
Style);
|
|
|
|
// Ensure clang-format affects top-level snippets correctly.
|
|
verifyFormat("using (StreamWriter sw = new StreamWriter (filenameB)) {}",
|
|
Style);
|
|
}
|
|
|
|
TEST_F(FormatTestCSharp, CSharpRegions) {
|
|
verifyFormat("#region aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaa "
|
|
"aaaaaaaaaaaaaaa long region");
|
|
}
|
|
|
|
TEST_F(FormatTestCSharp, CSharpKeyWordEscaping) {
|
|
verifyFormat("public enum var { none, @string, bool, @enum }");
|
|
}
|
|
|
|
TEST_F(FormatTestCSharp, CSharpNullCoalescing) {
|
|
verifyFormat("var test = ABC ?? DEF");
|
|
verifyFormat("string myname = name ?? \"ABC\";");
|
|
verifyFormat("return _name ?? \"DEF\";");
|
|
}
|
|
|
|
TEST_F(FormatTestCSharp, AttributesIndentation) {
|
|
FormatStyle Style = getMicrosoftStyle(FormatStyle::LK_CSharp);
|
|
Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_None;
|
|
|
|
verifyFormat("[STAThread]\n"
|
|
"static void Main(string[] args)\n"
|
|
"{\n"
|
|
"}",
|
|
Style);
|
|
|
|
verifyFormat("[STAThread]\n"
|
|
"void "
|
|
"veryLooooooooooooooongFunctionName(string[] args)\n"
|
|
"{\n"
|
|
"}",
|
|
Style);
|
|
|
|
verifyFormat("[STAThread]\n"
|
|
"veryLoooooooooooooooooooongReturnType "
|
|
"veryLooooooooooooooongFunctionName(string[] args)\n"
|
|
"{\n"
|
|
"}",
|
|
Style);
|
|
|
|
verifyFormat("[SuppressMessage(\"A\", \"B\", Justification = \"C\")]\n"
|
|
"public override X Y()\n"
|
|
"{\n"
|
|
"}\n",
|
|
Style);
|
|
|
|
verifyFormat("[SuppressMessage]\n"
|
|
"public X Y()\n"
|
|
"{\n"
|
|
"}\n",
|
|
Style);
|
|
|
|
verifyFormat("[SuppressMessage]\n"
|
|
"public override X Y()\n"
|
|
"{\n"
|
|
"}\n",
|
|
Style);
|
|
|
|
verifyFormat("public A(B b) : base(b)\n"
|
|
"{\n"
|
|
" [SuppressMessage]\n"
|
|
" public override X Y()\n"
|
|
" {\n"
|
|
" }\n"
|
|
"}\n",
|
|
Style);
|
|
|
|
verifyFormat("public A : Base\n"
|
|
"{\n"
|
|
"}\n"
|
|
"[Test]\n"
|
|
"public Foo()\n"
|
|
"{\n"
|
|
"}\n",
|
|
Style);
|
|
|
|
verifyFormat("namespace\n"
|
|
"{\n"
|
|
"public A : Base\n"
|
|
"{\n"
|
|
"}\n"
|
|
"[Test]\n"
|
|
"public Foo()\n"
|
|
"{\n"
|
|
"}\n"
|
|
"}\n",
|
|
Style);
|
|
}
|
|
|
|
TEST_F(FormatTestCSharp, CSharpSpaceBefore) {
|
|
FormatStyle Style = getGoogleStyle(FormatStyle::LK_CSharp);
|
|
Style.SpaceBeforeParens = FormatStyle::SBPO_Always;
|
|
|
|
verifyFormat("List<string> list;", Style);
|
|
verifyFormat("Dictionary<string, string> dict;", Style);
|
|
|
|
verifyFormat("for (int i = 0; i < size (); i++) {\n"
|
|
"}",
|
|
Style);
|
|
verifyFormat("foreach (var x in y) {\n"
|
|
"}",
|
|
Style);
|
|
verifyFormat("switch (x) {}", Style);
|
|
verifyFormat("do {\n"
|
|
"} while (x);",
|
|
Style);
|
|
|
|
Style.SpaceBeforeParens = FormatStyle::SBPO_Never;
|
|
|
|
verifyFormat("List<string> list;", Style);
|
|
verifyFormat("Dictionary<string, string> dict;", Style);
|
|
|
|
verifyFormat("for(int i = 0; i < size(); i++) {\n"
|
|
"}",
|
|
Style);
|
|
verifyFormat("foreach(var x in y) {\n"
|
|
"}",
|
|
Style);
|
|
verifyFormat("switch(x) {}", Style);
|
|
verifyFormat("do {\n"
|
|
"} while(x);",
|
|
Style);
|
|
}
|
|
|
|
TEST_F(FormatTestCSharp, CSharpSpaceAfterCStyleCast) {
|
|
FormatStyle Style = getGoogleStyle(FormatStyle::LK_CSharp);
|
|
|
|
verifyFormat("(int)x / y;", Style);
|
|
|
|
Style.SpaceAfterCStyleCast = true;
|
|
verifyFormat("(int) x / y;", Style);
|
|
}
|
|
|
|
TEST_F(FormatTestCSharp, CSharpEscapedQuotesInVerbatimStrings) {
|
|
FormatStyle Style = getGoogleStyle(FormatStyle::LK_CSharp);
|
|
|
|
verifyFormat(R"(string str = @"""")", Style);
|
|
verifyFormat(R"(string str = @"""Hello world""")", Style);
|
|
verifyFormat(R"(string str = $@"""Hello {friend}""")", Style);
|
|
}
|
|
|
|
TEST_F(FormatTestCSharp, CSharpQuotesInInterpolatedStrings) {
|
|
FormatStyle Style = getGoogleStyle(FormatStyle::LK_CSharp);
|
|
|
|
verifyFormat(R"(string str1 = $"{null ?? "null"}";)", Style);
|
|
verifyFormat(R"(string str2 = $"{{{braceCount} braces";)", Style);
|
|
verifyFormat(R"(string str3 = $"{braceCount}}} braces";)", Style);
|
|
}
|
|
|
|
} // namespace format
|
|
} // end namespace clang
|