mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2024-10-20 19:42:54 +02:00
ae65e281f3
to reflect the new license. We understand that people may be surprised that we're moving the header entirely to discuss the new license. We checked this carefully with the Foundation's lawyer and we believe this is the correct approach. Essentially, all code in the project is now made available by the LLVM project under our new license, so you will see that the license headers include that license only. Some of our contributors have contributed code under our old license, and accordingly, we have retained a copy of our old license notice in the top-level files in each project and repository. llvm-svn: 351636
335 lines
12 KiB
C++
335 lines
12 KiB
C++
//===- unittest/Support/YAMLParserTest ------------------------------------===//
|
|
//
|
|
// 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 "llvm/Support/YAMLParser.h"
|
|
#include "llvm/ADT/Twine.h"
|
|
#include "llvm/Support/Casting.h"
|
|
#include "llvm/Support/MemoryBuffer.h"
|
|
#include "llvm/Support/SourceMgr.h"
|
|
#include "gtest/gtest.h"
|
|
|
|
namespace llvm {
|
|
|
|
static void SuppressDiagnosticsOutput(const SMDiagnostic &, void *) {
|
|
// Prevent SourceMgr from writing errors to stderr
|
|
// to reduce noise in unit test runs.
|
|
}
|
|
|
|
// Assumes Ctx is an SMDiagnostic where Diag can be stored.
|
|
static void CollectDiagnosticsOutput(const SMDiagnostic &Diag, void *Ctx) {
|
|
SMDiagnostic* DiagOut = static_cast<SMDiagnostic*>(Ctx);
|
|
*DiagOut = Diag;
|
|
}
|
|
|
|
// Checks that the given input gives a parse error. Makes sure that an error
|
|
// text is available and the parse fails.
|
|
static void ExpectParseError(StringRef Message, StringRef Input) {
|
|
SourceMgr SM;
|
|
yaml::Stream Stream(Input, SM);
|
|
SM.setDiagHandler(SuppressDiagnosticsOutput);
|
|
EXPECT_FALSE(Stream.validate()) << Message << ": " << Input;
|
|
EXPECT_TRUE(Stream.failed()) << Message << ": " << Input;
|
|
}
|
|
|
|
// Checks that the given input can be parsed without error.
|
|
static void ExpectParseSuccess(StringRef Message, StringRef Input) {
|
|
SourceMgr SM;
|
|
yaml::Stream Stream(Input, SM);
|
|
EXPECT_TRUE(Stream.validate()) << Message << ": " << Input;
|
|
}
|
|
|
|
TEST(YAMLParser, ParsesEmptyArray) {
|
|
ExpectParseSuccess("Empty array", "[]");
|
|
}
|
|
|
|
TEST(YAMLParser, FailsIfNotClosingArray) {
|
|
ExpectParseError("Not closing array", "[");
|
|
ExpectParseError("Not closing array", " [ ");
|
|
ExpectParseError("Not closing array", " [x");
|
|
}
|
|
|
|
TEST(YAMLParser, ParsesEmptyArrayWithWhitespace) {
|
|
ExpectParseSuccess("Array with spaces", " [ ] ");
|
|
ExpectParseSuccess("All whitespaces", "\t\r\n[\t\n \t\r ]\t\r \n\n");
|
|
}
|
|
|
|
TEST(YAMLParser, ParsesEmptyObject) {
|
|
ExpectParseSuccess("Empty object", "[{}]");
|
|
}
|
|
|
|
TEST(YAMLParser, ParsesObject) {
|
|
ExpectParseSuccess("Object with an entry", "[{\"a\":\"/b\"}]");
|
|
}
|
|
|
|
TEST(YAMLParser, ParsesMultipleKeyValuePairsInObject) {
|
|
ExpectParseSuccess("Multiple key, value pairs",
|
|
"[{\"a\":\"/b\",\"c\":\"d\",\"e\":\"f\"}]");
|
|
}
|
|
|
|
TEST(YAMLParser, FailsIfNotClosingObject) {
|
|
ExpectParseError("Missing close on empty", "[{]");
|
|
ExpectParseError("Missing close after pair", "[{\"a\":\"b\"]");
|
|
}
|
|
|
|
TEST(YAMLParser, FailsIfMissingColon) {
|
|
ExpectParseError("Missing colon between key and value", "[{\"a\"\"/b\"}]");
|
|
ExpectParseError("Missing colon between key and value", "[{\"a\" \"b\"}]");
|
|
}
|
|
|
|
TEST(YAMLParser, FailsOnMissingQuote) {
|
|
ExpectParseError("Missing open quote", "[{a\":\"b\"}]");
|
|
ExpectParseError("Missing closing quote", "[{\"a\":\"b}]");
|
|
}
|
|
|
|
TEST(YAMLParser, ParsesEscapedQuotes) {
|
|
ExpectParseSuccess("Parses escaped string in key and value",
|
|
"[{\"a\":\"\\\"b\\\" \\\" \\\"\"}]");
|
|
}
|
|
|
|
TEST(YAMLParser, ParsesEmptyString) {
|
|
ExpectParseSuccess("Parses empty string in value", "[{\"a\":\"\"}]");
|
|
}
|
|
|
|
TEST(YAMLParser, ParsesMultipleObjects) {
|
|
ExpectParseSuccess(
|
|
"Multiple objects in array",
|
|
"["
|
|
" { \"a\" : \"b\" },"
|
|
" { \"a\" : \"b\" },"
|
|
" { \"a\" : \"b\" }"
|
|
"]");
|
|
}
|
|
|
|
TEST(YAMLParser, FailsOnMissingComma) {
|
|
ExpectParseError(
|
|
"Missing comma",
|
|
"["
|
|
" { \"a\" : \"b\" }"
|
|
" { \"a\" : \"b\" }"
|
|
"]");
|
|
}
|
|
|
|
TEST(YAMLParser, ParsesSpacesInBetweenTokens) {
|
|
ExpectParseSuccess(
|
|
"Various whitespace between tokens",
|
|
" \t \n\n \r [ \t \n\n \r"
|
|
" \t \n\n \r { \t \n\n \r\"a\"\t \n\n \r :"
|
|
" \t \n\n \r \"b\"\t \n\n \r } \t \n\n \r,\t \n\n \r"
|
|
" \t \n\n \r { \t \n\n \r\"a\"\t \n\n \r :"
|
|
" \t \n\n \r \"b\"\t \n\n \r } \t \n\n \r]\t \n\n \r");
|
|
}
|
|
|
|
TEST(YAMLParser, ParsesArrayOfArrays) {
|
|
ExpectParseSuccess("Array of arrays", "[[]]");
|
|
}
|
|
|
|
TEST(YAMLParser, ParsesBlockLiteralScalars) {
|
|
ExpectParseSuccess("Block literal scalar", "test: |\n Hello\n World\n");
|
|
ExpectParseSuccess("Block literal scalar EOF", "test: |\n Hello\n World");
|
|
ExpectParseSuccess("Empty block literal scalar header EOF", "test: | ");
|
|
ExpectParseSuccess("Empty block literal scalar", "test: |\ntest2: 20");
|
|
ExpectParseSuccess("Empty block literal scalar 2", "- | \n \n\n \n- 42");
|
|
ExpectParseSuccess("Block literal scalar in sequence",
|
|
"- |\n Testing\n Out\n\n- 22");
|
|
ExpectParseSuccess("Block literal scalar in document",
|
|
"--- |\n Document\n...");
|
|
ExpectParseSuccess("Empty non indented lines still count",
|
|
"- |\n First line\n \n\n Another line\n\n- 2");
|
|
ExpectParseSuccess("Comment in block literal scalar header",
|
|
"test: | # Comment \n No Comment\ntest 2: | # Void");
|
|
ExpectParseSuccess("Chomping indicators in block literal scalar header",
|
|
"test: |- \n Hello\n\ntest 2: |+ \n\n World\n\n\n");
|
|
ExpectParseSuccess("Indent indicators in block literal scalar header",
|
|
"test: |1 \n \n Hello \n World\n");
|
|
ExpectParseSuccess("Chomping and indent indicators in block literals",
|
|
"test: |-1\n Hello\ntest 2: |9+\n World");
|
|
ExpectParseSuccess("Trailing comments in block literals",
|
|
"test: |\n Content\n # Trailing\n #Comment\ntest 2: 3");
|
|
ExpectParseError("Invalid block scalar header", "test: | failure");
|
|
ExpectParseError("Invalid line indentation", "test: |\n First line\n Error");
|
|
ExpectParseError("Long leading space line", "test: |\n \n Test\n");
|
|
}
|
|
|
|
TEST(YAMLParser, NullTerminatedBlockScalars) {
|
|
SourceMgr SM;
|
|
yaml::Stream Stream("test: |\n Hello\n World\n", SM);
|
|
yaml::Document &Doc = *Stream.begin();
|
|
yaml::MappingNode *Map = cast<yaml::MappingNode>(Doc.getRoot());
|
|
StringRef Value =
|
|
cast<yaml::BlockScalarNode>(Map->begin()->getValue())->getValue();
|
|
|
|
EXPECT_EQ(Value, "Hello\nWorld\n");
|
|
EXPECT_EQ(Value.data()[Value.size()], '\0');
|
|
}
|
|
|
|
TEST(YAMLParser, HandlesEndOfFileGracefully) {
|
|
ExpectParseError("In string starting with EOF", "[\"");
|
|
ExpectParseError("In string hitting EOF", "[\" ");
|
|
ExpectParseError("In string escaping EOF", "[\" \\");
|
|
ExpectParseError("In array starting with EOF", "[");
|
|
ExpectParseError("In array element starting with EOF", "[[], ");
|
|
ExpectParseError("In array hitting EOF", "[[] ");
|
|
ExpectParseError("In array hitting EOF", "[[]");
|
|
ExpectParseError("In object hitting EOF", "{\"\"");
|
|
}
|
|
|
|
TEST(YAMLParser, HandlesNullValuesInKeyValueNodesGracefully) {
|
|
ExpectParseError("KeyValueNode with null key", "? \"\n:");
|
|
ExpectParseError("KeyValueNode with null value", "test: '");
|
|
}
|
|
|
|
// Checks that the given string can be parsed into an identical string inside
|
|
// of an array.
|
|
static void ExpectCanParseString(StringRef String) {
|
|
std::string StringInArray = (llvm::Twine("[\"") + String + "\"]").str();
|
|
SourceMgr SM;
|
|
yaml::Stream Stream(StringInArray, SM);
|
|
yaml::SequenceNode *ParsedSequence
|
|
= dyn_cast<yaml::SequenceNode>(Stream.begin()->getRoot());
|
|
StringRef ParsedString
|
|
= dyn_cast<yaml::ScalarNode>(
|
|
static_cast<yaml::Node*>(ParsedSequence->begin()))->getRawValue();
|
|
ParsedString = ParsedString.substr(1, ParsedString.size() - 2);
|
|
EXPECT_EQ(String, ParsedString.str());
|
|
}
|
|
|
|
// Checks that parsing the given string inside an array fails.
|
|
static void ExpectCannotParseString(StringRef String) {
|
|
std::string StringInArray = (llvm::Twine("[\"") + String + "\"]").str();
|
|
ExpectParseError((Twine("When parsing string \"") + String + "\"").str(),
|
|
StringInArray);
|
|
}
|
|
|
|
TEST(YAMLParser, ParsesStrings) {
|
|
ExpectCanParseString("");
|
|
ExpectCannotParseString("\\");
|
|
ExpectCannotParseString("\"");
|
|
ExpectCanParseString(" ");
|
|
ExpectCanParseString("\\ ");
|
|
ExpectCanParseString("\\\"");
|
|
ExpectCannotParseString("\"\\");
|
|
ExpectCannotParseString(" \\");
|
|
ExpectCanParseString("\\\\");
|
|
ExpectCannotParseString("\\\\\\");
|
|
ExpectCanParseString("\\\\\\\\");
|
|
ExpectCanParseString("\\\" ");
|
|
ExpectCannotParseString("\\\\\" ");
|
|
ExpectCanParseString("\\\\\\\" ");
|
|
ExpectCanParseString(" \\\\ \\\" \\\\\\\" ");
|
|
}
|
|
|
|
TEST(YAMLParser, WorksWithIteratorAlgorithms) {
|
|
SourceMgr SM;
|
|
yaml::Stream Stream("[\"1\", \"2\", \"3\", \"4\", \"5\", \"6\"]", SM);
|
|
yaml::SequenceNode *Array
|
|
= dyn_cast<yaml::SequenceNode>(Stream.begin()->getRoot());
|
|
EXPECT_EQ(6, std::distance(Array->begin(), Array->end()));
|
|
}
|
|
|
|
TEST(YAMLParser, DefaultDiagnosticFilename) {
|
|
SourceMgr SM;
|
|
|
|
SMDiagnostic GeneratedDiag;
|
|
SM.setDiagHandler(CollectDiagnosticsOutput, &GeneratedDiag);
|
|
|
|
// When we construct a YAML stream over an unnamed string,
|
|
// the filename is hard-coded as "YAML".
|
|
yaml::Stream UnnamedStream("[]", SM);
|
|
UnnamedStream.printError(UnnamedStream.begin()->getRoot(), "Hello, World!");
|
|
EXPECT_EQ("YAML", GeneratedDiag.getFilename());
|
|
}
|
|
|
|
TEST(YAMLParser, DiagnosticFilenameFromBufferID) {
|
|
SourceMgr SM;
|
|
|
|
SMDiagnostic GeneratedDiag;
|
|
SM.setDiagHandler(CollectDiagnosticsOutput, &GeneratedDiag);
|
|
|
|
// When we construct a YAML stream over a named buffer,
|
|
// we get its ID as filename in diagnostics.
|
|
std::unique_ptr<MemoryBuffer> Buffer =
|
|
MemoryBuffer::getMemBuffer("[]", "buffername.yaml");
|
|
yaml::Stream Stream(Buffer->getMemBufferRef(), SM);
|
|
Stream.printError(Stream.begin()->getRoot(), "Hello, World!");
|
|
EXPECT_EQ("buffername.yaml", GeneratedDiag.getFilename());
|
|
}
|
|
|
|
TEST(YAMLParser, SameNodeIteratorOperatorNotEquals) {
|
|
SourceMgr SM;
|
|
yaml::Stream Stream("[\"1\", \"2\"]", SM);
|
|
|
|
yaml::SequenceNode *Node = dyn_cast<yaml::SequenceNode>(
|
|
Stream.begin()->getRoot());
|
|
|
|
auto Begin = Node->begin();
|
|
auto End = Node->end();
|
|
|
|
EXPECT_TRUE(Begin != End);
|
|
EXPECT_FALSE(Begin != Begin);
|
|
EXPECT_FALSE(End != End);
|
|
}
|
|
|
|
TEST(YAMLParser, SameNodeIteratorOperatorEquals) {
|
|
SourceMgr SM;
|
|
yaml::Stream Stream("[\"1\", \"2\"]", SM);
|
|
|
|
yaml::SequenceNode *Node = dyn_cast<yaml::SequenceNode>(
|
|
Stream.begin()->getRoot());
|
|
|
|
auto Begin = Node->begin();
|
|
auto End = Node->end();
|
|
|
|
EXPECT_FALSE(Begin == End);
|
|
EXPECT_TRUE(Begin == Begin);
|
|
EXPECT_TRUE(End == End);
|
|
}
|
|
|
|
TEST(YAMLParser, DifferentNodesIteratorOperatorNotEquals) {
|
|
SourceMgr SM;
|
|
yaml::Stream Stream("[\"1\", \"2\"]", SM);
|
|
yaml::Stream AnotherStream("[\"1\", \"2\"]", SM);
|
|
|
|
yaml::SequenceNode *Node = dyn_cast<yaml::SequenceNode>(
|
|
Stream.begin()->getRoot());
|
|
yaml::SequenceNode *AnotherNode = dyn_cast<yaml::SequenceNode>(
|
|
AnotherStream.begin()->getRoot());
|
|
|
|
auto Begin = Node->begin();
|
|
auto End = Node->end();
|
|
|
|
auto AnotherBegin = AnotherNode->begin();
|
|
auto AnotherEnd = AnotherNode->end();
|
|
|
|
EXPECT_TRUE(Begin != AnotherBegin);
|
|
EXPECT_TRUE(Begin != AnotherEnd);
|
|
EXPECT_FALSE(End != AnotherEnd);
|
|
}
|
|
|
|
TEST(YAMLParser, DifferentNodesIteratorOperatorEquals) {
|
|
SourceMgr SM;
|
|
yaml::Stream Stream("[\"1\", \"2\"]", SM);
|
|
yaml::Stream AnotherStream("[\"1\", \"2\"]", SM);
|
|
|
|
yaml::SequenceNode *Node = dyn_cast<yaml::SequenceNode>(
|
|
Stream.begin()->getRoot());
|
|
yaml::SequenceNode *AnotherNode = dyn_cast<yaml::SequenceNode>(
|
|
AnotherStream.begin()->getRoot());
|
|
|
|
auto Begin = Node->begin();
|
|
auto End = Node->end();
|
|
|
|
auto AnotherBegin = AnotherNode->begin();
|
|
auto AnotherEnd = AnotherNode->end();
|
|
|
|
EXPECT_FALSE(Begin == AnotherBegin);
|
|
EXPECT_FALSE(Begin == AnotherEnd);
|
|
EXPECT_TRUE(End == AnotherEnd);
|
|
}
|
|
|
|
} // end namespace llvm
|