#include "simplecpp.h"

#include <cctype>

#include <cstdint>

#include <cstdlib>

#include <cstring>

#include <exception>

#include <iostream>

#include <list>

#include <sstream>

#include <stdexcept>

#include <string>

#include <utility>

#include <vector>

#ifdef __cpp_lib_string_view

#include <string_view>

#endif

#ifndef SIMPLECPP_TEST_SOURCE_DIR

#error "SIMPLECPP_TEST_SOURCE_DIR is not defined."

#endif

#define STRINGIZE_(x) #x

#define STRINGIZE(x) STRINGIZE_(x)

static const std::string testSourceDir = SIMPLECPP_TEST_SOURCE_DIR;

namespace {

enum class Input : std::uint8_t {

Stringstream,

CharBuffer

};

}

static Input USE_INPUT = Input::Stringstream;

static int numberOfFailedAssertions = 0;

#define ASSERT_EQUALS(expected, actual) (assertEquals((expected), (actual), __LINE__))

#define ASSERT_THROW_EQUALS(stmt, e, expected) do { try { stmt; assertThrowFailed(__LINE__); } catch (const e& ex) { assertEquals((expected), (ex.what()), __LINE__); } } while (false)

static std::string pprint(const std::string &in)

}

static const char* inputString(Input input) {

switch (input) {

case Input::Stringstream:

return "Stringstream";

case Input::CharBuffer:

return "CharBuffer";

}

return ""; // unreachable - needed for GCC and Visual Studio

}

static int assertEquals(const std::string &expected, const std::string &actual, int line)

}

static int assertEquals(const long long &expected, const long long &actual, int line)

{

return assertEquals(std::to_string(expected), std::to_string(actual), line);

}

static void assertThrowFailed(int line)

}

static void testcase(const std::string &name, void (*f)(), int argc, char * const *argv)

}

#define TEST_CASE(F) (testcase(#F, F, argc, argv))

static simplecpp::TokenList makeTokenList(const char code[], std::size_t size, std::vector<std::string> &filenames, const std::string &filename=std::string(), const simplecpp::DUI &dui = {}, simplecpp::OutputList *outputList = nullptr)

}

static simplecpp::TokenList makeTokenList(const char code[], std::vector<std::string> &filenames, const std::string &filename=std::string(), const simplecpp::DUI &dui = {}, simplecpp::OutputList *outputList=nullptr)

{

return makeTokenList(code, strlen(code), filenames, filename, dui, outputList);

}

static simplecpp::TokenList makeTokenList(const char code[], const simplecpp::DUI &dui = {}, simplecpp::OutputList *outputList=nullptr)

}

static std::string readfile(const char code[], const simplecpp::DUI &dui = {}, simplecpp::OutputList *outputList = nullptr)

}

static std::string readfile(const char code[], std::size_t size, const simplecpp::DUI &dui = {}, simplecpp::OutputList *outputList=nullptr)

}

static std::string preprocess(const char code[], std::size_t size, const simplecpp::DUI &dui, simplecpp::OutputList *outputList, std::list<simplecpp::MacroUsage> *macroUsage = nullptr, std::list<simplecpp::IfCond> *ifCond = nullptr, const std::string &file = std::string())

}

static std::string preprocess(const char code[], const simplecpp::DUI &dui, simplecpp::OutputList *outputList, std::list<simplecpp::MacroUsage> *macroUsage = nullptr, std::list<simplecpp::IfCond> *ifCond = nullptr, const std::string &file = std::string())

{

return preprocess(code, strlen(code), dui, outputList, macroUsage, ifCond, file);

}

static std::string preprocess(const char code[])

{

return preprocess(code, simplecpp::DUI(), nullptr);

}

static std::string preprocess(const char code[], const std::string &file)

{

return preprocess(code, simplecpp::DUI(), nullptr, nullptr, nullptr, file);

}

static std::string preprocess(const char code[], const simplecpp::DUI &dui)

{

return preprocess(code, dui, nullptr);

}

static std::string preprocess(const char code[], simplecpp::OutputList *outputList)

{

return preprocess(code, simplecpp::DUI(), outputList);

}

static std::string preprocess(const char code[], std::size_t size, simplecpp::OutputList *outputList)

{

return preprocess(code, size, simplecpp::DUI(), outputList);

}

static std::string preprocess(const char code[], std::list<simplecpp::IfCond> *ifCond)

{

return preprocess(code, simplecpp::DUI(), nullptr, nullptr, ifCond);

}

static std::string preprocess(const char code[], std::list<simplecpp::MacroUsage> *macroUsage)

{

return preprocess(code, simplecpp::DUI(), nullptr, macroUsage);

}

static std::string toString(const simplecpp::OutputList &outputList)

}

static void backslash()

}

static void builtin()

}

static std::string testConstFold(const char code[])

}

static void characterLiteral()

}

static void combineOperators_floatliteral()

}

static void combineOperators_increment()

}

static void combineOperators_coloncolon()

{

ASSERT_EQUALS("x ? y : :: z", preprocess("x ? y : ::z"));

}

static void combineOperators_andequal()

}

static void combineOperators_ellipsis()

}

static void comment()

}

static void comment_multiline()

}

static void keep_comments()

}

static void constFold()

}

#ifdef __CYGWIN__

static void convertCygwinPath()

}

#endif

static void define1()

}

static void define2()

}

static void define3()

}

static void define4()

}

static void define5()

}

static void define6()

}

static void define7()

}

static void define8() // 6.10.3.10

}

static void define9()

}

static void define10() // don't combine prefix with space in macro

}

static void define11() // location of expanded argument

}

static void define12()

}

static void define13()

}

static void define14() // #296

}

static void define15() // #231

}

static void define16() // #201

}

static void define17() // #185

}

static void define18() // #130

}

static void define19() // #124

}

static void define20() // #113

}

static void define21() // #66

}

static void define22() // #40

}

static void define23() // #40

}

static void define24()

}

static void define25()