| 1 |
//===- unittest/Support/YAMLParserTest ------------------------------------===// |
| 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 "llvm/Support/YAMLParser.h" |
| 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 "gtest/gtest.h" |
| 15 |
|
| 16 |
namespace llvm { |
| 17 |
|
| 18 |
static void SuppressDiagnosticsOutput(const SMDiagnostic &, void *) { |
| 19 |
// Prevent SourceMgr from writing errors to stderr |
| 20 |
// to reduce noise in unit test runs. |
| 21 |
} |
| 22 |
|
| 23 |
// Assumes Ctx is an SMDiagnostic where Diag can be stored. |
| 24 |
static void CollectDiagnosticsOutput(const SMDiagnostic &Diag, void *Ctx) { |
| 25 |
SMDiagnostic* DiagOut = static_cast<SMDiagnostic*>(Ctx); |
| 26 |
*DiagOut = Diag; |
| 27 |
} |
| 28 |
|
| 29 |
// Checks that the given input gives a parse error. Makes sure that an error |
| 30 |
// text is available and the parse fails. |
| 31 |
static void ExpectParseError(StringRef Message, StringRef Input) { |
| 32 |
SourceMgr SM; |
| 33 |
yaml::Stream Stream(Input, SM); |
| 34 |
SM.setDiagHandler(SuppressDiagnosticsOutput); |
| 35 |
EXPECT_FALSE(Stream.validate()) << Message << ": " << Input; |
| 36 |
EXPECT_TRUE(Stream.failed()) << Message << ": " << Input; |
| 37 |
} |
| 38 |
|
| 39 |
// Checks that the given input can be parsed without error. |
| 40 |
static void ExpectParseSuccess(StringRef Message, StringRef Input) { |
| 41 |
SourceMgr SM; |
| 42 |
yaml::Stream Stream(Input, SM); |
| 43 |
EXPECT_TRUE(Stream.validate()) << Message << ": " << Input; |
| 44 |
} |
| 45 |
|
| 46 |
TEST(YAMLParser, ParsesEmptyArray) { |
| 47 |
ExpectParseSuccess("Empty array", "[]"); |
| 48 |
} |
| 49 |
|
| 50 |
TEST(YAMLParser, FailsIfNotClosingArray) { |
| 51 |
ExpectParseError("Not closing array", "["); |
| 52 |
ExpectParseError("Not closing array", " [ "); |
| 53 |
ExpectParseError("Not closing array", " [x"); |
| 54 |
} |
| 55 |
|
| 56 |
TEST(YAMLParser, ParsesEmptyArrayWithWhitespace) { |
| 57 |
ExpectParseSuccess("Array with spaces", " [ ] "); |
| 58 |
ExpectParseSuccess("All whitespaces", "\t\r\n[\t\n \t\r ]\t\r \n\n"); |
| 59 |
} |
| 60 |
|
| 61 |
TEST(YAMLParser, ParsesEmptyObject) { |
| 62 |
ExpectParseSuccess("Empty object", "[{}]"); |
| 63 |
} |
| 64 |
|
| 65 |
TEST(YAMLParser, ParsesObject) { |
| 66 |
ExpectParseSuccess("Object with an entry", "[{\"a\":\"/b\"}]"); |
| 67 |
} |
| 68 |
|
| 69 |
TEST(YAMLParser, ParsesMultipleKeyValuePairsInObject) { |
| 70 |
ExpectParseSuccess("Multiple key, value pairs", |
| 71 |
"[{\"a\":\"/b\",\"c\":\"d\",\"e\":\"f\"}]"); |
| 72 |
} |
| 73 |
|
| 74 |
TEST(YAMLParser, FailsIfNotClosingObject) { |
| 75 |
ExpectParseError("Missing close on empty", "[{]"); |
| 76 |
ExpectParseError("Missing close after pair", "[{\"a\":\"b\"]"); |
| 77 |
} |
| 78 |
|
| 79 |
TEST(YAMLParser, FailsIfMissingColon) { |
| 80 |
ExpectParseError("Missing colon between key and value", "[{\"a\"\"/b\"}]"); |
| 81 |
ExpectParseError("Missing colon between key and value", "[{\"a\" \"b\"}]"); |
| 82 |
} |
| 83 |
|
| 84 |
TEST(YAMLParser, FailsOnMissingQuote) { |
| 85 |
ExpectParseError("Missing open quote", "[{a\":\"b\"}]"); |
| 86 |
ExpectParseError("Missing closing quote", "[{\"a\":\"b}]"); |
| 87 |
} |
| 88 |
|
| 89 |
TEST(YAMLParser, ParsesEscapedQuotes) { |
| 90 |
ExpectParseSuccess("Parses escaped string in key and value", |
| 91 |
"[{\"a\":\"\\\"b\\\" \\\" \\\"\"}]"); |
| 92 |
} |
| 93 |
|
| 94 |
TEST(YAMLParser, ParsesEmptyString) { |
| 95 |
ExpectParseSuccess("Parses empty string in value", "[{\"a\":\"\"}]"); |
| 96 |
} |
| 97 |
|
| 98 |
TEST(YAMLParser, ParsesMultipleObjects) { |
| 99 |
ExpectParseSuccess( |
| 100 |
"Multiple objects in array", |
| 101 |
"[" |
| 102 |
" { \"a\" : \"b\" }," |
| 103 |
" { \"a\" : \"b\" }," |
| 104 |
" { \"a\" : \"b\" }" |
| 105 |
"]"); |
| 106 |
} |
| 107 |
|
| 108 |
TEST(YAMLParser, FailsOnMissingComma) { |
| 109 |
ExpectParseError( |
| 110 |
"Missing comma", |
| 111 |
"[" |
| 112 |
" { \"a\" : \"b\" }" |
| 113 |
" { \"a\" : \"b\" }" |
| 114 |
"]"); |
| 115 |
} |
| 116 |
|
| 117 |
TEST(YAMLParser, ParsesSpacesInBetweenTokens) { |
| 118 |
ExpectParseSuccess( |
| 119 |
"Various whitespace between tokens", |
| 120 |
" \t \n\n \r [ \t \n\n \r" |
| 121 |
" \t \n\n \r { \t \n\n \r\"a\"\t \n\n \r :" |
| 122 |
" \t \n\n \r \"b\"\t \n\n \r } \t \n\n \r,\t \n\n \r" |
| 123 |
" \t \n\n \r { \t \n\n \r\"a\"\t \n\n \r :" |
| 124 |
" \t \n\n \r \"b\"\t \n\n \r } \t \n\n \r]\t \n\n \r"); |
| 125 |
} |
| 126 |
|
| 127 |
TEST(YAMLParser, ParsesArrayOfArrays) { |
| 128 |
ExpectParseSuccess("Array of arrays", "[[]]"); |
| 129 |
} |
| 130 |
|
| 131 |
TEST(YAMLParser, ParsesBlockLiteralScalars) { |
| 132 |
ExpectParseSuccess("Block literal scalar", "test: |\n Hello\n World\n"); |
| 133 |
ExpectParseSuccess("Block literal scalar EOF", "test: |\n Hello\n World"); |
| 134 |
ExpectParseSuccess("Empty block literal scalar header EOF", "test: | "); |
| 135 |
ExpectParseSuccess("Empty block literal scalar", "test: |\ntest2: 20"); |
| 136 |
ExpectParseSuccess("Empty block literal scalar 2", "- | \n \n\n \n- 42"); |
| 137 |
ExpectParseSuccess("Block literal scalar in sequence", |
| 138 |
"- |\n Testing\n Out\n\n- 22"); |
| 139 |
ExpectParseSuccess("Block literal scalar in document", |
| 140 |
"--- |\n Document\n..."); |
| 141 |
ExpectParseSuccess("Empty non indented lines still count", |
| 142 |
"- |\n First line\n \n\n Another line\n\n- 2"); |
| 143 |
ExpectParseSuccess("Comment in block literal scalar header", |
| 144 |
"test: | # Comment \n No Comment\ntest 2: | # Void"); |
| 145 |
ExpectParseSuccess("Chomping indicators in block literal scalar header", |
| 146 |
"test: |- \n Hello\n\ntest 2: |+ \n\n World\n\n\n"); |
| 147 |
ExpectParseSuccess("Indent indicators in block literal scalar header", |
| 148 |
"test: |1 \n \n Hello \n World\n"); |
| 149 |
ExpectParseSuccess("Chomping and indent indicators in block literals", |
| 150 |
"test: |-1\n Hello\ntest 2: |9+\n World"); |
| 151 |
ExpectParseSuccess("Trailing comments in block literals", |
| 152 |
"test: |\n Content\n # Trailing\n #Comment\ntest 2: 3"); |
| 153 |
ExpectParseError("Invalid block scalar header", "test: | failure"); |
| 154 |
ExpectParseError("Invalid line indentation", "test: |\n First line\n Error"); |
| 155 |
ExpectParseError("Long leading space line", "test: |\n \n Test\n"); |
| 156 |
} |
| 157 |
|
| 158 |
TEST(YAMLParser, NullTerminatedBlockScalars) { |
| 159 |
SourceMgr SM; |
| 160 |
yaml::Stream Stream("test: |\n Hello\n World\n", SM); |
| 161 |
yaml::Document &Doc = *Stream.begin(); |
| 162 |
yaml::MappingNode *Map = cast<yaml::MappingNode>(Doc.getRoot()); |
| 163 |
StringRef Value = |
| 164 |
cast<yaml::BlockScalarNode>(Map->begin()->getValue())->getValue(); |
| 165 |
|
| 166 |
EXPECT_EQ(Value, "Hello\nWorld\n"); |
| 167 |
EXPECT_EQ(Value.data()[Value.size()], '\0'); |
| 168 |
} |
| 169 |
|
| 170 |
TEST(YAMLParser, HandlesEndOfFileGracefully) { |
| 171 |
ExpectParseError("In string starting with EOF", "[\""); |
| 172 |
ExpectParseError("In string hitting EOF", "[\" "); |
| 173 |
ExpectParseError("In string escaping EOF", "[\" \\"); |
| 174 |
ExpectParseError("In array starting with EOF", "["); |
| 175 |
ExpectParseError("In array element starting with EOF", "[[], "); |
| 176 |
ExpectParseError("In array hitting EOF", "[[] "); |
| 177 |
ExpectParseError("In array hitting EOF", "[[]"); |
| 178 |
ExpectParseError("In object hitting EOF", "{\"\""); |
| 179 |
} |
| 180 |
|
| 181 |
TEST(YAMLParser, HandlesNullValuesInKeyValueNodesGracefully) { |
| 182 |
ExpectParseError("KeyValueNode with null key", "? \"\n:"); |
| 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. |
| 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. |
| 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 |
|
| 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 |
|
| 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 |
|
| 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 |
|
| 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 |
|
| 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_NE(Begin, End); |
| 273 |
EXPECT_EQ(Begin, Begin); |
| 274 |
EXPECT_EQ(End, End); |
| 275 |
} |
| 276 |
|
| 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_NE(Begin, End); |
| 288 |
EXPECT_EQ(Begin, Begin); |
| 289 |
EXPECT_EQ(End, End); |
| 290 |
} |
| 291 |
|
| 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_NE(Begin, AnotherBegin); |
| 309 |
EXPECT_NE(Begin, AnotherEnd); |
| 310 |
EXPECT_EQ(End, AnotherEnd); |
| 311 |
} |
| 312 |
|
| 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_NE(Begin, AnotherBegin); |
| 330 |
EXPECT_NE(Begin, AnotherEnd); |
| 331 |
EXPECT_EQ(End, AnotherEnd); |
| 332 |
} |
| 333 |
|
| 334 |
TEST(YAMLParser, FlowSequenceTokensOutsideFlowSequence) { |
| 335 |
auto FlowSequenceStrs = {",", "]", "}"}; |
| 336 |
SourceMgr SM; |
| 337 |
|
| 338 |
for (auto &Str : FlowSequenceStrs) { |
| 339 |
yaml::Stream Stream(Str, SM); |
| 340 |
yaml::Document &Doc = *Stream.begin(); |
| 341 |
EXPECT_FALSE(Doc.skip()); |
| 342 |
} |
| 343 |
} |
| 344 |
|
| 345 |
static void expectCanParseBool(StringRef S, bool Expected) { |
| 346 |
std::optional<bool> Parsed = yaml::parseBool(S); |
| 347 |
EXPECT_TRUE(Parsed.has_value()); |
| 348 |
EXPECT_EQ(*Parsed, Expected); |
| 349 |
} |
| 350 |
|
| 351 |
static void expectCannotParseBool(StringRef S) { |
| 352 |
EXPECT_FALSE(yaml::parseBool(S).has_value()); |
| 353 |
} |
| 354 |
|
| 355 |
TEST(YAMLParser, ParsesBools) { |
| 356 |
// Test true values. |
| 357 |
expectCanParseBool("ON", true); |
| 358 |
expectCanParseBool("On", true); |
| 359 |
expectCanParseBool("on", true); |
| 360 |
expectCanParseBool("TRUE", true); |
| 361 |
expectCanParseBool("True", true); |
| 362 |
expectCanParseBool("true", true); |
| 363 |
expectCanParseBool("Y", true); |
| 364 |
expectCanParseBool("y", true); |
| 365 |
expectCanParseBool("YES", true); |
| 366 |
expectCanParseBool("Yes", true); |
| 367 |
expectCanParseBool("yes", true); |
| 368 |
expectCannotParseBool("1"); |
| 369 |
|
| 370 |
// Test false values. |
| 371 |
expectCanParseBool("FALSE", false); |
| 372 |
expectCanParseBool("False", false); |
| 373 |
expectCanParseBool("false", false); |
| 374 |
expectCanParseBool("N", false); |
| 375 |
expectCanParseBool("n", false); |
| 376 |
expectCanParseBool("NO", false); |
| 377 |
expectCanParseBool("No", false); |
| 378 |
expectCanParseBool("no", false); |
| 379 |
expectCanParseBool("OFF", false); |
| 380 |
expectCanParseBool("Off", false); |
| 381 |
expectCanParseBool("off", false); |
| 382 |
expectCannotParseBool("0"); |
| 383 |
} |
| 384 |
|
| 385 |
} // end namespace llvm |