[RFC] Introduce support for multiple sanitizer blacklists (LLVM side).

[pcc]

Summary

This adds support for multiple -fsanitize-blacklist flags, which cause
clang to load blacklists from each of the specified paths. This could be
useful for sanitizers such as DFSan where we may have multiple ABI lists,
each covering a specific library, which describes the ABI of that library.

This changes the semantics of the -fsanitize-blacklist flag, so I wanted to
make sure that we were comfortable with that. Now, the flag is additive, so a
-fsanitize-blacklist flag on the command line loads the specified blacklist
as well as the one in the resource directory. The -fno-sanitize-blacklist
flag works as before in that it prevents the blacklist in the resource
directory from being loaded, but it can also be used in combination with
-fsanitize-blacklist to load only user-specified blacklists.

Tests to come. I've removed the one test which fails as a result of the
changed semantics.

[samsonov]

I'm fine with general direction of this patch. Having multiple blacklists for different parts of code base looks like a legit use case.

I don't like proliferation of std::unique_ptr across interfaces, though. I would prefer to have them more lightweight. Can we add one more factory:

llvm::SpecialCaseList::createOrDie(const std::vector<std::string> &Paths);

In this case Clang's BackendUtil won't have to bother about creating SpecialCaseList - it will just pass CGOpts.SanitizerBlacklistFiles to the DFSan instrumentation pass.

lib/Support/SpecialCaseList.cpp

135–136

You're now using a vector of Regexps. Either use "|" (as done here) to merge them into a single Regexp, or use push_back everywhere.

[pcc]

I don't like proliferation of std::unique_ptr across interfaces, though. I would prefer to have them more lightweight. Can we add one more factory:
llvm::SpecialCaseList::createOrDie(const std::vector<std::string> &Paths);
In this case Clang's BackendUtil won't have to bother about creating SpecialCaseList - it will just pass CGOpts.SanitizerBlacklistFiles to the DFSan instrumentation pass.

I would prefer not to. It seems to me that passing SpecialCaseLists around would give us a little more flexibility. For example, it would make it easier to accept ad-hoc entries on the command line, or do things like dynamically load ABI lists out of object files.

lib/Support/SpecialCaseList.cpp

135–136

Okay, I'll change this to use one regexp per entry. It doesn't seem like we were getting much benefit out of having a single regexp for all entries, given the poor performance I was seeing before.

[pcc]

Add tests and address reviewer comments.

include/llvm/Support/SpecialCaseList.h

 
 namespace llvm {
 class MemoryBuffer;
 class Regex;
 class StringRef;
 
 class SpecialCaseList {
  public:
-  /// Parses the special case list from a file. If Path is empty, returns
-  /// an empty special case list. On failure, returns 0 and writes an error
-  /// message to string.
-  static SpecialCaseList *create(const StringRef Path, std::string &Error);
-  /// Parses the special case list from a memory buffer. On failure, returns
-  /// 0 and writes an error message to string.
-  static SpecialCaseList *create(const MemoryBuffer *MB, std::string &Error);
-  /// Parses the special case list from a file. On failure, reports a fatal
-  /// error.
-  static SpecialCaseList *createOrDie(const StringRef Path);
+  /// Parses the special case list from a file. If Path is empty, returns an
+  /// empty special case list. On failure, reports a fatal error.
+  static std::unique_ptr<SpecialCaseList> createOrDie(const StringRef Path);
 
+  SpecialCaseList();
   ~SpecialCaseList();
 
+  /// Parses the special case list from a file. Returns true if successful. On
+  /// failure, writes an error message to \param Error.
+  bool loadFromFile(StringRef Path, std::string &Error);
+  /// Parses the special case list from a memory buffer. Returns true if
+  /// successful. On failure, writes an error message to \param Error.
+  bool loadFromBuffer(const MemoryBuffer *MB, std::string &Error);
+
   /// Returns true, if special case list contains a line
   /// \code
   ///   @Section:<E>=@Category
   /// \endcode
   /// and @Query satisfies a wildcard expression <E>.
   bool inSection(const StringRef Section, const StringRef Query,
                  const StringRef Category = StringRef()) const;
 
  private:
   SpecialCaseList(SpecialCaseList const &) LLVM_DELETED_FUNCTION;
   SpecialCaseList &operator=(SpecialCaseList const &) LLVM_DELETED_FUNCTION;
 
   struct Entry;
   StringMap<StringMap<Entry> > Entries;
-
-  SpecialCaseList();
-  /// Parses just-constructed SpecialCaseList entries from a memory buffer.
-  bool parse(const MemoryBuffer *MB, std::string &Error);
 };
 
 }  // namespace llvm
 
 #endif  // LLVM_SUPPORT_SPECIALCASELIST_H
 

