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/Support/YAMLParser.h"
11 #include "llvm/ADT/Twine.h"
12 #include "llvm/Support/Casting.h"
13 #include "llvm/Support/MemoryBuffer.h"
14 #include "llvm/Support/SourceMgr.h"
15 #include "gtest/gtest.h"
16 
17 namespace llvm {
18 
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.
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.
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.
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 
47 TEST(YAMLParser, ParsesEmptyArray) {
48   ExpectParseSuccess("Empty array", "[]");
49 }
50 
51 TEST(YAMLParser, FailsIfNotClosingArray) {
52   ExpectParseError("Not closing array", "[");
53   ExpectParseError("Not closing array", "  [  ");
54   ExpectParseError("Not closing array", "  [x");
55 }
56 
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 
62 TEST(YAMLParser, ParsesEmptyObject) {
63   ExpectParseSuccess("Empty object", "[{}]");
64 }
65 
66 TEST(YAMLParser, ParsesObject) {
67   ExpectParseSuccess("Object with an entry", "[{\"a\":\"/b\"}]");
68 }
69 
70 TEST(YAMLParser, ParsesMultipleKeyValuePairsInObject) {
71   ExpectParseSuccess("Multiple key, value pairs",
72                      "[{\"a\":\"/b\",\"c\":\"d\",\"e\":\"f\"}]");
73 }
74 
75 TEST(YAMLParser, FailsIfNotClosingObject) {
76   ExpectParseError("Missing close on empty", "[{]");
77   ExpectParseError("Missing close after pair", "[{\"a\":\"b\"]");
78 }
79 
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 
85 TEST(YAMLParser, FailsOnMissingQuote) {
86   ExpectParseError("Missing open quote", "[{a\":\"b\"}]");
87   ExpectParseError("Missing closing quote", "[{\"a\":\"b}]");
88 }
89 
90 TEST(YAMLParser, ParsesEscapedQuotes) {
91   ExpectParseSuccess("Parses escaped string in key and value",
92                      "[{\"a\":\"\\\"b\\\"  \\\" \\\"\"}]");
93 }
94 
95 TEST(YAMLParser, ParsesEmptyString) {
96   ExpectParseSuccess("Parses empty string in value", "[{\"a\":\"\"}]");
97 }
98 
99 TEST(YAMLParser, ParsesMultipleObjects) {
100   ExpectParseSuccess(
101       "Multiple objects in array",
102       "["
103       " { \"a\" : \"b\" },"
104       " { \"a\" : \"b\" },"
105       " { \"a\" : \"b\" }"
106       "]");
107 }
108 
109 TEST(YAMLParser, FailsOnMissingComma) {
110   ExpectParseError(
111       "Missing comma",
112       "["
113       " { \"a\" : \"b\" }"
114       " { \"a\" : \"b\" }"
115       "]");
116 }
117 
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 
128 TEST(YAMLParser, ParsesArrayOfArrays) {
129   ExpectParseSuccess("Array of arrays", "[[]]");
130 }
131 
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 
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 
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 
182 TEST(YAMLParser, HandlesNullValuesInKeyValueNodesGracefully) {
183   ExpectParseError("KeyValueNode with null key", "? \"\n:");
184   ExpectParseError("KeyValueNode with null value", "test: '");
185 }
186 
187 // Checks that the given string can be parsed into an identical string inside
188 // of an array.
189 static void ExpectCanParseString(StringRef String) {
190   std::string StringInArray = (llvm::Twine("[\"") + String + "\"]").str();
191   SourceMgr SM;
192   yaml::Stream Stream(StringInArray, SM);
193   yaml::SequenceNode *ParsedSequence
194     = dyn_cast<yaml::SequenceNode>(Stream.begin()->getRoot());
195   StringRef ParsedString
196     = dyn_cast<yaml::ScalarNode>(
197       static_cast<yaml::Node*>(ParsedSequence->begin()))->getRawValue();
198   ParsedString = ParsedString.substr(1, ParsedString.size() - 2);
199   EXPECT_EQ(String, ParsedString.str());
200 }
201 
202 // Checks that parsing the given string inside an array fails.
203 static void ExpectCannotParseString(StringRef String) {
204   std::string StringInArray = (llvm::Twine("[\"") + String + "\"]").str();
205   ExpectParseError((Twine("When parsing string \"") + String + "\"").str(),
206                    StringInArray);
207 }
208 
209 TEST(YAMLParser, ParsesStrings) {
210   ExpectCanParseString("");
211   ExpectCannotParseString("\\");
212   ExpectCannotParseString("\"");
213   ExpectCanParseString(" ");
214   ExpectCanParseString("\\ ");
215   ExpectCanParseString("\\\"");
216   ExpectCannotParseString("\"\\");
217   ExpectCannotParseString(" \\");
218   ExpectCanParseString("\\\\");
219   ExpectCannotParseString("\\\\\\");
220   ExpectCanParseString("\\\\\\\\");
221   ExpectCanParseString("\\\" ");
222   ExpectCannotParseString("\\\\\" ");
223   ExpectCanParseString("\\\\\\\" ");
224   ExpectCanParseString("    \\\\  \\\"  \\\\\\\"   ");
225 }
226 
227 TEST(YAMLParser, WorksWithIteratorAlgorithms) {
228   SourceMgr SM;
229   yaml::Stream Stream("[\"1\", \"2\", \"3\", \"4\", \"5\", \"6\"]", SM);
230   yaml::SequenceNode *Array
231     = dyn_cast<yaml::SequenceNode>(Stream.begin()->getRoot());
232   EXPECT_EQ(6, std::distance(Array->begin(), Array->end()));
233 }
234 
235 TEST(YAMLParser, DefaultDiagnosticFilename) {
236   SourceMgr SM;
237 
238   SMDiagnostic GeneratedDiag;
239   SM.setDiagHandler(CollectDiagnosticsOutput, &GeneratedDiag);
240 
241   // When we construct a YAML stream over an unnamed string,
242   // the filename is hard-coded as "YAML".
243   yaml::Stream UnnamedStream("[]", SM);
244   UnnamedStream.printError(UnnamedStream.begin()->getRoot(), "Hello, World!");
245   EXPECT_EQ("YAML", GeneratedDiag.getFilename());
246 }
247 
248 TEST(YAMLParser, DiagnosticFilenameFromBufferID) {
249   SourceMgr SM;
250 
251   SMDiagnostic GeneratedDiag;
252   SM.setDiagHandler(CollectDiagnosticsOutput, &GeneratedDiag);
253 
254   // When we construct a YAML stream over a named buffer,
255   // we get its ID as filename in diagnostics.
256   std::unique_ptr<MemoryBuffer> Buffer =
257       MemoryBuffer::getMemBuffer("[]", "buffername.yaml");
258   yaml::Stream Stream(Buffer->getMemBufferRef(), SM);
259   Stream.printError(Stream.begin()->getRoot(), "Hello, World!");
260   EXPECT_EQ("buffername.yaml", GeneratedDiag.getFilename());
261 }
262 
263 TEST(YAMLParser, SameNodeIteratorOperatorNotEquals) {
264   SourceMgr SM;
265   yaml::Stream Stream("[\"1\", \"2\"]", SM);
266 
267   yaml::SequenceNode *Node = dyn_cast<yaml::SequenceNode>(
268                                               Stream.begin()->getRoot());
269 
270   auto Begin = Node->begin();
271   auto End = Node->end();
272 
273   EXPECT_TRUE(Begin != End);
274   EXPECT_FALSE(Begin != Begin);
275   EXPECT_FALSE(End != End);
276 }
277 
278 TEST(YAMLParser, SameNodeIteratorOperatorEquals) {
279   SourceMgr SM;
280   yaml::Stream Stream("[\"1\", \"2\"]", SM);
281 
282   yaml::SequenceNode *Node = dyn_cast<yaml::SequenceNode>(
283                                               Stream.begin()->getRoot());
284 
285   auto Begin = Node->begin();
286   auto End = Node->end();
287 
288   EXPECT_FALSE(Begin == End);
289   EXPECT_TRUE(Begin == Begin);
290   EXPECT_TRUE(End == End);
291 }
292 
293 TEST(YAMLParser, DifferentNodesIteratorOperatorNotEquals) {
294   SourceMgr SM;
295   yaml::Stream Stream("[\"1\", \"2\"]", SM);
296   yaml::Stream AnotherStream("[\"1\", \"2\"]", SM);
297 
298   yaml::SequenceNode *Node = dyn_cast<yaml::SequenceNode>(
299                                                   Stream.begin()->getRoot());
300   yaml::SequenceNode *AnotherNode = dyn_cast<yaml::SequenceNode>(
301                                               AnotherStream.begin()->getRoot());
302 
303   auto Begin = Node->begin();
304   auto End = Node->end();
305 
306   auto AnotherBegin = AnotherNode->begin();
307   auto AnotherEnd = AnotherNode->end();
308 
309   EXPECT_TRUE(Begin != AnotherBegin);
310   EXPECT_TRUE(Begin != AnotherEnd);
311   EXPECT_FALSE(End != AnotherEnd);
312 }
313 
314 TEST(YAMLParser, DifferentNodesIteratorOperatorEquals) {
315   SourceMgr SM;
316   yaml::Stream Stream("[\"1\", \"2\"]", SM);
317   yaml::Stream AnotherStream("[\"1\", \"2\"]", SM);
318 
319   yaml::SequenceNode *Node = dyn_cast<yaml::SequenceNode>(
320                                                     Stream.begin()->getRoot());
321   yaml::SequenceNode *AnotherNode = dyn_cast<yaml::SequenceNode>(
322                                              AnotherStream.begin()->getRoot());
323 
324   auto Begin = Node->begin();
325   auto End = Node->end();
326 
327   auto AnotherBegin = AnotherNode->begin();
328   auto AnotherEnd = AnotherNode->end();
329 
330   EXPECT_FALSE(Begin == AnotherBegin);
331   EXPECT_FALSE(Begin == AnotherEnd);
332   EXPECT_TRUE(End == AnotherEnd);
333 }
334 
335 } // end namespace llvm
336