1 //===- unittest/Support/YAMLParserTest ------------------------------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9
10 #include "llvm/ADT/Twine.h"
11 #include "llvm/Support/Casting.h"
12 #include "llvm/Support/MemoryBuffer.h"
13 #include "llvm/Support/SourceMgr.h"
14 #include "llvm/Support/YAMLParser.h"
15 #include "gtest/gtest.h"
16
17 namespace llvm {
18
SuppressDiagnosticsOutput(const SMDiagnostic &,void *)19 static void SuppressDiagnosticsOutput(const SMDiagnostic &, void *) {
20 // Prevent SourceMgr from writing errors to stderr
21 // to reduce noise in unit test runs.
22 }
23
24 // Assumes Ctx is an SMDiagnostic where Diag can be stored.
CollectDiagnosticsOutput(const SMDiagnostic & Diag,void * Ctx)25 static void CollectDiagnosticsOutput(const SMDiagnostic &Diag, void *Ctx) {
26 SMDiagnostic* DiagOut = static_cast<SMDiagnostic*>(Ctx);
27 *DiagOut = Diag;
28 }
29
30 // Checks that the given input gives a parse error. Makes sure that an error
31 // text is available and the parse fails.
ExpectParseError(StringRef Message,StringRef Input)32 static void ExpectParseError(StringRef Message, StringRef Input) {
33 SourceMgr SM;
34 yaml::Stream Stream(Input, SM);
35 SM.setDiagHandler(SuppressDiagnosticsOutput);
36 EXPECT_FALSE(Stream.validate()) << Message << ": " << Input;
37 EXPECT_TRUE(Stream.failed()) << Message << ": " << Input;
38 }
39
40 // Checks that the given input can be parsed without error.
ExpectParseSuccess(StringRef Message,StringRef Input)41 static void ExpectParseSuccess(StringRef Message, StringRef Input) {
42 SourceMgr SM;
43 yaml::Stream Stream(Input, SM);
44 EXPECT_TRUE(Stream.validate()) << Message << ": " << Input;
45 }
46
TEST(YAMLParser,ParsesEmptyArray)47 TEST(YAMLParser, ParsesEmptyArray) {
48 ExpectParseSuccess("Empty array", "[]");
49 }
50
TEST(YAMLParser,FailsIfNotClosingArray)51 TEST(YAMLParser, FailsIfNotClosingArray) {
52 ExpectParseError("Not closing array", "[");
53 ExpectParseError("Not closing array", " [ ");
54 ExpectParseError("Not closing array", " [x");
55 }
56
TEST(YAMLParser,ParsesEmptyArrayWithWhitespace)57 TEST(YAMLParser, ParsesEmptyArrayWithWhitespace) {
58 ExpectParseSuccess("Array with spaces", " [ ] ");
59 ExpectParseSuccess("All whitespaces", "\t\r\n[\t\n \t\r ]\t\r \n\n");
60 }
61
TEST(YAMLParser,ParsesEmptyObject)62 TEST(YAMLParser, ParsesEmptyObject) {
63 ExpectParseSuccess("Empty object", "[{}]");
64 }
65
TEST(YAMLParser,ParsesObject)66 TEST(YAMLParser, ParsesObject) {
67 ExpectParseSuccess("Object with an entry", "[{\"a\":\"/b\"}]");
68 }
69
TEST(YAMLParser,ParsesMultipleKeyValuePairsInObject)70 TEST(YAMLParser, ParsesMultipleKeyValuePairsInObject) {
71 ExpectParseSuccess("Multiple key, value pairs",
72 "[{\"a\":\"/b\",\"c\":\"d\",\"e\":\"f\"}]");
73 }
74
TEST(YAMLParser,FailsIfNotClosingObject)75 TEST(YAMLParser, FailsIfNotClosingObject) {
76 ExpectParseError("Missing close on empty", "[{]");
77 ExpectParseError("Missing close after pair", "[{\"a\":\"b\"]");
78 }
79
TEST(YAMLParser,FailsIfMissingColon)80 TEST(YAMLParser, FailsIfMissingColon) {
81 ExpectParseError("Missing colon between key and value", "[{\"a\"\"/b\"}]");
82 ExpectParseError("Missing colon between key and value", "[{\"a\" \"b\"}]");
83 }
84
TEST(YAMLParser,FailsOnMissingQuote)85 TEST(YAMLParser, FailsOnMissingQuote) {
86 ExpectParseError("Missing open quote", "[{a\":\"b\"}]");
87 ExpectParseError("Missing closing quote", "[{\"a\":\"b}]");
88 }
89
TEST(YAMLParser,ParsesEscapedQuotes)90 TEST(YAMLParser, ParsesEscapedQuotes) {
91 ExpectParseSuccess("Parses escaped string in key and value",
92 "[{\"a\":\"\\\"b\\\" \\\" \\\"\"}]");
93 }
94
TEST(YAMLParser,ParsesEmptyString)95 TEST(YAMLParser, ParsesEmptyString) {
96 ExpectParseSuccess("Parses empty string in value", "[{\"a\":\"\"}]");
97 }
98
TEST(YAMLParser,ParsesMultipleObjects)99 TEST(YAMLParser, ParsesMultipleObjects) {
100 ExpectParseSuccess(
101 "Multiple objects in array",
102 "["
103 " { \"a\" : \"b\" },"
104 " { \"a\" : \"b\" },"
105 " { \"a\" : \"b\" }"
106 "]");
107 }
108
TEST(YAMLParser,FailsOnMissingComma)109 TEST(YAMLParser, FailsOnMissingComma) {
110 ExpectParseError(
111 "Missing comma",
112 "["
113 " { \"a\" : \"b\" }"
114 " { \"a\" : \"b\" }"
115 "]");
116 }
117
TEST(YAMLParser,ParsesSpacesInBetweenTokens)118 TEST(YAMLParser, ParsesSpacesInBetweenTokens) {
119 ExpectParseSuccess(
120 "Various whitespace between tokens",
121 " \t \n\n \r [ \t \n\n \r"
122 " \t \n\n \r { \t \n\n \r\"a\"\t \n\n \r :"
123 " \t \n\n \r \"b\"\t \n\n \r } \t \n\n \r,\t \n\n \r"
124 " \t \n\n \r { \t \n\n \r\"a\"\t \n\n \r :"
125 " \t \n\n \r \"b\"\t \n\n \r } \t \n\n \r]\t \n\n \r");
126 }
127
TEST(YAMLParser,ParsesArrayOfArrays)128 TEST(YAMLParser, ParsesArrayOfArrays) {
129 ExpectParseSuccess("Array of arrays", "[[]]");
130 }
131
TEST(YAMLParser,ParsesBlockLiteralScalars)132 TEST(YAMLParser, ParsesBlockLiteralScalars) {
133 ExpectParseSuccess("Block literal scalar", "test: |\n Hello\n World\n");
134 ExpectParseSuccess("Block literal scalar EOF", "test: |\n Hello\n World");
135 ExpectParseSuccess("Empty block literal scalar header EOF", "test: | ");
136 ExpectParseSuccess("Empty block literal scalar", "test: |\ntest2: 20");
137 ExpectParseSuccess("Empty block literal scalar 2", "- | \n \n\n \n- 42");
138 ExpectParseSuccess("Block literal scalar in sequence",
139 "- |\n Testing\n Out\n\n- 22");
140 ExpectParseSuccess("Block literal scalar in document",
141 "--- |\n Document\n...");
142 ExpectParseSuccess("Empty non indented lines still count",
143 "- |\n First line\n \n\n Another line\n\n- 2");
144 ExpectParseSuccess("Comment in block literal scalar header",
145 "test: | # Comment \n No Comment\ntest 2: | # Void");
146 ExpectParseSuccess("Chomping indicators in block literal scalar header",
147 "test: |- \n Hello\n\ntest 2: |+ \n\n World\n\n\n");
148 ExpectParseSuccess("Indent indicators in block literal scalar header",
149 "test: |1 \n \n Hello \n World\n");
150 ExpectParseSuccess("Chomping and indent indicators in block literals",
151 "test: |-1\n Hello\ntest 2: |9+\n World");
152 ExpectParseSuccess("Trailing comments in block literals",
153 "test: |\n Content\n # Trailing\n #Comment\ntest 2: 3");
154 ExpectParseError("Invalid block scalar header", "test: | failure");
155 ExpectParseError("Invalid line indentation", "test: |\n First line\n Error");
156 ExpectParseError("Long leading space line", "test: |\n \n Test\n");
157 }
158
TEST(YAMLParser,NullTerminatedBlockScalars)159 TEST(YAMLParser, NullTerminatedBlockScalars) {
160 SourceMgr SM;
161 yaml::Stream Stream("test: |\n Hello\n World\n", SM);
162 yaml::Document &Doc = *Stream.begin();
163 yaml::MappingNode *Map = cast<yaml::MappingNode>(Doc.getRoot());
164 StringRef Value =
165 cast<yaml::BlockScalarNode>(Map->begin()->getValue())->getValue();
166
167 EXPECT_EQ(Value, "Hello\nWorld\n");
168 EXPECT_EQ(Value.data()[Value.size()], '\0');
169 }
170
TEST(YAMLParser,HandlesEndOfFileGracefully)171 TEST(YAMLParser, HandlesEndOfFileGracefully) {
172 ExpectParseError("In string starting with EOF", "[\"");
173 ExpectParseError("In string hitting EOF", "[\" ");
174 ExpectParseError("In string escaping EOF", "[\" \\");
175 ExpectParseError("In array starting with EOF", "[");
176 ExpectParseError("In array element starting with EOF", "[[], ");
177 ExpectParseError("In array hitting EOF", "[[] ");
178 ExpectParseError("In array hitting EOF", "[[]");
179 ExpectParseError("In object hitting EOF", "{\"\"");
180 }
181
TEST(YAMLParser,HandlesNullValuesInKeyValueNodesGracefully)182 TEST(YAMLParser, HandlesNullValuesInKeyValueNodesGracefully) {
183 ExpectParseError("KeyValueNode with null value", "test: '");
184 }
185
186 // Checks that the given string can be parsed into an identical string inside
187 // of an array.
ExpectCanParseString(StringRef String)188 static void ExpectCanParseString(StringRef String) {
189 std::string StringInArray = (llvm::Twine("[\"") + String + "\"]").str();
190 SourceMgr SM;
191 yaml::Stream Stream(StringInArray, SM);
192 yaml::SequenceNode *ParsedSequence
193 = dyn_cast<yaml::SequenceNode>(Stream.begin()->getRoot());
194 StringRef ParsedString
195 = dyn_cast<yaml::ScalarNode>(
196 static_cast<yaml::Node*>(ParsedSequence->begin()))->getRawValue();
197 ParsedString = ParsedString.substr(1, ParsedString.size() - 2);
198 EXPECT_EQ(String, ParsedString.str());
199 }
200
201 // Checks that parsing the given string inside an array fails.
ExpectCannotParseString(StringRef String)202 static void ExpectCannotParseString(StringRef String) {
203 std::string StringInArray = (llvm::Twine("[\"") + String + "\"]").str();
204 ExpectParseError((Twine("When parsing string \"") + String + "\"").str(),
205 StringInArray);
206 }
207
TEST(YAMLParser,ParsesStrings)208 TEST(YAMLParser, ParsesStrings) {
209 ExpectCanParseString("");
210 ExpectCannotParseString("\\");
211 ExpectCannotParseString("\"");
212 ExpectCanParseString(" ");
213 ExpectCanParseString("\\ ");
214 ExpectCanParseString("\\\"");
215 ExpectCannotParseString("\"\\");
216 ExpectCannotParseString(" \\");
217 ExpectCanParseString("\\\\");
218 ExpectCannotParseString("\\\\\\");
219 ExpectCanParseString("\\\\\\\\");
220 ExpectCanParseString("\\\" ");
221 ExpectCannotParseString("\\\\\" ");
222 ExpectCanParseString("\\\\\\\" ");
223 ExpectCanParseString(" \\\\ \\\" \\\\\\\" ");
224 }
225
TEST(YAMLParser,WorksWithIteratorAlgorithms)226 TEST(YAMLParser, WorksWithIteratorAlgorithms) {
227 SourceMgr SM;
228 yaml::Stream Stream("[\"1\", \"2\", \"3\", \"4\", \"5\", \"6\"]", SM);
229 yaml::SequenceNode *Array
230 = dyn_cast<yaml::SequenceNode>(Stream.begin()->getRoot());
231 EXPECT_EQ(6, std::distance(Array->begin(), Array->end()));
232 }
233
TEST(YAMLParser,DefaultDiagnosticFilename)234 TEST(YAMLParser, DefaultDiagnosticFilename) {
235 SourceMgr SM;
236
237 SMDiagnostic GeneratedDiag;
238 SM.setDiagHandler(CollectDiagnosticsOutput, &GeneratedDiag);
239
240 // When we construct a YAML stream over an unnamed string,
241 // the filename is hard-coded as "YAML".
242 yaml::Stream UnnamedStream("[]", SM);
243 UnnamedStream.printError(UnnamedStream.begin()->getRoot(), "Hello, World!");
244 EXPECT_EQ("YAML", GeneratedDiag.getFilename());
245 }
246
TEST(YAMLParser,DiagnosticFilenameFromBufferID)247 TEST(YAMLParser, DiagnosticFilenameFromBufferID) {
248 SourceMgr SM;
249
250 SMDiagnostic GeneratedDiag;
251 SM.setDiagHandler(CollectDiagnosticsOutput, &GeneratedDiag);
252
253 // When we construct a YAML stream over a named buffer,
254 // we get its ID as filename in diagnostics.
255 std::unique_ptr<MemoryBuffer> Buffer =
256 MemoryBuffer::getMemBuffer("[]", "buffername.yaml");
257 yaml::Stream Stream(Buffer->getMemBufferRef(), SM);
258 Stream.printError(Stream.begin()->getRoot(), "Hello, World!");
259 EXPECT_EQ("buffername.yaml", GeneratedDiag.getFilename());
260 }
261
TEST(YAMLParser,SameNodeIteratorOperatorNotEquals)262 TEST(YAMLParser, SameNodeIteratorOperatorNotEquals) {
263 SourceMgr SM;
264 yaml::Stream Stream("[\"1\", \"2\"]", SM);
265
266 yaml::SequenceNode *Node = dyn_cast<yaml::SequenceNode>(
267 Stream.begin()->getRoot());
268
269 auto Begin = Node->begin();
270 auto End = Node->end();
271
272 EXPECT_TRUE(Begin != End);
273 EXPECT_FALSE(Begin != Begin);
274 EXPECT_FALSE(End != End);
275 }
276
TEST(YAMLParser,SameNodeIteratorOperatorEquals)277 TEST(YAMLParser, SameNodeIteratorOperatorEquals) {
278 SourceMgr SM;
279 yaml::Stream Stream("[\"1\", \"2\"]", SM);
280
281 yaml::SequenceNode *Node = dyn_cast<yaml::SequenceNode>(
282 Stream.begin()->getRoot());
283
284 auto Begin = Node->begin();
285 auto End = Node->end();
286
287 EXPECT_FALSE(Begin == End);
288 EXPECT_TRUE(Begin == Begin);
289 EXPECT_TRUE(End == End);
290 }
291
TEST(YAMLParser,DifferentNodesIteratorOperatorNotEquals)292 TEST(YAMLParser, DifferentNodesIteratorOperatorNotEquals) {
293 SourceMgr SM;
294 yaml::Stream Stream("[\"1\", \"2\"]", SM);
295 yaml::Stream AnotherStream("[\"1\", \"2\"]", SM);
296
297 yaml::SequenceNode *Node = dyn_cast<yaml::SequenceNode>(
298 Stream.begin()->getRoot());
299 yaml::SequenceNode *AnotherNode = dyn_cast<yaml::SequenceNode>(
300 AnotherStream.begin()->getRoot());
301
302 auto Begin = Node->begin();
303 auto End = Node->end();
304
305 auto AnotherBegin = AnotherNode->begin();
306 auto AnotherEnd = AnotherNode->end();
307
308 EXPECT_TRUE(Begin != AnotherBegin);
309 EXPECT_TRUE(Begin != AnotherEnd);
310 EXPECT_FALSE(End != AnotherEnd);
311 }
312
TEST(YAMLParser,DifferentNodesIteratorOperatorEquals)313 TEST(YAMLParser, DifferentNodesIteratorOperatorEquals) {
314 SourceMgr SM;
315 yaml::Stream Stream("[\"1\", \"2\"]", SM);
316 yaml::Stream AnotherStream("[\"1\", \"2\"]", SM);
317
318 yaml::SequenceNode *Node = dyn_cast<yaml::SequenceNode>(
319 Stream.begin()->getRoot());
320 yaml::SequenceNode *AnotherNode = dyn_cast<yaml::SequenceNode>(
321 AnotherStream.begin()->getRoot());
322
323 auto Begin = Node->begin();
324 auto End = Node->end();
325
326 auto AnotherBegin = AnotherNode->begin();
327 auto AnotherEnd = AnotherNode->end();
328
329 EXPECT_FALSE(Begin == AnotherBegin);
330 EXPECT_FALSE(Begin == AnotherEnd);
331 EXPECT_TRUE(End == AnotherEnd);
332 }
333
334 } // end namespace llvm
335