1 //===- SpecialCaseList.cpp - Unit tests for SpecialCaseList ---------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 #include "llvm/IR/Function.h"
11 #include "llvm/IR/LLVMContext.h"
12 #include "llvm/IR/Module.h"
13 #include "llvm/Support/MemoryBuffer.h"
14 #include "llvm/Transforms/Utils/SpecialCaseList.h"
15 #include "gtest/gtest.h"
21 class SpecialCaseListTest : public ::testing::Test {
23 Function *makeFunction(StringRef Name, Module &M) {
24 return Function::Create(FunctionType::get(Type::getVoidTy(Ctx), false),
25 GlobalValue::ExternalLinkage,
30 GlobalVariable *makeGlobal(StringRef Name, StringRef StructName, Module &M) {
32 StructType::create(StructName, Type::getInt32Ty(Ctx), (Type*)0);
33 return new GlobalVariable(
34 M, ST, false, GlobalValue::ExternalLinkage, 0, Name);
37 SpecialCaseList *makeSpecialCaseList(StringRef List, std::string &Error) {
38 OwningPtr<MemoryBuffer> MB(MemoryBuffer::getMemBuffer(List));
39 return SpecialCaseList::create(MB.get(), Error);
42 SpecialCaseList *makeSpecialCaseList(StringRef List) {
44 SpecialCaseList *SCL = makeSpecialCaseList(List, Error);
53 TEST_F(SpecialCaseListTest, ModuleIsIn) {
54 Module M("hello", Ctx);
55 Function *F = makeFunction("foo", M);
56 GlobalVariable *GV = makeGlobal("bar", "t", M);
58 OwningPtr<SpecialCaseList> SCL(makeSpecialCaseList("# This is a comment.\n"
61 EXPECT_TRUE(SCL->isIn(M));
62 EXPECT_TRUE(SCL->isIn(*F));
63 EXPECT_TRUE(SCL->isIn(*GV));
65 SCL.reset(makeSpecialCaseList("src:he*o\n"));
66 EXPECT_TRUE(SCL->isIn(M));
67 EXPECT_TRUE(SCL->isIn(*F));
68 EXPECT_TRUE(SCL->isIn(*GV));
70 SCL.reset(makeSpecialCaseList("src:hi\n"));
71 EXPECT_FALSE(SCL->isIn(M));
72 EXPECT_FALSE(SCL->isIn(*F));
73 EXPECT_FALSE(SCL->isIn(*GV));
76 TEST_F(SpecialCaseListTest, FunctionIsIn) {
77 Module M("hello", Ctx);
78 Function *Foo = makeFunction("foo", M);
79 Function *Bar = makeFunction("bar", M);
81 OwningPtr<SpecialCaseList> SCL(makeSpecialCaseList("fun:foo\n"));
82 EXPECT_TRUE(SCL->isIn(*Foo));
83 EXPECT_FALSE(SCL->isIn(*Bar));
85 SCL.reset(makeSpecialCaseList("fun:b*\n"));
86 EXPECT_FALSE(SCL->isIn(*Foo));
87 EXPECT_TRUE(SCL->isIn(*Bar));
89 SCL.reset(makeSpecialCaseList("fun:f*\n"
91 EXPECT_TRUE(SCL->isIn(*Foo));
92 EXPECT_TRUE(SCL->isIn(*Bar));
94 SCL.reset(makeSpecialCaseList("fun:foo=functional\n"));
95 EXPECT_TRUE(SCL->isIn(*Foo, "functional"));
97 EXPECT_TRUE(SCL->findCategory(*Foo, Category));
98 EXPECT_EQ("functional", Category);
99 EXPECT_FALSE(SCL->isIn(*Bar, "functional"));
102 TEST_F(SpecialCaseListTest, GlobalIsIn) {
103 Module M("hello", Ctx);
104 GlobalVariable *Foo = makeGlobal("foo", "t1", M);
105 GlobalVariable *Bar = makeGlobal("bar", "t2", M);
107 OwningPtr<SpecialCaseList> SCL(makeSpecialCaseList("global:foo\n"));
108 EXPECT_TRUE(SCL->isIn(*Foo));
109 EXPECT_FALSE(SCL->isIn(*Bar));
110 EXPECT_FALSE(SCL->isIn(*Foo, "init"));
111 EXPECT_FALSE(SCL->isIn(*Bar, "init"));
113 SCL.reset(makeSpecialCaseList("global:foo=init\n"));
114 EXPECT_FALSE(SCL->isIn(*Foo));
115 EXPECT_FALSE(SCL->isIn(*Bar));
116 EXPECT_TRUE(SCL->isIn(*Foo, "init"));
117 EXPECT_FALSE(SCL->isIn(*Bar, "init"));
119 SCL.reset(makeSpecialCaseList("global-init:foo\n"));
120 EXPECT_FALSE(SCL->isIn(*Foo));
121 EXPECT_FALSE(SCL->isIn(*Bar));
122 EXPECT_TRUE(SCL->isIn(*Foo, "init"));
123 EXPECT_FALSE(SCL->isIn(*Bar, "init"));
125 SCL.reset(makeSpecialCaseList("type:t2=init\n"));
126 EXPECT_FALSE(SCL->isIn(*Foo));
127 EXPECT_FALSE(SCL->isIn(*Bar));
128 EXPECT_FALSE(SCL->isIn(*Foo, "init"));
129 EXPECT_TRUE(SCL->isIn(*Bar, "init"));
131 SCL.reset(makeSpecialCaseList("global-init-type:t2\n"));
132 EXPECT_FALSE(SCL->isIn(*Foo));
133 EXPECT_FALSE(SCL->isIn(*Bar));
134 EXPECT_FALSE(SCL->isIn(*Foo, "init"));
135 EXPECT_TRUE(SCL->isIn(*Bar, "init"));
137 SCL.reset(makeSpecialCaseList("src:hello=init\n"));
138 EXPECT_FALSE(SCL->isIn(*Foo));
139 EXPECT_FALSE(SCL->isIn(*Bar));
140 EXPECT_TRUE(SCL->isIn(*Foo, "init"));
141 EXPECT_TRUE(SCL->isIn(*Bar, "init"));
143 SCL.reset(makeSpecialCaseList("global-init-src:hello\n"));
144 EXPECT_FALSE(SCL->isIn(*Foo));
145 EXPECT_FALSE(SCL->isIn(*Bar));
146 EXPECT_TRUE(SCL->isIn(*Foo, "init"));
147 EXPECT_TRUE(SCL->isIn(*Bar, "init"));
150 TEST_F(SpecialCaseListTest, Substring) {
151 Module M("othello", Ctx);
152 Function *F = makeFunction("tomfoolery", M);
153 GlobalVariable *GV = makeGlobal("bartender", "t", M);
155 OwningPtr<SpecialCaseList> SCL(makeSpecialCaseList("src:hello\n"
158 EXPECT_FALSE(SCL->isIn(M));
159 EXPECT_FALSE(SCL->isIn(*F));
160 EXPECT_FALSE(SCL->isIn(*GV));
162 SCL.reset(makeSpecialCaseList("fun:*foo*\n"));
163 EXPECT_TRUE(SCL->isIn(*F));
166 TEST_F(SpecialCaseListTest, InvalidSpecialCaseList) {
168 EXPECT_EQ(0, makeSpecialCaseList("badline", Error));
169 EXPECT_EQ("Malformed line 1: 'badline'", Error);
170 EXPECT_EQ(0, makeSpecialCaseList("src:bad[a-", Error));
171 EXPECT_EQ("Malformed regex in line 1: 'bad[a-': invalid character range",
173 EXPECT_EQ(0, makeSpecialCaseList("src:a.c\n"
176 EXPECT_EQ("Malformed regex in line 2: 'fun(a': parentheses not balanced",
178 EXPECT_EQ(0, SpecialCaseList::create("unexisting", Error));
179 EXPECT_EQ("Can't open file 'unexisting': No such file or directory", Error);
182 TEST_F(SpecialCaseListTest, EmptySpecialCaseList) {
183 OwningPtr<SpecialCaseList> SCL(makeSpecialCaseList(""));
184 Module M("foo", Ctx);
185 EXPECT_FALSE(SCL->isIn(M));