Install notion of diagnostic handler into PNaCl bitcode readers.

unittests/Bitcode/NaClBitReaderTest.cpp

 //===- llvm/unittest/Bitcode/NaClBitReaderTest.cpp - Tests for BitReader --===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
+#include "NaClMungeTest.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Bitcode/BitstreamWriter.h"
 #include "llvm/Bitcode/NaCl/NaClReaderWriter.h"
 #include "llvm/IR/Constants.h"
+#include "llvm/IR/DiagnosticPrinter.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/Verifier.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "gtest/gtest.h"
 
-namespace llvm {
+using namespace llvm;
+
 namespace {
 
 static std::unique_ptr<Module> makeLLVMModule() {
   std::unique_ptr<Module> Mod(new Module("test-mem", getGlobalContext()));
 
   FunctionType* FuncTy =
     FunctionType::get(Type::getVoidTy(Mod->getContext()), false);
   Function* Func = Function::Create(FuncTy,GlobalValue::ExternalLinkage,
                                     "func", Mod.get());
 
   BasicBlock* Entry = BasicBlock::Create(Mod->getContext(), "entry", Func);
   new UnreachableInst(Mod->getContext(), Entry);
 
   BasicBlock* BB = BasicBlock::Create(Mod->getContext(), "bb", Func);
   new UnreachableInst(Mod->getContext(), BB);
 
   return Mod;
 }
 
 static void writeModuleToBuffer(SmallVectorImpl<char> &Buffer) {
   std::unique_ptr<Module> Mod = makeLLVMModule();
   raw_svector_ostream OS(Buffer);
   NaClWriteBitcodeToFile(Mod.get(), OS);
 }
 
 // Check that we can parse a good bitcode file.
 TEST(NaClBitReaderTest, MaterializeSimpleModule) {
   SmallString<1024> Mem;
   writeModuleToBuffer(Mem);
-  std::unique_ptr<MemoryBuffer> Buffer = MemoryBuffer::getMemBuffer(Mem.str(), "test", false);
+  std::unique_ptr<MemoryBuffer> Buffer =
+      MemoryBuffer::getMemBuffer(Mem.str(), "test", false);
   ErrorOr<Module *> ModuleOrErr =
       getNaClLazyBitcodeModule(std::move(Buffer), getGlobalContext());
   EXPECT_EQ(true, bool(ModuleOrErr));
   // Do something with the module just to make sure it was built.
   std::unique_ptr<Module> M(ModuleOrErr.get());
   EXPECT_NE((Module *)nullptr, M.get());
   M->getFunction("func")->materialize();
   EXPECT_FALSE(verifyModule(*M, &dbgs()));
 }
 
 // Test that we catch bad stuff at the end of a bitcode file.
 TEST(NaClBitReaderTest, BadDataAfterModule) {
   SmallString<1024> Mem;
   writeModuleToBuffer(Mem);
   Mem.append("more"); // Length must be divisible by 4!
-  std::unique_ptr<MemoryBuffer> Buffer = MemoryBuffer::getMemBuffer(Mem.str(), "test", false);
+  std::unique_ptr<MemoryBuffer> Buffer =
+      MemoryBuffer::getMemBuffer(Mem.str(), "test", false);
+  std::string OutputBuffer;
+  raw_string_ostream OutputStream(OutputBuffer);
   ErrorOr<Module *> ModuleOrErr =
-      getNaClLazyBitcodeModule(std::move(Buffer), getGlobalContext());
+      getNaClLazyBitcodeModule(std::move(Buffer), getGlobalContext(),
+                               redirectNaClDiagnosticToStream(OutputStream));
   EXPECT_EQ(false, bool(ModuleOrErr));
-  std::string BadMessage("Invalid data after module");
-  EXPECT_EQ(BadMessage, ModuleOrErr.getError().message());
-}
-
+  std::string BadMessage("Invalid data after module\n");
+  EXPECT_EQ(BadMessage, naclmungetest::stripErrorPrefix(OutputStream.str()));
 }
 }