unittests/Transforms/Utils/SpecialCaseList.cpp

   1 //===- SpecialCaseList.cpp - Unit tests for SpecialCaseList ---------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  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"
  16
  17 using namespace llvm;
  18
  19 namespace {
  20
  21 class SpecialCaseListTest : public ::testing::Test {
  22 protected:
  23   Function *makeFunction(StringRef Name, Module &M) {
  24     return Function::Create(FunctionType::get(Type::getVoidTy(Ctx), false),
  25                             GlobalValue::ExternalLinkage,
  26                             Name,
  27                             &M);
  28   }
  29
  30   GlobalVariable *makeGlobal(StringRef Name, StringRef StructName, Module &M) {
  31     StructType *ST =
  32         StructType::create(StructName, Type::getInt32Ty(Ctx), (Type*)0);
  33     return new GlobalVariable(
  34         M, ST, false, GlobalValue::ExternalLinkage, 0, Name);
  35   }
  36
  37   SpecialCaseList *makeSpecialCaseList(StringRef List, std::string &Error) {
  38     OwningPtr<MemoryBuffer> MB(MemoryBuffer::getMemBuffer(List));
  39     return SpecialCaseList::create(MB.get(), Error);
  40   }
  41
  42   SpecialCaseList *makeSpecialCaseList(StringRef List) {
  43     std::string Error;
  44     SpecialCaseList *SCL = makeSpecialCaseList(List, Error);
  45     assert(SCL);
  46     assert(Error == "");
  47     return SCL;
  48   }
  49
  50   LLVMContext Ctx;
  51 };
  52
  53 TEST_F(SpecialCaseListTest, ModuleIsIn) {
  54   Module M("hello", Ctx);
  55   Function *F = makeFunction("foo", M);
  56   GlobalVariable *GV = makeGlobal("bar", "t", M);
  57
  58   OwningPtr<SpecialCaseList> SCL(makeSpecialCaseList("# This is a comment.\n"
  59                                                      "\n"
  60                                                      "src:hello\n"));
  61   EXPECT_TRUE(SCL->isIn(M));
  62   EXPECT_TRUE(SCL->isIn(*F));
  63   EXPECT_TRUE(SCL->isIn(*GV));
  64
  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));
  69
  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));
  74 }
  75
  76 TEST_F(SpecialCaseListTest, FunctionIsIn) {
  77   Module M("hello", Ctx);
  78   Function *Foo = makeFunction("foo", M);
  79   Function *Bar = makeFunction("bar", M);
  80
  81   OwningPtr<SpecialCaseList> SCL(makeSpecialCaseList("fun:foo\n"));
  82   EXPECT_TRUE(SCL->isIn(*Foo));
  83   EXPECT_FALSE(SCL->isIn(*Bar));
  84
  85   SCL.reset(makeSpecialCaseList("fun:b*\n"));
  86   EXPECT_FALSE(SCL->isIn(*Foo));
  87   EXPECT_TRUE(SCL->isIn(*Bar));
  88
  89   SCL.reset(makeSpecialCaseList("fun:f*\n"
  90                                 "fun:bar\n"));
  91   EXPECT_TRUE(SCL->isIn(*Foo));
  92   EXPECT_TRUE(SCL->isIn(*Bar));
  93
  94   SCL.reset(makeSpecialCaseList("fun:foo=functional\n"));
  95   EXPECT_TRUE(SCL->isIn(*Foo, "functional"));
  96   StringRef Category;
  97   EXPECT_TRUE(SCL->findCategory(*Foo, Category));
  98   EXPECT_EQ("functional", Category);
  99   EXPECT_FALSE(SCL->isIn(*Bar, "functional"));
 100 }
 101
 102 TEST_F(SpecialCaseListTest, GlobalIsIn) {
 103   Module M("hello", Ctx);
 104   GlobalVariable *Foo = makeGlobal("foo", "t1", M);
 105   GlobalVariable *Bar = makeGlobal("bar", "t2", M);
 106
 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"));
 112
 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"));
 118
 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"));
 124
 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"));
 130
 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"));
 136
 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"));
 142
 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"));
 148 }
 149
 150 TEST_F(SpecialCaseListTest, Substring) {
 151   Module M("othello", Ctx);
 152   Function *F = makeFunction("tomfoolery", M);
 153   GlobalVariable *GV = makeGlobal("bartender", "t", M);
 154
 155   OwningPtr<SpecialCaseList> SCL(makeSpecialCaseList("src:hello\n"
 156                                                      "fun:foo\n"
 157                                                      "global:bar\n"));
 158   EXPECT_FALSE(SCL->isIn(M));
 159   EXPECT_FALSE(SCL->isIn(*F));
 160   EXPECT_FALSE(SCL->isIn(*GV));
 161
 162   SCL.reset(makeSpecialCaseList("fun:*foo*\n"));
 163   EXPECT_TRUE(SCL->isIn(*F));
 164 }
 165
 166 TEST_F(SpecialCaseListTest, InvalidSpecialCaseList) {
 167   std::string Error;
 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",
 172             Error);
 173   EXPECT_EQ(0, makeSpecialCaseList("src:a.c\n"
 174                                    "fun:fun(a\n",
 175                                    Error));
 176   EXPECT_EQ("Malformed regex in line 2: 'fun(a': parentheses not balanced",
 177             Error);
 178   EXPECT_EQ(0, SpecialCaseList::create("unexisting", Error));
 179   EXPECT_EQ(0U, Error.find("Can't open file 'unexisting':"));
 180 }
 181
 182 TEST_F(SpecialCaseListTest, EmptySpecialCaseList) {
 183   OwningPtr<SpecialCaseList> SCL(makeSpecialCaseList(""));
 184   Module M("foo", Ctx);
 185   EXPECT_FALSE(SCL->isIn(M));
 186 }
 187
 188 }