llvm/clang/unittests/Interpreter/InterpreterTest.cpp

//===- unittests/Interpreter/InterpreterTest.cpp --- Interpreter 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
//
//===----------------------------------------------------------------------===//
//
// Unit tests for Clang's Interpreter library.
//
//===----------------------------------------------------------------------===//

#include "InterpreterTestFixture.h"

#include "clang/AST/Decl.h"
#include "clang/AST/DeclGroup.h"
#include "clang/AST/Mangle.h"
#include "clang/Frontend/CompilerInstance.h"
#include "clang/Frontend/TextDiagnosticPrinter.h"
#include "clang/Interpreter/Interpreter.h"
#include "clang/Interpreter/Value.h"
#include "clang/Sema/Lookup.h"
#include "clang/Sema/Sema.h"

#include "gmock/gmock.h"
#include "gtest/gtest.h"

usingnamespaceclang;

int Global = …;
// JIT reports symbol not found on Windows without the visibility attribute.
REPL_EXTERNAL_VISIBILITY int getGlobal() { … }
REPL_EXTERNAL_VISIBILITY void setGlobal(int val) { … }

namespace {

class InterpreterTest : public InterpreterTestBase { … };

Args;
static std::unique_ptr<Interpreter>
createInterpreter(const Args &ExtraArgs = { … }

static size_t DeclsSize(TranslationUnitDecl *PTUDecl) { … }

TEST_F(InterpreterTest, Sanity) { … }

static std::string DeclToString(Decl *D) { … }

TEST_F(InterpreterTest, IncrementalInputTopLevelDecls) { … }

TEST_F(InterpreterTest, Errors) { … }

// Here we test whether the user can mix declarations and statements. The
// interpreter should be smart enough to recognize the declarations from the
// statements and wrap the latter into a declaration, producing valid code.

TEST_F(InterpreterTest, DeclsAndStatements) { … }

TEST_F(InterpreterTest, UndoCommand) { … }

static std::string MangleName(NamedDecl *ND) { … }

TEST_F(InterpreterTest, FindMangledNameSymbol) { … }

static Value AllocateObject(TypeDecl *TD, Interpreter &Interp) { … }

static NamedDecl *LookupSingleName(Interpreter &Interp, const char *Name) { … }

TEST_F(InterpreterTest, InstantiateTemplate) { … }

TEST_F(InterpreterTest, Value) { … }

} // end anonymous namespace