include/llvm/Transforms/Instrumentation.h

 // This file defines constructor functions for instrumentation passes.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TRANSFORMS_INSTRUMENTATION_H
 #define LLVM_TRANSFORMS_INSTRUMENTATION_H
 
 #include "llvm/ADT/StringRef.h"
+#include "llvm/Support/SpecialCaseList.h"
+#include <memory>
 
 #if defined(__GNUC__) && defined(__linux__) && !defined(ANDROID)
 inline void *getDFSanArgTLSPtrForJIT() {
   extern __thread __attribute__((tls_model("initial-exec")))
     void *__dfsan_arg_tls;
   return (void *)&__dfsan_arg_tls;
 }
 

 
 // Insert MemorySanitizer instrumentation (detection of uninitialized reads)
 FunctionPass *createMemorySanitizerPass(int TrackOrigins = 0);
 
 // Insert ThreadSanitizer (race detection) instrumentation
 FunctionPass *createThreadSanitizerPass();
 
 // Insert DataFlowSanitizer (dynamic data flow analysis) instrumentation
-ModulePass *createDataFlowSanitizerPass(StringRef ABIListFile = StringRef(),
+ModulePass *createDataFlowSanitizerPass(std::unique_ptr<SpecialCaseList> ABIL,
                                         void *(*getArgTLS)() = nullptr,
                                         void *(*getRetValTLS)() = nullptr);
 
 #if defined(__GNUC__) && defined(__linux__) && !defined(ANDROID)
-inline ModulePass *createDataFlowSanitizerPassForJIT(StringRef ABIListFile =
-                                                         StringRef()) {
-  return createDataFlowSanitizerPass(ABIListFile, getDFSanArgTLSPtrForJIT,
-                                     getDFSanRetValTLSPtrForJIT);
+inline ModulePass *
+createDataFlowSanitizerPassForJIT(std::unique_ptr<SpecialCaseList> ABIList) {
+  return createDataFlowSanitizerPass(
+      std::move(ABIList), getDFSanArgTLSPtrForJIT, getDFSanRetValTLSPtrForJIT);
 }
 #endif
 
 // BoundsChecking - This pass instruments the code to perform run-time bounds
 // checking on loads, stores, and other memory intrinsics.
 FunctionPass *createBoundsCheckingPass();
 
 /// createDebugIRPass - Enable interactive stepping through LLVM IR in LLDB (or

lib/Support/SpecialCaseList.cpp

 /// Represents a set of regular expressions.  Regular expressions which are
 /// "literal" (i.e. no regex metacharacters) are stored in Strings, while all
 /// others are represented as a single pipe-separated regex in RegEx.  The
 /// reason for doing so is efficiency; StringSet is much faster at matching
 /// literal strings than Regex.
 struct SpecialCaseList::Entry {
   Entry() {}
   Entry(Entry &&Other)
-      : Strings(std::move(Other.Strings)), RegEx(std::move(Other.RegEx)) {}
+      : Strings(std::move(Other.Strings)), RegExps(std::move(Other.RegExps)) {}
 
   StringSet<> Strings;
-  std::unique_ptr<Regex> RegEx;
+  std::vector<std::unique_ptr<Regex>> RegExps;
 
   bool match(StringRef Query) const {
-    return Strings.count(Query) || (RegEx && RegEx->match(Query));
+    if (Strings.count(Query))
+      return true;
+    for (auto &&RE : RegExps) {
+      if (RE->match(Query))
+        return true;
+    }
+    return false;
   }
 };
 
-SpecialCaseList::SpecialCaseList() : Entries() {}
+SpecialCaseList::SpecialCaseList() {}
 
-SpecialCaseList *SpecialCaseList::create(
-    const StringRef Path, std::string &Error) {
+std::unique_ptr<SpecialCaseList>
+SpecialCaseList::createOrDie(const StringRef Path) {
+  auto SCL = make_unique<SpecialCaseList>();
   if (Path.empty())
-    return new SpecialCaseList();
+    return std::move(SCL);
+  std::string Error;
+  if (!SCL->loadFromFile(Path, Error))
+    report_fatal_error(Error);
+  return std::move(SCL);
+}
+
+bool SpecialCaseList::loadFromFile(StringRef Path, std::string &Error) {
   ErrorOr<std::unique_ptr<MemoryBuffer>> FileOrErr =
       MemoryBuffer::getFile(Path);
   if (std::error_code EC = FileOrErr.getError()) {
     Error = (Twine("Can't open file '") + Path + "': " + EC.message()).str();
     return nullptr;
   }
-  return create(FileOrErr.get().get(), Error);
+  return loadFromBuffer(FileOrErr.get().get(), Error);
 }
 
-SpecialCaseList *SpecialCaseList::create(
-    const MemoryBuffer *MB, std::string &Error) {
-  std::unique_ptr<SpecialCaseList> SCL(new SpecialCaseList());
-  if (!SCL->parse(MB, Error))
-    return nullptr;
-  return SCL.release();
-}
-
-SpecialCaseList *SpecialCaseList::createOrDie(const StringRef Path) {
-  std::string Error;
-  if (SpecialCaseList *SCL = create(Path, Error))
-    return SCL;
-  report_fatal_error(Error);
-}
-
-bool SpecialCaseList::parse(const MemoryBuffer *MB, std::string &Error) {
+bool SpecialCaseList::loadFromBuffer(const MemoryBuffer *MB, std::string &Error) {
   // Iterate through each line in the blacklist file.
   SmallVector<StringRef, 16> Lines;
   SplitString(MB->getBuffer(), Lines, "\n\r");
-  StringMap<StringMap<std::string> > Regexps;
-  assert(Entries.empty() &&
-         "parse() should be called on an empty SpecialCaseList");
   int LineNo = 1;
   for (SmallVectorImpl<StringRef>::iterator I = Lines.begin(), E = Lines.end();
        I != E; ++I, ++LineNo) {
     // Ignore empty lines and lines starting with "#"
     if (I->empty() || I->startswith("#"))
       continue;
     // Get our prefix and unparsed regexp.
     std::pair<StringRef, StringRef> SplitLine = I->split(":");
for (SmallVectorImpl<StringRef>::iterator I = Lines.begin(), E = Lines.end();
     }
 
     // Replace * with .*
     for (size_t pos = 0; (pos = Regexp.find("*", pos)) != std::string::npos;
          pos += strlen(".*")) {
       Regexp.replace(pos, strlen("*"), ".*");
     }
 
-    // Check that the regexp is valid.
-    Regex CheckRE(Regexp);
+    auto RE = make_unique<Regex>("^" + Regexp + "$");
     std::string REError;
-    if (!CheckRE.isValid(REError)) {
+    // Check that the regexp is valid.
+    if (!RE->isValid(REError)) {
       Error = (Twine("Malformed regex in line ") + Twine(LineNo) + ": '" +
                SplitLine.second + "': " + REError).str();
       return false;
     }
 
     // Add this regexp into the proper group by its prefix.
-    if (!Regexps[Prefix][Category].empty())
-      Regexps[Prefix][Category] += "|";
-    Regexps[Prefix][Category] += "^" + Regexp + "$";
+    Entries[Prefix][Category].RegExps.push_back(std::move(RE));
   }
 
-  // Iterate through each of the prefixes, and create Regexs for them.
-  for (StringMap<StringMap<std::string> >::const_iterator I = Regexps.begin(),
-                                                          E = Regexps.end();
-       I != E; ++I) {
-    for (StringMap<std::string>::const_iterator II = I->second.begin(),
-                                                IE = I->second.end();
-         II != IE; ++II) {
-      Entries[I->getKey()][II->getKey()].RegEx.reset(new Regex(II->getValue()));
-    }
-  }
   return true;
 }
 
 SpecialCaseList::~SpecialCaseList() {}
 
 bool SpecialCaseList::inSection(const StringRef Section, const StringRef Query,
                                 const StringRef Category) const {
   StringMap<StringMap<Entry> >::const_iterator I = Entries.find(Section);
   if (I == Entries.end()) return false;
   StringMap<Entry>::const_iterator II = I->second.find(Category);
   if (II == I->second.end()) return false;
 
   return II->getValue().match(Query);
 }
 
 }  // namespace llvm

lib/Transforms/Instrumentation/DataFlowSanitizer.cpp

StringRef GetGlobalTypeString(const GlobalValue &G) {
   }
   return "<unknown type>";
 }
 
 class DFSanABIList {
   std::unique_ptr<SpecialCaseList> SCL;
 
  public:
-  DFSanABIList(SpecialCaseList *SCL) : SCL(SCL) {}
+  DFSanABIList(std::unique_ptr<SpecialCaseList> SCL) : SCL(std::move(SCL)) {}
 
   /// Returns whether either this function or its source file are listed in the
   /// given category.
   bool isIn(const Function &F, const StringRef Category) const {
     return isIn(*F.getParent(), Category) ||
            SCL->inSection("fun", F.getName(), Category);
   }
 
class DataFlowSanitizer : public ModulePass {
   WrapperKind getWrapperKind(Function *F);
   void addGlobalNamePrefix(GlobalValue *GV);
   Function *buildWrapperFunction(Function *F, StringRef NewFName,
                                  GlobalValue::LinkageTypes NewFLink,
                                  FunctionType *NewFT);
   Constant *getOrBuildTrampolineFunction(FunctionType *FT, StringRef FName);
 
  public:
-  DataFlowSanitizer(StringRef ABIListFile = StringRef(),
+  DataFlowSanitizer(std::unique_ptr<SpecialCaseList> ABIList =
+                        std::unique_ptr<SpecialCaseList>(),
                     void *(*getArgTLS)() = nullptr,
                     void *(*getRetValTLS)() = nullptr);
   static char ID;
   bool doInitialization(Module &M) override;
   bool runOnModule(Module &M) override;
 };
 
 struct DFSanFunction {

 };
 
 }
 
 char DataFlowSanitizer::ID;
 INITIALIZE_PASS(DataFlowSanitizer, "dfsan",
                 "DataFlowSanitizer: dynamic data flow analysis.", false, false)
 
-ModulePass *llvm::createDataFlowSanitizerPass(StringRef ABIListFile,
-                                              void *(*getArgTLS)(),
-                                              void *(*getRetValTLS)()) {
-  return new DataFlowSanitizer(ABIListFile, getArgTLS, getRetValTLS);
+ModulePass *
+llvm::createDataFlowSanitizerPass(std::unique_ptr<SpecialCaseList> ABIList,
+  return new DataFlowSanitizer(std::move(ABIList), getArgTLS, getRetValTLS);
 }
 
-DataFlowSanitizer::DataFlowSanitizer(StringRef ABIListFile,
+DataFlowSanitizer::DataFlowSanitizer(std::unique_ptr<SpecialCaseList> ABIList,
                                      void *(*getArgTLS)(),
                                      void *(*getRetValTLS)())
     : ModulePass(ID), GetArgTLSPtr(getArgTLS), GetRetvalTLSPtr(getRetValTLS),
-      ABIList(SpecialCaseList::createOrDie(ABIListFile.empty() ? ClABIListFile
-                                                               : ABIListFile)) {
-}
+      ABIList(ABIList ? std::move(ABIList)
+                      : SpecialCaseList::createOrDie(ClABIListFile)) {}
 
 FunctionType *DataFlowSanitizer::getArgsFunctionType(FunctionType *T) {
   llvm::SmallVector<Type *, 4> ArgTypes;
   std::copy(T->param_begin(), T->param_end(), std::back_inserter(ArgTypes));
   for (unsigned i = 0, e = T->getNumParams(); i != e; ++i)
     ArgTypes.push_back(ShadowTy);
   if (T->isVarArg())
     ArgTypes.push_back(ShadowPtrTy);

unittests/Support/SpecialCaseListTest.cpp

 //===- SpecialCaseListTest.cpp - Unit tests for SpecialCaseList -----------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
+#include "llvm/ADT/STLExtras.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/SpecialCaseList.h"
 #include "gtest/gtest.h"
 
 using namespace llvm;
 
 namespace {
 
 class SpecialCaseListTest : public ::testing::Test {
 protected:
-  SpecialCaseList *makeSpecialCaseList(StringRef List, std::string &Error) {
+  bool loadFromStr(SpecialCaseList *SCL, StringRef List, std::string &Error) {
     std::unique_ptr<MemoryBuffer> MB(MemoryBuffer::getMemBuffer(List));
-    return SpecialCaseList::create(MB.get(), Error);
+    return SCL->loadFromBuffer(MB.get(), Error);
   }
 
-  SpecialCaseList *makeSpecialCaseList(StringRef List) {
+  std::unique_ptr<SpecialCaseList> makeSpecialCaseList(StringRef List, std::string &Error) {
+    auto SCL = make_unique<SpecialCaseList>();
+    if (!loadFromStr(SCL.get(), List, Error))
+      return nullptr;
+    return SCL;
+  }
+
+  std::unique_ptr<SpecialCaseList> makeSpecialCaseList(StringRef List) {
     std::string Error;
-    SpecialCaseList *SCL = makeSpecialCaseList(List, Error);
+    auto SCL = makeSpecialCaseList(List, Error);
     assert(SCL);
     assert(Error == "");
     return SCL;
   }
 };
 
 TEST_F(SpecialCaseListTest, Basic) {
-  std::unique_ptr<SpecialCaseList> SCL(
+  auto SCL =
       makeSpecialCaseList("# This is a comment.\n"
                           "\n"
                           "src:hello\n"
                           "src:bye\n"
                           "src:hi=category\n"
-                          "src:z*=category\n"));
+                          "src:z*=category\n");
   EXPECT_TRUE(SCL->inSection("src", "hello"));
   EXPECT_TRUE(SCL->inSection("src", "bye"));
   EXPECT_TRUE(SCL->inSection("src", "hi", "category"));
   EXPECT_TRUE(SCL->inSection("src", "zzzz", "category"));
   EXPECT_FALSE(SCL->inSection("src", "hi"));
   EXPECT_FALSE(SCL->inSection("fun", "hello"));
   EXPECT_FALSE(SCL->inSection("src", "hello", "category"));
 }
 
 TEST_F(SpecialCaseListTest, GlobalInitCompat) {
-  std::unique_ptr<SpecialCaseList> SCL(
-      makeSpecialCaseList("global:foo=init\n"));
+  auto SCL = makeSpecialCaseList("global:foo=init\n");
   EXPECT_FALSE(SCL->inSection("global", "foo"));
   EXPECT_FALSE(SCL->inSection("global", "bar"));
   EXPECT_TRUE(SCL->inSection("global", "foo", "init"));
   EXPECT_FALSE(SCL->inSection("global", "bar", "init"));
 
-  SCL.reset(makeSpecialCaseList("global-init:foo\n"));
+  SCL = makeSpecialCaseList("global-init:foo\n");
   EXPECT_FALSE(SCL->inSection("global", "foo"));
   EXPECT_FALSE(SCL->inSection("global", "bar"));
   EXPECT_TRUE(SCL->inSection("global", "foo", "init"));
   EXPECT_FALSE(SCL->inSection("global", "bar", "init"));
 
-  SCL.reset(makeSpecialCaseList("type:t2=init\n"));
+  SCL = makeSpecialCaseList("type:t2=init\n");
   EXPECT_FALSE(SCL->inSection("type", "t1"));
   EXPECT_FALSE(SCL->inSection("type", "t2"));
   EXPECT_FALSE(SCL->inSection("type", "t1", "init"));
   EXPECT_TRUE(SCL->inSection("type", "t2", "init"));
 
-  SCL.reset(makeSpecialCaseList("global-init-type:t2\n"));
+  SCL = makeSpecialCaseList("global-init-type:t2\n");
   EXPECT_FALSE(SCL->inSection("type", "t1"));
   EXPECT_FALSE(SCL->inSection("type", "t2"));
   EXPECT_FALSE(SCL->inSection("type", "t1", "init"));
   EXPECT_TRUE(SCL->inSection("type", "t2", "init"));
 
-  SCL.reset(makeSpecialCaseList("src:hello=init\n"));
+  SCL = makeSpecialCaseList("src:hello=init\n");
   EXPECT_FALSE(SCL->inSection("src", "hello"));
   EXPECT_FALSE(SCL->inSection("src", "bye"));
   EXPECT_TRUE(SCL->inSection("src", "hello", "init"));
   EXPECT_FALSE(SCL->inSection("src", "bye", "init"));
 
-  SCL.reset(makeSpecialCaseList("global-init-src:hello\n"));
+  SCL = makeSpecialCaseList("global-init-src:hello\n");
   EXPECT_FALSE(SCL->inSection("src", "hello"));
   EXPECT_FALSE(SCL->inSection("src", "bye"));
   EXPECT_TRUE(SCL->inSection("src", "hello", "init"));
   EXPECT_FALSE(SCL->inSection("src", "bye", "init"));
 }
 
 TEST_F(SpecialCaseListTest, Substring) {
-  std::unique_ptr<SpecialCaseList> SCL(makeSpecialCaseList("src:hello\n"
-                                                           "fun:foo\n"
-                                                           "global:bar\n"));
+  auto SCL = makeSpecialCaseList("src:hello\n"
+                                 "global:bar\n");
   EXPECT_FALSE(SCL->inSection("src", "othello"));
   EXPECT_FALSE(SCL->inSection("fun", "tomfoolery"));
   EXPECT_FALSE(SCL->inSection("global", "bartender"));
 
-  SCL.reset(makeSpecialCaseList("fun:*foo*\n"));
+  SCL = makeSpecialCaseList("fun:*foo*\n");
   EXPECT_TRUE(SCL->inSection("fun", "tomfoolery"));
   EXPECT_TRUE(SCL->inSection("fun", "foobar"));
 }
 
 TEST_F(SpecialCaseListTest, InvalidSpecialCaseList) {
   std::string Error;
   EXPECT_EQ(nullptr, makeSpecialCaseList("badline", Error));
   EXPECT_EQ("Malformed line 1: 'badline'", Error);
   EXPECT_EQ(nullptr, makeSpecialCaseList("src:bad[a-", Error));
   EXPECT_EQ("Malformed regex in line 1: 'bad[a-': invalid character range",
             Error);
   EXPECT_EQ(nullptr, makeSpecialCaseList("src:a.c\n"
                                    "fun:fun(a\n",
                                    Error));
   EXPECT_EQ("Malformed regex in line 2: 'fun(a': parentheses not balanced",
             Error);
-  EXPECT_EQ(nullptr, SpecialCaseList::create("unexisting", Error));
+
+  SpecialCaseList SCL;
+  EXPECT_FALSE(SCL.loadFromFile("unexisting", Error));
   EXPECT_EQ(0U, Error.find("Can't open file 'unexisting':"));
 }
 
 TEST_F(SpecialCaseListTest, EmptySpecialCaseList) {
-  std::unique_ptr<SpecialCaseList> SCL(makeSpecialCaseList(""));
+  auto SCL = makeSpecialCaseList("");
   EXPECT_FALSE(SCL->inSection("foo", "bar"));
 }
 
-}
+TEST_F(SpecialCaseListTest, MultipleLists) {
+  SpecialCaseList SCL;
+  std::string Error;
+
+  EXPECT_FALSE(SCL.inSection("fun", "foo"));
+  EXPECT_FALSE(SCL.inSection("fun", "bar"));
 
+  ASSERT_TRUE(loadFromStr(&SCL, "fun:foo\n", Error));
 
+  EXPECT_TRUE(SCL.inSection("fun", "foo"));
+  EXPECT_FALSE(SCL.inSection("fun", "bar"));
+
+  ASSERT_TRUE(loadFromStr(&SCL, "fun:bar*\n", Error));
+
+  EXPECT_TRUE(SCL.inSection("fun", "foo"));
+  EXPECT_TRUE(SCL.inSection("fun", "bar"));
+  EXPECT_TRUE(SCL.inSection("fun", "bartender"));
+  EXPECT_FALSE(SCL.inSection("fun", "foobar"));
+  EXPECT_FALSE(SCL.inSection("fun", "baz"));
+
+  ASSERT_TRUE(loadFromStr(&SCL, "fun:baz\n", Error));
+
+  EXPECT_TRUE(SCL.inSection("fun", "foo"));
+  EXPECT_TRUE(SCL.inSection("fun", "bar"));
+  EXPECT_TRUE(SCL.inSection("fun", "bartender"));
+  EXPECT_FALSE(SCL.inSection("fun", "foobar"));
+  EXPECT_TRUE(SCL.inSection("fun", "baz"));
+}
+
+}