89 lines
2.8 KiB
C++
89 lines
2.8 KiB
C++
//===- StringMapEntryTest.cpp ---------------------------------------------===//
|
|
//
|
|
// 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/Testing/ADT/StringMapEntry.h"
|
|
#include "llvm/ADT/StringMap.h"
|
|
|
|
#include "gtest/gtest.h"
|
|
#include <sstream>
|
|
|
|
namespace llvm {
|
|
namespace {
|
|
|
|
using testing::Gt;
|
|
using testing::Matcher;
|
|
using testing::StrCaseEq;
|
|
using testing::StringMatchResultListener;
|
|
using testing::UnorderedElementsAre;
|
|
|
|
template <typename T> std::string Describe(const Matcher<T> &M, bool Match) {
|
|
std::stringstream SS;
|
|
if (Match) {
|
|
M.DescribeTo(&SS);
|
|
} else {
|
|
M.DescribeNegationTo(&SS);
|
|
}
|
|
return SS.str();
|
|
}
|
|
|
|
template <typename T, typename V>
|
|
std::string ExplainMatch(const Matcher<T> &Matcher, const V &Value) {
|
|
StringMatchResultListener Listener;
|
|
Matcher.MatchAndExplain(Value, &Listener);
|
|
return Listener.str();
|
|
}
|
|
|
|
TEST(IsStringMapEntryTest, InnerMatchersAreExactValues) {
|
|
llvm::StringMap<int> Map = {{"A", 1}};
|
|
EXPECT_THAT(*Map.find("A"), IsStringMapEntry("A", 1));
|
|
}
|
|
|
|
TEST(IsStringMapEntryTest, InnerMatchersAreOtherMatchers) {
|
|
llvm::StringMap<int> Map = {{"A", 1}};
|
|
EXPECT_THAT(*Map.find("A"), IsStringMapEntry(StrCaseEq("a"), Gt(0)));
|
|
}
|
|
|
|
TEST(IsStringMapEntryTest, UseAsInnerMatcher) {
|
|
llvm::StringMap<int> Map = {{"A", 1}, {"B", 2}};
|
|
EXPECT_THAT(Map, UnorderedElementsAre(IsStringMapEntry("A", 1),
|
|
IsStringMapEntry("B", 2)));
|
|
}
|
|
|
|
TEST(IsStringMapEntryTest, DescribeSelf) {
|
|
Matcher<llvm::StringMapEntry<int>> M = IsStringMapEntry("A", 1);
|
|
EXPECT_EQ(
|
|
R"(has a string key that is equal to "A", and has a value that is equal to 1)",
|
|
Describe(M, true));
|
|
EXPECT_EQ(
|
|
R"(has a string key that isn't equal to "A", or has a value that isn't equal to 1)",
|
|
Describe(M, false));
|
|
}
|
|
|
|
TEST(IsStringMapEntryTest, ExplainSelfMatchSuccess) {
|
|
llvm::StringMap<int> Map = {{"A", 1}};
|
|
Matcher<llvm::StringMapEntry<int>> M = IsStringMapEntry("A", 1);
|
|
EXPECT_EQ(R"(which is a match)", ExplainMatch(M, *Map.find("A")));
|
|
}
|
|
|
|
TEST(IsStringMapEntryTest, ExplainSelfMatchFailsOnKey) {
|
|
llvm::StringMap<int> Map = {{"B", 1}};
|
|
Matcher<llvm::StringMapEntry<int>> M = IsStringMapEntry("A", 1);
|
|
EXPECT_EQ(R"(which has a string key that doesn't match)",
|
|
ExplainMatch(M, *Map.find("B")));
|
|
}
|
|
|
|
TEST(IsStringMapEntryTest, ExplainSelfMatchFailsOnValue) {
|
|
llvm::StringMap<int> Map = {{"A", 2}};
|
|
Matcher<llvm::StringMapEntry<int>> M = IsStringMapEntry("A", 1);
|
|
EXPECT_EQ(R"(which has a value that doesn't match)",
|
|
ExplainMatch(M, *Map.find("A")));
|
|
}
|
|
|
|
} // namespace
|
|
} // namespace llvm
|