forked from OSchip/llvm-project
96 lines
3.8 KiB
C++
96 lines
3.8 KiB
C++
//===- unittests/Frontend/CompilerInstanceTest.cpp - CI tests -------------===//
|
|
//
|
|
// 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/Frontend/CompilerInstance.h"
|
|
#include "clang/Basic/FileManager.h"
|
|
#include "clang/Frontend/CompilerInvocation.h"
|
|
#include "clang/Frontend/TextDiagnosticPrinter.h"
|
|
#include "llvm/Support/FileSystem.h"
|
|
#include "llvm/Support/Format.h"
|
|
#include "llvm/Support/ToolOutputFile.h"
|
|
#include "gtest/gtest.h"
|
|
|
|
using namespace llvm;
|
|
using namespace clang;
|
|
|
|
namespace {
|
|
|
|
TEST(CompilerInstance, DefaultVFSOverlayFromInvocation) {
|
|
// Create a temporary VFS overlay yaml file.
|
|
int FD;
|
|
SmallString<256> FileName;
|
|
ASSERT_FALSE(sys::fs::createTemporaryFile("vfs", "yaml", FD, FileName));
|
|
ToolOutputFile File(FileName, FD);
|
|
|
|
SmallString<256> CurrentPath;
|
|
sys::fs::current_path(CurrentPath);
|
|
sys::fs::make_absolute(CurrentPath, FileName);
|
|
|
|
// Mount the VFS file itself on the path 'virtual.file'. Makes this test
|
|
// a bit shorter than creating a new dummy file just for this purpose.
|
|
const std::string CurrentPathStr = std::string(CurrentPath.str());
|
|
const std::string FileNameStr = std::string(FileName.str());
|
|
const char *VFSYaml = "{ 'version': 0, 'roots': [\n"
|
|
" { 'name': '%s',\n"
|
|
" 'type': 'directory',\n"
|
|
" 'contents': [\n"
|
|
" { 'name': 'vfs-virtual.file', 'type': 'file',\n"
|
|
" 'external-contents': '%s'\n"
|
|
" }\n"
|
|
" ]\n"
|
|
" }\n"
|
|
"]}\n";
|
|
File.os() << format(VFSYaml, CurrentPathStr.c_str(), FileName.c_str());
|
|
File.os().flush();
|
|
|
|
// Create a CompilerInvocation that uses this overlay file.
|
|
const std::string VFSArg = "-ivfsoverlay" + FileNameStr;
|
|
const char *Args[] = {"clang", VFSArg.c_str(), "-xc++", "-"};
|
|
|
|
IntrusiveRefCntPtr<DiagnosticsEngine> Diags =
|
|
CompilerInstance::createDiagnostics(new DiagnosticOptions());
|
|
|
|
std::shared_ptr<CompilerInvocation> CInvok =
|
|
createInvocationFromCommandLine(Args, Diags);
|
|
|
|
if (!CInvok)
|
|
FAIL() << "could not create compiler invocation";
|
|
// Create a minimal CompilerInstance which should use the VFS we specified
|
|
// in the CompilerInvocation (as we don't explicitly set our own).
|
|
CompilerInstance Instance;
|
|
Instance.setDiagnostics(Diags.get());
|
|
Instance.setInvocation(CInvok);
|
|
Instance.createFileManager();
|
|
|
|
// Check if the virtual file exists which means that our VFS is used by the
|
|
// CompilerInstance.
|
|
ASSERT_TRUE(Instance.getFileManager().getFile("vfs-virtual.file"));
|
|
}
|
|
|
|
TEST(CompilerInstance, AllowDiagnosticLogWithUnownedDiagnosticConsumer) {
|
|
auto DiagOpts = new DiagnosticOptions();
|
|
// Tell the diagnostics engine to emit the diagnostic log to STDERR. This
|
|
// ensures that a chained diagnostic consumer is created so that the test can
|
|
// exercise the unowned diagnostic consumer in a chained consumer.
|
|
DiagOpts->DiagnosticLogFile = "-";
|
|
|
|
// Create the diagnostic engine with unowned consumer.
|
|
std::string DiagnosticOutput;
|
|
llvm::raw_string_ostream DiagnosticsOS(DiagnosticOutput);
|
|
auto DiagPrinter = std::make_unique<TextDiagnosticPrinter>(
|
|
DiagnosticsOS, new DiagnosticOptions());
|
|
CompilerInstance Instance;
|
|
IntrusiveRefCntPtr<DiagnosticsEngine> Diags = Instance.createDiagnostics(
|
|
DiagOpts, DiagPrinter.get(), /*ShouldOwnClient=*/false);
|
|
|
|
Diags->Report(diag::err_expected) << "no crash";
|
|
ASSERT_EQ(DiagnosticsOS.str(), "error: expected no crash\n");
|
|
}
|
|
|
|
} // anonymous namespace
|