diff options
Diffstat (limited to 'unittests/Support')
| -rw-r--r-- | unittests/Support/MDBuilderTest.cpp | 105 | ||||
| -rw-r--r-- | unittests/Support/YAMLParserTest.cpp (renamed from unittests/Support/JSONParserTest.cpp) | 88 |
2 files changed, 143 insertions, 50 deletions
diff --git a/unittests/Support/MDBuilderTest.cpp b/unittests/Support/MDBuilderTest.cpp new file mode 100644 index 0000000..d54c7e8 --- /dev/null +++ b/unittests/Support/MDBuilderTest.cpp @@ -0,0 +1,105 @@ +//===- llvm/unittests/Support/MDBuilderTest.cpp - MDBuilder unit tests ----===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#include "gtest/gtest.h" +#include "llvm/Operator.h" +#include "llvm/Support/IRBuilder.h" +#include "llvm/Support/MDBuilder.h" +using namespace llvm; + +namespace { + +class MDBuilderTest : public testing::Test { +protected: + LLVMContext Context; +}; + +TEST_F(MDBuilderTest, createString) { + MDBuilder MDHelper(Context); + MDString *Str0 = MDHelper.createString(""); + MDString *Str1 = MDHelper.createString("string"); + EXPECT_EQ(Str0->getString(), StringRef("")); + EXPECT_EQ(Str1->getString(), StringRef("string")); +} +TEST_F(MDBuilderTest, createFPMath) { + MDBuilder MDHelper(Context); + MDNode *MD0 = MDHelper.createFPMath(0.0); + MDNode *MD1 = MDHelper.createFPMath(1.0); + EXPECT_EQ(MD0, (MDNode *)0); + EXPECT_NE(MD1, (MDNode *)0); + EXPECT_EQ(MD1->getNumOperands(), 1U); + Value *Op = MD1->getOperand(0); + EXPECT_TRUE(isa<ConstantFP>(Op)); + EXPECT_TRUE(Op->getType()->isFloatingPointTy()); + ConstantFP *Val = cast<ConstantFP>(Op); + EXPECT_TRUE(Val->isExactlyValue(1.0)); +} +TEST_F(MDBuilderTest, createRangeMetadata) { + MDBuilder MDHelper(Context); + APInt A(8, 1), B(8, 2); + MDNode *R0 = MDHelper.createRange(A, A); + MDNode *R1 = MDHelper.createRange(A, B); + EXPECT_EQ(R0, (MDNode *)0); + EXPECT_NE(R1, (MDNode *)0); + EXPECT_EQ(R1->getNumOperands(), 2U); + EXPECT_TRUE(isa<ConstantInt>(R1->getOperand(0))); + EXPECT_TRUE(isa<ConstantInt>(R1->getOperand(1))); + ConstantInt *C0 = cast<ConstantInt>(R1->getOperand(0)); + ConstantInt *C1 = cast<ConstantInt>(R1->getOperand(1)); + EXPECT_EQ(C0->getValue(), A); + EXPECT_EQ(C1->getValue(), B); +} +TEST_F(MDBuilderTest, createAnonymousTBAARoot) { + MDBuilder MDHelper(Context); + MDNode *R0 = MDHelper.createAnonymousTBAARoot(); + MDNode *R1 = MDHelper.createAnonymousTBAARoot(); + EXPECT_NE(R0, R1); + EXPECT_GE(R0->getNumOperands(), 1U); + EXPECT_GE(R1->getNumOperands(), 1U); + EXPECT_EQ(R0->getOperand(0), R0); + EXPECT_EQ(R1->getOperand(0), R1); + EXPECT_TRUE(R0->getNumOperands() == 1 || R0->getOperand(1) == 0); + EXPECT_TRUE(R1->getNumOperands() == 1 || R1->getOperand(1) == 0); +} +TEST_F(MDBuilderTest, createTBAARoot) { + MDBuilder MDHelper(Context); + MDNode *R0 = MDHelper.createTBAARoot("Root"); + MDNode *R1 = MDHelper.createTBAARoot("Root"); + EXPECT_EQ(R0, R1); + EXPECT_GE(R0->getNumOperands(), 1U); + EXPECT_TRUE(isa<MDString>(R0->getOperand(0))); + EXPECT_EQ(cast<MDString>(R0->getOperand(0))->getString(), "Root"); + EXPECT_TRUE(R0->getNumOperands() == 1 || R0->getOperand(1) == 0); +} +TEST_F(MDBuilderTest, createTBAANode) { + MDBuilder MDHelper(Context); + MDNode *R = MDHelper.createTBAARoot("Root"); + MDNode *N0 = MDHelper.createTBAANode("Node", R); + MDNode *N1 = MDHelper.createTBAANode("edoN", R); + MDNode *N2 = MDHelper.createTBAANode("Node", R, true); + MDNode *N3 = MDHelper.createTBAANode("Node", R); + EXPECT_EQ(N0, N3); + EXPECT_NE(N0, N1); + EXPECT_NE(N0, N2); + EXPECT_GE(N0->getNumOperands(), 2U); + EXPECT_GE(N1->getNumOperands(), 2U); + EXPECT_GE(N2->getNumOperands(), 3U); + EXPECT_TRUE(isa<MDString>(N0->getOperand(0))); + EXPECT_TRUE(isa<MDString>(N1->getOperand(0))); + EXPECT_TRUE(isa<MDString>(N2->getOperand(0))); + EXPECT_EQ(cast<MDString>(N0->getOperand(0))->getString(), "Node"); + EXPECT_EQ(cast<MDString>(N1->getOperand(0))->getString(), "edoN"); + EXPECT_EQ(cast<MDString>(N2->getOperand(0))->getString(), "Node"); + EXPECT_EQ(N0->getOperand(1), R); + EXPECT_EQ(N1->getOperand(1), R); + EXPECT_EQ(N2->getOperand(1), R); + EXPECT_TRUE(isa<ConstantInt>(N2->getOperand(2))); + EXPECT_EQ(cast<ConstantInt>(N2->getOperand(2))->getZExtValue(), 1U); +} +} diff --git a/unittests/Support/JSONParserTest.cpp b/unittests/Support/YAMLParserTest.cpp index e9efb81..e88427a 100644 --- a/unittests/Support/JSONParserTest.cpp +++ b/unittests/Support/YAMLParserTest.cpp @@ -1,4 +1,4 @@ -//===- unittest/Tooling/JSONParserTest ------------------------------------===// +//===- unittest/Support/YAMLParserTest ------------------------------------===// // // The LLVM Compiler Infrastructure // @@ -7,9 +7,11 @@ // //===----------------------------------------------------------------------===// -#include "llvm/Support/Casting.h" -#include "llvm/Support/JSONParser.h" +#include "llvm/ADT/SmallString.h" #include "llvm/ADT/Twine.h" +#include "llvm/Support/Casting.h" +#include "llvm/Support/SourceMgr.h" +#include "llvm/Support/YAMLParser.h" #include "gtest/gtest.h" namespace llvm { @@ -18,84 +20,71 @@ namespace llvm { // text is available and the parse fails. static void ExpectParseError(StringRef Message, StringRef Input) { SourceMgr SM; - JSONParser Parser(Input, &SM); - EXPECT_FALSE(Parser.validate()) << Message << ": " << Input; - EXPECT_TRUE(Parser.failed()) << Message << ": " << Input; + yaml::Stream Stream(Input, SM); + 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; - JSONParser Parser(Input, &SM); - EXPECT_TRUE(Parser.validate()) << Message << ": " << Input; -} - -TEST(JSONParser, FailsOnEmptyString) { - ExpectParseError("Empty JSON text", ""); -} - -TEST(JSONParser, FailsIfStartsWithString) { - ExpectParseError("Top-level string", "\"x\""); + yaml::Stream Stream(Input, SM); + EXPECT_TRUE(Stream.validate()) << Message << ": " << Input; } -TEST(JSONParser, ParsesEmptyArray) { +TEST(YAMLParser, ParsesEmptyArray) { ExpectParseSuccess("Empty array", "[]"); } -TEST(JSONParser, FailsIfNotClosingArray) { +TEST(YAMLParser, FailsIfNotClosingArray) { ExpectParseError("Not closing array", "["); ExpectParseError("Not closing array", " [ "); ExpectParseError("Not closing array", " [x"); } -TEST(JSONParser, ParsesEmptyArrayWithWhitespace) { +TEST(YAMLParser, ParsesEmptyArrayWithWhitespace) { ExpectParseSuccess("Array with spaces", " [ ] "); ExpectParseSuccess("All whitespaces", "\t\r\n[\t\n \t\r ]\t\r \n\n"); } -TEST(JSONParser, ParsesEmptyObject) { +TEST(YAMLParser, ParsesEmptyObject) { ExpectParseSuccess("Empty object", "[{}]"); } -TEST(JSONParser, ParsesObject) { +TEST(YAMLParser, ParsesObject) { ExpectParseSuccess("Object with an entry", "[{\"a\":\"/b\"}]"); } -TEST(JSONParser, ParsesMultipleKeyValuePairsInObject) { +TEST(YAMLParser, ParsesMultipleKeyValuePairsInObject) { ExpectParseSuccess("Multiple key, value pairs", "[{\"a\":\"/b\",\"c\":\"d\",\"e\":\"f\"}]"); } -TEST(JSONParser, FailsIfNotClosingObject) { +TEST(YAMLParser, FailsIfNotClosingObject) { ExpectParseError("Missing close on empty", "[{]"); ExpectParseError("Missing close after pair", "[{\"a\":\"b\"]"); } -TEST(JSONParser, FailsIfMissingColon) { +TEST(YAMLParser, FailsIfMissingColon) { ExpectParseError("Missing colon between key and value", "[{\"a\"\"/b\"}]"); ExpectParseError("Missing colon between key and value", "[{\"a\" \"b\"}]"); } -TEST(JSONParser, FailsOnMissingQuote) { +TEST(YAMLParser, FailsOnMissingQuote) { ExpectParseError("Missing open quote", "[{a\":\"b\"}]"); ExpectParseError("Missing closing quote", "[{\"a\":\"b}]"); } -TEST(JSONParser, ParsesEscapedQuotes) { +TEST(YAMLParser, ParsesEscapedQuotes) { ExpectParseSuccess("Parses escaped string in key and value", "[{\"a\":\"\\\"b\\\" \\\" \\\"\"}]"); } -TEST(JSONParser, ParsesEmptyString) { +TEST(YAMLParser, ParsesEmptyString) { ExpectParseSuccess("Parses empty string in value", "[{\"a\":\"\"}]"); } -TEST(JSONParser, FailsOnMissingString) { - ExpectParseError("Missing value", "[{\"a\":}]"); - ExpectParseError("Missing key", "[{:\"b\"}]"); -} - -TEST(JSONParser, ParsesMultipleObjects) { +TEST(YAMLParser, ParsesMultipleObjects) { ExpectParseSuccess( "Multiple objects in array", "[" @@ -105,7 +94,7 @@ TEST(JSONParser, ParsesMultipleObjects) { "]"); } -TEST(JSONParser, FailsOnMissingComma) { +TEST(YAMLParser, FailsOnMissingComma) { ExpectParseError( "Missing comma", "[" @@ -114,12 +103,7 @@ TEST(JSONParser, FailsOnMissingComma) { "]"); } -TEST(JSONParser, FailsOnSuperfluousComma) { - ExpectParseError("Superfluous comma in array", "[ { \"a\" : \"b\" }, ]"); - ExpectParseError("Superfluous comma in object", "{ \"a\" : \"b\", }"); -} - -TEST(JSONParser, ParsesSpacesInBetweenTokens) { +TEST(YAMLParser, ParsesSpacesInBetweenTokens) { ExpectParseSuccess( "Various whitespace between tokens", " \t \n\n \r [ \t \n\n \r" @@ -129,11 +113,11 @@ TEST(JSONParser, ParsesSpacesInBetweenTokens) { " \t \n\n \r \"b\"\t \n\n \r } \t \n\n \r]\t \n\n \r"); } -TEST(JSONParser, ParsesArrayOfArrays) { +TEST(YAMLParser, ParsesArrayOfArrays) { ExpectParseSuccess("Array of arrays", "[[]]"); } -TEST(JSONParser, HandlesEndOfFileGracefully) { +TEST(YAMLParser, HandlesEndOfFileGracefully) { ExpectParseError("In string starting with EOF", "[\""); ExpectParseError("In string hitting EOF", "[\" "); ExpectParseError("In string escaping EOF", "[\" \\"); @@ -149,10 +133,13 @@ TEST(JSONParser, HandlesEndOfFileGracefully) { static void ExpectCanParseString(StringRef String) { std::string StringInArray = (llvm::Twine("[\"") + String + "\"]").str(); SourceMgr SM; - JSONParser Parser(StringInArray, &SM); - const JSONArray *ParsedArray = dyn_cast<JSONArray>(Parser.parseRoot()); - StringRef ParsedString = - dyn_cast<JSONString>(*ParsedArray->begin())->getRawText(); + 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()); } @@ -163,7 +150,7 @@ static void ExpectCannotParseString(StringRef String) { StringInArray); } -TEST(JSONParser, ParsesStrings) { +TEST(YAMLParser, ParsesStrings) { ExpectCanParseString(""); ExpectCannotParseString("\\"); ExpectCannotParseString("\""); @@ -181,10 +168,11 @@ TEST(JSONParser, ParsesStrings) { ExpectCanParseString(" \\\\ \\\" \\\\\\\" "); } -TEST(JSONParser, WorksWithIteratorAlgorithms) { +TEST(YAMLParser, WorksWithIteratorAlgorithms) { SourceMgr SM; - JSONParser Parser("[\"1\", \"2\", \"3\", \"4\", \"5\", \"6\"]", &SM); - const JSONArray *Array = dyn_cast<JSONArray>(Parser.parseRoot()); + 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())); } |