1 //===-- HighlighterTest.cpp -----------------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #include "gtest/gtest.h"
10 
11 #include "lldb/Core/Highlighter.h"
12 #include "lldb/Host/FileSystem.h"
13 
14 #include "Plugins/Language/CPlusPlus/CPlusPlusLanguage.h"
15 #include "Plugins/Language/ObjC/ObjCLanguage.h"
16 #include "Plugins/Language/ObjCPlusPlus/ObjCPlusPlusLanguage.h"
17 #include "TestingSupport/SubsystemRAII.h"
18 
19 using namespace lldb_private;
20 
21 namespace {
22 class HighlighterTest : public testing::Test {
23   SubsystemRAII<FileSystem, CPlusPlusLanguage, ObjCLanguage,
24                 ObjCPlusPlusLanguage>
25       subsystems;
26 };
27 } // namespace
28 
29 static std::string getName(lldb::LanguageType type) {
30   HighlighterManager m;
31   return m.getHighlighterFor(type, "").GetName().str();
32 }
33 
34 static std::string getName(llvm::StringRef path) {
35   HighlighterManager m;
36   return m.getHighlighterFor(lldb::eLanguageTypeUnknown, path).GetName().str();
37 }
38 
39 TEST_F(HighlighterTest, HighlighterSelectionType) {
40   EXPECT_EQ(getName(lldb::eLanguageTypeC_plus_plus), "clang");
41   EXPECT_EQ(getName(lldb::eLanguageTypeC_plus_plus_03), "clang");
42   EXPECT_EQ(getName(lldb::eLanguageTypeC_plus_plus_11), "clang");
43   EXPECT_EQ(getName(lldb::eLanguageTypeC_plus_plus_14), "clang");
44   EXPECT_EQ(getName(lldb::eLanguageTypeObjC), "clang");
45   EXPECT_EQ(getName(lldb::eLanguageTypeObjC_plus_plus), "clang");
46 
47   EXPECT_EQ(getName(lldb::eLanguageTypeUnknown), "none");
48   EXPECT_EQ(getName(lldb::eLanguageTypeJulia), "none");
49   EXPECT_EQ(getName(lldb::eLanguageTypeHaskell), "none");
50 }
51 
52 TEST_F(HighlighterTest, HighlighterSelectionPath) {
53   EXPECT_EQ(getName("myfile.cc"), "clang");
54   EXPECT_EQ(getName("moo.cpp"), "clang");
55   EXPECT_EQ(getName("mar.cxx"), "clang");
56   EXPECT_EQ(getName("foo.C"), "clang");
57   EXPECT_EQ(getName("bar.CC"), "clang");
58   EXPECT_EQ(getName("a/dir.CC"), "clang");
59   EXPECT_EQ(getName("/a/dir.hpp"), "clang");
60   EXPECT_EQ(getName("header.h"), "clang");
61 
62   EXPECT_EQ(getName(""), "none");
63   EXPECT_EQ(getName("/dev/null"), "none");
64   EXPECT_EQ(getName("Factory.java"), "none");
65   EXPECT_EQ(getName("poll.py"), "none");
66   EXPECT_EQ(getName("reducer.hs"), "none");
67 }
68 
69 TEST_F(HighlighterTest, FallbackHighlighter) {
70   HighlighterManager mgr;
71   const Highlighter &h =
72       mgr.getHighlighterFor(lldb::eLanguageTypePascal83, "foo.pas");
73 
74   HighlightStyle style;
75   style.identifier.Set("[", "]");
76   style.semicolons.Set("<", ">");
77 
78   const char *code = "program Hello;";
79   std::string output = h.Highlight(style, code, llvm::Optional<size_t>());
80 
81   EXPECT_STREQ(output.c_str(), code);
82 }
83 
84 static std::string
85 highlightDefault(llvm::StringRef code, HighlightStyle style,
86                  llvm::Optional<size_t> cursor = llvm::Optional<size_t>()) {
87   HighlighterManager mgr;
88   return mgr.getDefaultHighlighter().Highlight(style, code, cursor);
89 }
90 
91 TEST_F(HighlighterTest, DefaultHighlighter) {
92   const char *code = "int my_main() { return 22; } \n";
93 
94   HighlightStyle style;
95   EXPECT_EQ(code, highlightDefault(code, style));
96 }
97 
98 TEST_F(HighlighterTest, DefaultHighlighterWithCursor) {
99   HighlightStyle style;
100   style.selected.Set("<c>", "</c>");
101   EXPECT_EQ("<c>a</c> bc", highlightDefault("a bc", style, 0));
102   EXPECT_EQ("a<c> </c>bc", highlightDefault("a bc", style, 1));
103   EXPECT_EQ("a <c>b</c>c", highlightDefault("a bc", style, 2));
104   EXPECT_EQ("a b<c>c</c>", highlightDefault("a bc", style, 3));
105 }
106 
107 TEST_F(HighlighterTest, DefaultHighlighterWithCursorOutOfBounds) {
108   HighlightStyle style;
109   style.selected.Set("<c>", "</c>");
110   EXPECT_EQ("a bc", highlightDefault("a bc", style, 4));
111 }
112 // Tests highlighting with the Clang highlighter.
113 
114 static std::string
115 highlightC(llvm::StringRef code, HighlightStyle style,
116            llvm::Optional<size_t> cursor = llvm::Optional<size_t>()) {
117   HighlighterManager mgr;
118   const Highlighter &h = mgr.getHighlighterFor(lldb::eLanguageTypeC, "main.c");
119   return h.Highlight(style, code, cursor);
120 }
121 
122 TEST_F(HighlighterTest, ClangEmptyInput) {
123   HighlightStyle s;
124   EXPECT_EQ("", highlightC("", s));
125 }
126 
127 TEST_F(HighlighterTest, ClangScalarLiterals) {
128   HighlightStyle s;
129   s.scalar_literal.Set("<scalar>", "</scalar>");
130 
131   EXPECT_EQ(" int i = <scalar>22</scalar>;", highlightC(" int i = 22;", s));
132 }
133 
134 TEST_F(HighlighterTest, ClangStringLiterals) {
135   HighlightStyle s;
136   s.string_literal.Set("<str>", "</str>");
137 
138   EXPECT_EQ("const char *f = 22 + <str>\"foo\"</str>;",
139             highlightC("const char *f = 22 + \"foo\";", s));
140 }
141 
142 TEST_F(HighlighterTest, ClangUnterminatedString) {
143   HighlightStyle s;
144   s.string_literal.Set("<str>", "</str>");
145 
146   EXPECT_EQ(" f = \"", highlightC(" f = \"", s));
147 }
148 
149 TEST_F(HighlighterTest, Keywords) {
150   HighlightStyle s;
151   s.keyword.Set("<k>", "</k>");
152 
153   EXPECT_EQ(" <k>return</k> 1; ", highlightC(" return 1; ", s));
154 }
155 
156 TEST_F(HighlighterTest, Colons) {
157   HighlightStyle s;
158   s.colon.Set("<c>", "</c>");
159 
160   EXPECT_EQ("foo<c>:</c><c>:</c>bar<c>:</c>", highlightC("foo::bar:", s));
161 }
162 
163 TEST_F(HighlighterTest, ClangBraces) {
164   HighlightStyle s;
165   s.braces.Set("<b>", "</b>");
166 
167   EXPECT_EQ("a<b>{</b><b>}</b>", highlightC("a{}", s));
168 }
169 
170 TEST_F(HighlighterTest, ClangSquareBrackets) {
171   HighlightStyle s;
172   s.square_brackets.Set("<sb>", "</sb>");
173 
174   EXPECT_EQ("a<sb>[</sb><sb>]</sb>", highlightC("a[]", s));
175 }
176 
177 TEST_F(HighlighterTest, ClangCommas) {
178   HighlightStyle s;
179   s.comma.Set("<comma>", "</comma>");
180 
181   EXPECT_EQ(" bool f = foo()<comma>,</comma> 1;",
182             highlightC(" bool f = foo(), 1;", s));
183 }
184 
185 TEST_F(HighlighterTest, ClangPPDirectives) {
186   HighlightStyle s;
187   s.pp_directive.Set("<pp>", "</pp>");
188 
189   EXPECT_EQ("<pp>#</pp><pp>include</pp><pp> </pp><pp>\"foo\"</pp><pp> </pp>//c",
190             highlightC("#include \"foo\" //c", s));
191 }
192 
193 TEST_F(HighlighterTest, ClangPreserveNewLine) {
194   HighlightStyle s;
195   s.comment.Set("<cc>", "</cc>");
196 
197   EXPECT_EQ("<cc>//</cc>\n", highlightC("//\n", s));
198 }
199 
200 TEST_F(HighlighterTest, ClangTrailingBackslashBeforeNewline) {
201   HighlightStyle s;
202 
203   EXPECT_EQ("\\\n", highlightC("\\\n", s));
204   EXPECT_EQ("\\\r\n", highlightC("\\\r\n", s));
205 
206   EXPECT_EQ("#define a \\\n", highlightC("#define a \\\n", s));
207   EXPECT_EQ("#define a \\\r\n", highlightC("#define a \\\r\n", s));
208   EXPECT_EQ("#define a \\\r", highlightC("#define a \\\r", s));
209 }
210 
211 TEST_F(HighlighterTest, ClangTrailingBackslashWithWhitespace) {
212   HighlightStyle s;
213 
214   EXPECT_EQ("\\  \n", highlightC("\\  \n", s));
215   EXPECT_EQ("\\ \t\n", highlightC("\\ \t\n", s));
216   EXPECT_EQ("\\ \n", highlightC("\\ \n", s));
217   EXPECT_EQ("\\\t\n", highlightC("\\\t\n", s));
218 
219   EXPECT_EQ("#define a \\  \n", highlightC("#define a \\  \n", s));
220   EXPECT_EQ("#define a \\ \t\n", highlightC("#define a \\ \t\n", s));
221   EXPECT_EQ("#define a \\ \n", highlightC("#define a \\ \n", s));
222   EXPECT_EQ("#define a \\\t\n", highlightC("#define a \\\t\n", s));
223 }
224 
225 TEST_F(HighlighterTest, ClangTrailingBackslashMissingNewLine) {
226   HighlightStyle s;
227   EXPECT_EQ("\\", highlightC("\\", s));
228   EXPECT_EQ("#define a\\", highlightC("#define a\\", s));
229 }
230 
231 TEST_F(HighlighterTest, ClangComments) {
232   HighlightStyle s;
233   s.comment.Set("<cc>", "</cc>");
234 
235   EXPECT_EQ(" <cc>/*com */</cc> <cc>// com /*n*/</cc>",
236             highlightC(" /*com */ // com /*n*/", s));
237 }
238 
239 TEST_F(HighlighterTest, ClangOperators) {
240   HighlightStyle s;
241   s.operators.Set("[", "]");
242 
243   EXPECT_EQ(" 1[+]2[/]a[*]f[&]x[|][~]l", highlightC(" 1+2/a*f&x|~l", s));
244 }
245 
246 TEST_F(HighlighterTest, ClangIdentifiers) {
247   HighlightStyle s;
248   s.identifier.Set("<id>", "</id>");
249 
250   EXPECT_EQ(" <id>foo</id> <id>c</id> = <id>bar</id>(); return 1;",
251             highlightC(" foo c = bar(); return 1;", s));
252 }
253 
254 TEST_F(HighlighterTest, ClangCursorPos) {
255   HighlightStyle s;
256   s.selected.Set("<c>", "</c>");
257 
258   EXPECT_EQ("<c> </c>foo c = bar(); return 1;",
259             highlightC(" foo c = bar(); return 1;", s, 0));
260   EXPECT_EQ(" <c>foo</c> c = bar(); return 1;",
261             highlightC(" foo c = bar(); return 1;", s, 1));
262   EXPECT_EQ(" <c>foo</c> c = bar(); return 1;",
263             highlightC(" foo c = bar(); return 1;", s, 2));
264   EXPECT_EQ(" <c>foo</c> c = bar(); return 1;",
265             highlightC(" foo c = bar(); return 1;", s, 3));
266   EXPECT_EQ(" foo<c> </c>c = bar(); return 1;",
267             highlightC(" foo c = bar(); return 1;", s, 4));
268   EXPECT_EQ(" foo <c>c</c> = bar(); return 1;",
269             highlightC(" foo c = bar(); return 1;", s, 5));
270 }
271 
272 TEST_F(HighlighterTest, ClangCursorPosEndOfLine) {
273   HighlightStyle s;
274   s.selected.Set("<c>", "</c>");
275 
276   EXPECT_EQ("f", highlightC("f", s, 1));
277 }
278 
279 TEST_F(HighlighterTest, ClangCursorOutOfBounds) {
280   HighlightStyle s;
281   s.selected.Set("<c>", "</c>");
282   EXPECT_EQ("f", highlightC("f", s, 2));
283   EXPECT_EQ("f", highlightC("f", s, 3));
284   EXPECT_EQ("f", highlightC("f", s, 4));
285 }
286 
287 TEST_F(HighlighterTest, ClangCursorPosBeforeOtherToken) {
288   HighlightStyle s;
289   s.selected.Set("<c>", "</c>");
290   s.identifier.Set("<id>", "</id>");
291 
292   EXPECT_EQ("<c> </c><id>foo</id> <id>c</id> = <id>bar</id>(); return 1;",
293             highlightC(" foo c = bar(); return 1;", s, 0));
294 }
295 
296 TEST_F(HighlighterTest, ClangCursorPosAfterOtherToken) {
297   HighlightStyle s;
298   s.selected.Set("<c>", "</c>");
299   s.identifier.Set("<id>", "</id>");
300 
301   EXPECT_EQ(" <id>foo</id><c> </c><id>c</id> = <id>bar</id>(); return 1;",
302             highlightC(" foo c = bar(); return 1;", s, 4));
303 }
304 
305 TEST_F(HighlighterTest, ClangCursorPosInOtherToken) {
306   HighlightStyle s;
307   s.selected.Set("<c>", "</c>");
308   s.identifier.Set("<id>", "</id>");
309 
310   EXPECT_EQ(" <id><c>foo</c></id> <id>c</id> = <id>bar</id>(); return 1;",
311             highlightC(" foo c = bar(); return 1;", s, 1));
312   EXPECT_EQ(" <id><c>foo</c></id> <id>c</id> = <id>bar</id>(); return 1;",
313             highlightC(" foo c = bar(); return 1;", s, 2));
314   EXPECT_EQ(" <id><c>foo</c></id> <id>c</id> = <id>bar</id>(); return 1;",
315             highlightC(" foo c = bar(); return 1;", s, 3));
316 }
317