llvm-for-llvmta/unittests/Support/YAMLParserTest.cpp

386 lines
13 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);
}
TEST(YAMLParser, FlowSequenceTokensOutsideFlowSequence) {
auto FlowSequenceStrs = {",", "]", "}"};
SourceMgr SM;
for (auto &Str : FlowSequenceStrs) {
yaml::Stream Stream(Str, SM);
yaml::Document &Doc = *Stream.begin();
EXPECT_FALSE(Doc.skip());
}
}
static void expectCanParseBool(StringRef S, bool Expected) {
llvm::Optional<bool> Parsed = yaml::parseBool(S);
EXPECT_TRUE(Parsed.hasValue());
EXPECT_EQ(*Parsed, Expected);
}
static void expectCannotParseBool(StringRef S) {
EXPECT_FALSE(yaml::parseBool(S).hasValue());
}
TEST(YAMLParser, ParsesBools) {
// Test true values.
expectCanParseBool("ON", true);
expectCanParseBool("On", true);
expectCanParseBool("on", true);
expectCanParseBool("TRUE", true);
expectCanParseBool("True", true);
expectCanParseBool("true", true);
expectCanParseBool("Y", true);
expectCanParseBool("y", true);
expectCanParseBool("YES", true);
expectCanParseBool("Yes", true);
expectCanParseBool("yes", true);
expectCannotParseBool("1");
// Test false values.
expectCanParseBool("FALSE", false);
expectCanParseBool("False", false);
expectCanParseBool("false", false);
expectCanParseBool("N", false);
expectCanParseBool("n", false);
expectCanParseBool("NO", false);
expectCanParseBool("No", false);
expectCanParseBool("no", false);
expectCanParseBool("OFF", false);
expectCanParseBool("Off", false);
expectCanParseBool("off", false);
expectCannotParseBool("0");
}
} // end namespace llvm