fcd230adc6
- Rename `clang/{include,lib,unittests}/Analysis/Scalable/` to
`clang/{include,lib,unittests}/ScalableStaticAnalysisFramework/Core/`
- Update header-guards with their new paths
- Rename the library `clangAnalysisScalable` to
`clangScalableStaticAnalysisFrameworkCore`
- Add a new `Clang_ScalableStaticAnalysisFramework` module to
`module.modulemap`
- Update GN build files, GitHub PR labeler, and documentation
- Harmonise license comments
- Add a missing header-guard
118 lines
3.7 KiB
C++
118 lines
3.7 KiB
C++
//===- EntityLinkageTest.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 "clang/ScalableStaticAnalysisFramework/Core/Model/EntityLinkage.h"
|
|
#include "clang/ScalableStaticAnalysisFramework/Core/Support/FormatProviders.h"
|
|
#include "llvm/Support/FormatVariadic.h"
|
|
#include "llvm/Support/raw_ostream.h"
|
|
#include "gtest/gtest.h"
|
|
|
|
using clang::ssaf::EntityLinkage;
|
|
using clang::ssaf::EntityLinkageType;
|
|
|
|
namespace {
|
|
|
|
constexpr inline auto None = EntityLinkageType::None;
|
|
constexpr inline auto Internal = EntityLinkageType::Internal;
|
|
constexpr inline auto External = EntityLinkageType::External;
|
|
|
|
TEST(EntityLinkageTest, Constructor) {
|
|
EntityLinkage NoneLinkage(None);
|
|
EntityLinkage InternalLinkage(Internal);
|
|
EntityLinkage ExternalLinkage(External);
|
|
|
|
EXPECT_EQ(NoneLinkage.getLinkage(), None);
|
|
EXPECT_EQ(InternalLinkage.getLinkage(), Internal);
|
|
EXPECT_EQ(ExternalLinkage.getLinkage(), External);
|
|
}
|
|
|
|
TEST(EntityLinkageTest, CopyConstructor) {
|
|
EntityLinkage Original(External);
|
|
EntityLinkage Copy = Original;
|
|
|
|
EXPECT_EQ(Copy.getLinkage(), External);
|
|
EXPECT_EQ(Copy.getLinkage(), Original.getLinkage());
|
|
}
|
|
|
|
TEST(EntityLinkageTest, AssignmentOperator) {
|
|
EntityLinkage Linkage1(None);
|
|
EntityLinkage Linkage2(External);
|
|
|
|
Linkage1 = Linkage2;
|
|
|
|
EXPECT_EQ(Linkage1.getLinkage(), External);
|
|
EXPECT_EQ(Linkage1.getLinkage(), Linkage2.getLinkage());
|
|
}
|
|
|
|
TEST(EntityLinkageTest, EqualityOperatorReflexive) {
|
|
EXPECT_EQ(EntityLinkage(None), EntityLinkage(None));
|
|
EXPECT_EQ(EntityLinkage(Internal), EntityLinkage(Internal));
|
|
EXPECT_EQ(EntityLinkage(External), EntityLinkage(External));
|
|
}
|
|
|
|
TEST(EntityLinkageTest, EqualityOperatorDistinct) {
|
|
EXPECT_NE(EntityLinkage(None), EntityLinkage(Internal));
|
|
EXPECT_NE(EntityLinkage(None), EntityLinkage(External));
|
|
EXPECT_NE(EntityLinkage(Internal), EntityLinkage(External));
|
|
}
|
|
|
|
TEST(EntityLinkageTypeTest, FormatProvider) {
|
|
EXPECT_EQ(llvm::formatv("{0}", EntityLinkageType::None).str(), "None");
|
|
EXPECT_EQ(llvm::formatv("{0}", EntityLinkageType::Internal).str(),
|
|
"Internal");
|
|
EXPECT_EQ(llvm::formatv("{0}", EntityLinkageType::External).str(),
|
|
"External");
|
|
}
|
|
|
|
TEST(EntityLinkageTypeTest, StreamOutputNone) {
|
|
std::string S;
|
|
llvm::raw_string_ostream(S) << EntityLinkageType::None;
|
|
EXPECT_EQ(S, "None");
|
|
}
|
|
|
|
TEST(EntityLinkageTypeTest, StreamOutputInternal) {
|
|
std::string S;
|
|
llvm::raw_string_ostream(S) << EntityLinkageType::Internal;
|
|
EXPECT_EQ(S, "Internal");
|
|
}
|
|
|
|
TEST(EntityLinkageTypeTest, StreamOutputExternal) {
|
|
std::string S;
|
|
llvm::raw_string_ostream(S) << EntityLinkageType::External;
|
|
EXPECT_EQ(S, "External");
|
|
}
|
|
|
|
TEST(EntityLinkageTest, FormatProvider) {
|
|
EXPECT_EQ(llvm::formatv("{0}", EntityLinkage(None)).str(),
|
|
"EntityLinkage(None)");
|
|
EXPECT_EQ(llvm::formatv("{0}", EntityLinkage(Internal)).str(),
|
|
"EntityLinkage(Internal)");
|
|
EXPECT_EQ(llvm::formatv("{0}", EntityLinkage(External)).str(),
|
|
"EntityLinkage(External)");
|
|
}
|
|
|
|
TEST(EntityLinkageTest, StreamOutputNone) {
|
|
std::string S;
|
|
llvm::raw_string_ostream(S) << EntityLinkage(None);
|
|
EXPECT_EQ(S, "EntityLinkage(None)");
|
|
}
|
|
|
|
TEST(EntityLinkageTest, StreamOutputInternal) {
|
|
std::string S;
|
|
llvm::raw_string_ostream(S) << EntityLinkage(Internal);
|
|
EXPECT_EQ(S, "EntityLinkage(Internal)");
|
|
}
|
|
|
|
TEST(EntityLinkageTest, StreamOutputExternal) {
|
|
std::string S;
|
|
llvm::raw_string_ostream(S) << EntityLinkage(External);
|
|
EXPECT_EQ(S, "EntityLinkage(External)");
|
|
}
|
|
|
|
} // namespace
|