#include "simplecpp.h"

#include <algorithm>

#include <cctype>

#include <cstdint>

#include <cstdlib>

#include <cstring>

#include <cstdio>

#include <exception>

#include <fstream>

#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)

#define TODO_ASSERT_EQUALS(wanted, current, actual) (todoAssertEquals((wanted), (current), (actual), __LINE__))

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

{

std::string ret;

for (std::string::size_type i = 0; i < in.size(); ++i) {

if (in[i] == '\n')

ret += "\\n";

ret += in[i];

}

return ret;

}

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)

{

if (expected != actual) {

numberOfFailedAssertions++;

std::cerr << "------ assertion failed (" << inputString(USE_INPUT) << ")---------" << std::endl;

std::cerr << "line test.cpp:" << line << std::endl;

std::cerr << "expected:" << pprint(expected) << std::endl;

std::cerr << "actual:" << pprint(actual) << std::endl;

}

return (expected == actual);

}

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 todoAssertEquals(const std::string &wanted, const std::string &current, const std::string &actual, int line)

{

if (wanted == actual) {

numberOfFailedAssertions++;

std::cerr << "------ TODO assertion fixed (" << inputString(USE_INPUT) << ")---------" << std::endl;

std::cerr << "line test.cpp:" << line << std::endl;

std::cerr << "change TODO_ASSERT_EQUALS to ASSERT_EQUALS" << std::endl;

return;

}

assertEquals(current, actual, line);

}

static void assertThrowFailed(int line)

{

numberOfFailedAssertions++;

std::cerr << "------ assertion failed ---------" << std::endl;

std::cerr << "line " << line << std::endl;

std::cerr << "exception not thrown" << std::endl;

}

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

{

if (argc == 1) {

f();

}

else {

for (int i = 1; i < argc; i++) {

if (name == argv[i])

f();

}

}

}

#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)

{

switch (USE_INPUT) {

case Input::Stringstream: {

std::istringstream istr(std::string(code, size));

return {istr,filenames,filename,dui,outputList};

}

case Input::CharBuffer:

return {{code, size}, filenames, filename, dui, outputList};

}

return simplecpp::TokenList{filenames}; // unreachable - needed for GCC and Visual Studio

}

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)

{

std::vector<std::string> files;

return makeTokenList(code, strlen(code), files, std::string(), dui, outputList);

}

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

{

std::vector<std::string> files;

return makeTokenList(code,files,std::string(),dui,outputList).stringify();

}

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

{

std::vector<std::string> files;

return makeTokenList(code,size,files,std::string(),dui,outputList).stringify();

}

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

{

const std::string filename = "testrunner_filestream.tmp";

{

std::ofstream f(filename, std::ios::binary);

f.write(code, static_cast<std::streamsize>(size));

}

std::vector<std::string> files;

std::string ret = simplecpp::TokenList(filename, files, {}, outputList).stringify();

std::remove(filename.c_str());

return ret;

}

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())

{

std::vector<std::string> files;

simplecpp::FileDataCache cache;

simplecpp::TokenList tokens = makeTokenList(code, size, files, file, dui, outputList);

if (dui.removeComments)

tokens.removeComments();

simplecpp::TokenList tokens2(files);

simplecpp::preprocess(tokens2, tokens, files, cache, dui, outputList, macroUsage, ifCond);

simplecpp::cleanup(cache);

return tokens2.stringify();

}

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)

{

std::ostringstream ostr;

for (const simplecpp::Output &output : outputList) {

ostr << "file" << output.location.fileIndex << ',' << output.location.line << ',';

switch (output.type) {

case simplecpp::Output::Type::ERROR:

ostr << "#error,";

break;

case simplecpp::Output::Type::WARNING:

ostr << "#warning,";

break;

case simplecpp::Output::Type::MISSING_HEADER:

ostr << "missing_header,";

break;

case simplecpp::Output::Type::INCLUDE_NESTED_TOO_DEEPLY:

ostr << "include_nested_too_deeply,";

break;

case simplecpp::Output::Type::SYNTAX_ERROR:

ostr << "syntax_error,";

break;

case simplecpp::Output::DIRECTIVE_AS_MACRO_PARAMETER:

ostr << "directive_as_macro_parameter,";

break;

case simplecpp::Output::Type::PORTABILITY_BACKSLASH:

ostr << "portability_backslash,";

break;

case simplecpp::Output::Type::PORTABILITY_LINE_DIRECTIVE:

ostr << "portability_line_directive,";

break;

case simplecpp::Output::Type::PORTABILITY_NO_EOF_NEWLINE:

ostr << "portability_no_eof_newline,";

break;

case simplecpp::Output::Type::PORTABILITY_STRINGIFY:

ostr << "portability_stringify,";

break;

case simplecpp::Output::Type::UNHANDLED_CHAR_ERROR:

ostr << "unhandled_char_error,";

break;

case simplecpp::Output::Type::EXPLICIT_INCLUDE_NOT_FOUND:

ostr << "explicit_include_not_found,";

break;

case simplecpp::Output::Type::FILE_NOT_FOUND:

ostr << "file_not_found,";

break;

case simplecpp::Output::Type::DUI_ERROR:

ostr << "dui_error,";

break;

}

ostr << output.msg << '\n';

}

return ostr.str();

}

static std::string expandedTokens(const char code[], const simplecpp::DUI &dui = simplecpp::DUI(), std::list<simplecpp::MacroUsage> *macroUsage = nullptr)

{

std::vector<std::string> files;

simplecpp::FileDataCache cache;

simplecpp::TokenList tokens(files);

const simplecpp::TokenList rawtokens = makeTokenList(code, files);

simplecpp::preprocess(tokens, rawtokens, files, cache, dui, nullptr, macroUsage);

std::string ret;

for (const simplecpp::Token *tok = tokens.cfront(); tok; tok = tok->next) {

if (!ret.empty())

ret += ' ';

ret += tok->str();

if (!tok->macro.empty())

ret += '@' + tok->macro;

ret += '(' + std::to_string(tok->location.line) + ':' + std::to_string(tok->location.col) + ')';

}

return ret;

}

static std::string toString(const std::list<simplecpp::MacroUsage> &macroUsage)

{

std::vector<std::string> lines;

for (const simplecpp::MacroUsage &mu : macroUsage) {

std::string line = mu.macroName + ' ' + std::to_string(mu.macroLocation.line) + ':' + std::to_string(mu.macroLocation.col) +

" use " + std::to_string(mu.useLocation.line) + ':' + std::to_string(mu.useLocation.col);

if (!mu.macroValueKnown)

line += " unknown";

lines.push_back(line + '\n');

}

std::sort(lines.begin(), lines.end());

std::string ret;

for (const std::string &line : lines)

ret += line;

return ret;

}

static void backslash()

{

// <backslash><space><newline> preprocessed differently

simplecpp::OutputList outputList;

readfile("//123 \\\n456\n", {}, &outputList);

ASSERT_EQUALS("", toString(outputList));

readfile("//123 \\ \n456\n", {}, &outputList);

ASSERT_EQUALS("file0,1,portability_backslash,Combination 'backslash space newline' is not portable.\n", toString(outputList));

outputList.clear();

readfile("#define A \\\n123\n", {}, &outputList);

ASSERT_EQUALS("", toString(outputList));

readfile("#define A \\ \n123\n", {}, &outputList);

ASSERT_EQUALS("file0,1,portability_backslash,Combination 'backslash space newline' is not portable.\n", toString(outputList));

}

static void builtin()

{

ASSERT_EQUALS("\"test.c\" 1 0", preprocess("__FILE__ __LINE__ __COUNTER__", "test.c"));

ASSERT_EQUALS("\n\n3", preprocess("\n\n__LINE__"));

ASSERT_EQUALS("\n\n0", preprocess("\n\n__COUNTER__"));

ASSERT_EQUALS("\n\n0 1", preprocess("\n\n__COUNTER__ __COUNTER__"));

ASSERT_EQUALS("\n0 + 0", preprocess("#define A(c) c+c\n"

"A(__COUNTER__)\n"));

ASSERT_EQUALS("\n0 + 0 + 1", preprocess("#define A(c) c+c+__COUNTER__\n"

"A(__COUNTER__)\n"));

}

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

{

try {

std::vector<std::string> files;

simplecpp::TokenList expr = makeTokenList(code, files);

expr.constFold();

return expr.stringify();

} catch (std::exception &) {

return "exception";

}

}

static void characterLiteral()

{

ASSERT_EQUALS('A', simplecpp::characterLiteralToLL("'A'"));

ASSERT_EQUALS('\'', simplecpp::characterLiteralToLL("'\\''"));

ASSERT_EQUALS('\"', simplecpp::characterLiteralToLL("'\\\"'"));

ASSERT_EQUALS('\?', simplecpp::characterLiteralToLL("'\\?'"));

ASSERT_EQUALS('\\', simplecpp::characterLiteralToLL("'\\\\'"));

ASSERT_EQUALS('\a', simplecpp::characterLiteralToLL("'\\a'"));

ASSERT_EQUALS('\b', simplecpp::characterLiteralToLL("'\\b'"));

ASSERT_EQUALS('\f', simplecpp::characterLiteralToLL("'\\f'"));

ASSERT_EQUALS('\n', simplecpp::characterLiteralToLL("'\\n'"));

ASSERT_EQUALS('\r', simplecpp::characterLiteralToLL("'\\r'"));

ASSERT_EQUALS('\t', simplecpp::characterLiteralToLL("'\\t'"));

ASSERT_EQUALS('\v', simplecpp::characterLiteralToLL("'\\v'"));

// GCC extension for ESC character

ASSERT_EQUALS(0x1b, simplecpp::characterLiteralToLL("'\\e'"));

ASSERT_EQUALS(0x1b, simplecpp::characterLiteralToLL("'\\E'"));

// more obscure GCC extensions

ASSERT_EQUALS('(', simplecpp::characterLiteralToLL("'\\('"));

ASSERT_EQUALS('[', simplecpp::characterLiteralToLL("'\\['"));

ASSERT_EQUALS('{', simplecpp::characterLiteralToLL("'\\{'"));

ASSERT_EQUALS('%', simplecpp::characterLiteralToLL("'\\%'"));

ASSERT_EQUALS('\0', simplecpp::characterLiteralToLL("'\\0'"));

ASSERT_EQUALS('\1', simplecpp::characterLiteralToLL("'\\1'"));

ASSERT_EQUALS('\10', simplecpp::characterLiteralToLL("'\\10'"));

ASSERT_EQUALS('\010', simplecpp::characterLiteralToLL("'\\010'"));

ASSERT_EQUALS('\377', simplecpp::characterLiteralToLL("'\\377'"));

ASSERT_EQUALS('\x0', simplecpp::characterLiteralToLL("'\\x0'"));

ASSERT_EQUALS('\x10', simplecpp::characterLiteralToLL("'\\x10'"));

ASSERT_EQUALS('\xff', simplecpp::characterLiteralToLL("'\\xff'"));

ASSERT_EQUALS('\u0012', simplecpp::characterLiteralToLL("'\\u0012'"));

ASSERT_EQUALS('\U00000012', simplecpp::characterLiteralToLL("'\\U00000012'"));

ASSERT_EQUALS((static_cast<unsigned int>(static_cast<unsigned char>('b')) << 8) | static_cast<unsigned char>('c'), simplecpp::characterLiteralToLL("'bc'"));

ASSERT_EQUALS((static_cast<unsigned int>(static_cast<unsigned char>('\x23')) << 8) | static_cast<unsigned char>('\x45'), simplecpp::characterLiteralToLL("'\\x23\\x45'"));

ASSERT_EQUALS((static_cast<unsigned int>(static_cast<unsigned char>('\11')) << 8) | static_cast<unsigned char>('\222'), simplecpp::characterLiteralToLL("'\\11\\222'"));

ASSERT_EQUALS((static_cast<unsigned int>(static_cast<unsigned char>('\a')) << 8) | static_cast<unsigned char>('\b'), simplecpp::characterLiteralToLL("'\\a\\b'"));

if (sizeof(int) <= 4)

ASSERT_EQUALS(-1, simplecpp::characterLiteralToLL("'\\xff\\xff\\xff\\xff'"));

else

ASSERT_EQUALS(0xffffffff, simplecpp::characterLiteralToLL("'\\xff\\xff\\xff\\xff'"));

ASSERT_EQUALS('A', simplecpp::characterLiteralToLL("u8'A'"));

ASSERT_EQUALS('A', simplecpp::characterLiteralToLL("u'A'"));

ASSERT_EQUALS('A', simplecpp::characterLiteralToLL("L'A'"));

ASSERT_EQUALS('A', simplecpp::characterLiteralToLL("U'A'"));

ASSERT_EQUALS(0xff, simplecpp::characterLiteralToLL("u8'\\xff'"));

ASSERT_EQUALS(0xff, simplecpp::characterLiteralToLL("u'\\xff'"));

ASSERT_EQUALS(0xff, simplecpp::characterLiteralToLL("L'\\xff'"));

ASSERT_EQUALS(0xff, simplecpp::characterLiteralToLL("U'\\xff'"));

ASSERT_EQUALS(0xfedc, simplecpp::characterLiteralToLL("u'\\xfedc'"));

ASSERT_EQUALS(0xfedcba98, simplecpp::characterLiteralToLL("L'\\xfedcba98'"));

ASSERT_EQUALS(0xfedcba98, simplecpp::characterLiteralToLL("U'\\xfedcba98'"));

ASSERT_EQUALS(0x12, simplecpp::characterLiteralToLL("u8'\\u0012'"));

ASSERT_EQUALS(0x1234, simplecpp::characterLiteralToLL("u'\\u1234'"));

ASSERT_EQUALS(0x00012345, simplecpp::characterLiteralToLL("L'\\U00012345'"));

ASSERT_EQUALS(0x00012345, simplecpp::characterLiteralToLL("U'\\U00012345'"));

#ifdef __GNUC__

// BEGIN Implementation-specific results

ASSERT_EQUALS('AB', simplecpp::characterLiteralToLL("'AB'"));

ASSERT_EQUALS('ABC', simplecpp::characterLiteralToLL("'ABC'"));

ASSERT_EQUALS('ABCD', simplecpp::characterLiteralToLL("'ABCD'"));

ASSERT_EQUALS('\134t', simplecpp::characterLiteralToLL("'\\134t'")); // cppcheck ticket #7452

// END Implementation-specific results

#endif

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("'\\9'"), std::runtime_error, "invalid escape sequence");

// Input is manually encoded to (escaped) UTF-8 byte sequences

// to avoid dependence on source encoding used for this file

ASSERT_EQUALS(0xb5, simplecpp::characterLiteralToLL("U'\302\265'"));

ASSERT_EQUALS(0x157, simplecpp::characterLiteralToLL("U'\305\227'"));

ASSERT_EQUALS(0xff0f, simplecpp::characterLiteralToLL("U'\357\274\217'"));

ASSERT_EQUALS(0x3042, simplecpp::characterLiteralToLL("U'\343\201\202'"));

ASSERT_EQUALS(0x13000, simplecpp::characterLiteralToLL("U'\360\223\200\200'"));

ASSERT_EQUALS(0xb5, simplecpp::characterLiteralToLL("L'\302\265'"));

ASSERT_EQUALS(0x157, simplecpp::characterLiteralToLL("L'\305\227'"));

ASSERT_EQUALS(0xff0f, simplecpp::characterLiteralToLL("L'\357\274\217'"));

ASSERT_EQUALS(0x3042, simplecpp::characterLiteralToLL("L'\343\201\202'"));

ASSERT_EQUALS(0x13000, simplecpp::characterLiteralToLL("L'\360\223\200\200'"));

ASSERT_EQUALS(0xb5, simplecpp::characterLiteralToLL("u'\302\265'"));

ASSERT_EQUALS(0x157, simplecpp::characterLiteralToLL("u'\305\227'"));

ASSERT_EQUALS(0xff0f, simplecpp::characterLiteralToLL("u'\357\274\217'"));

ASSERT_EQUALS(0x3042, simplecpp::characterLiteralToLL("u'\343\201\202'"));

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("u'\360\223\200\200'"), std::runtime_error, "code point too large");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("u8'\302\265'"), std::runtime_error, "code point too large");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("u8'\305\227'"), std::runtime_error, "code point too large");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("u8'\357\274\217'"), std::runtime_error, "code point too large");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("u8'\343\201\202'"), std::runtime_error, "code point too large");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("u8'\360\223\200\200'"), std::runtime_error, "code point too large");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("'\\U11111111"), std::runtime_error, "code point too large");

ASSERT_EQUALS('\x89', simplecpp::characterLiteralToLL("'\x89'"));

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("U'\x89'"), std::runtime_error, "assumed UTF-8 encoded source, but sequence is invalid");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("U'\xf4\x90\x80\x80'"), std::runtime_error, "code point too large");

// following examples based on https://www.cl.cam.ac.uk/~mgk25/ucs/examples/UTF-8-test.txt

ASSERT_EQUALS(0x80, simplecpp::characterLiteralToLL("U'\xc2\x80'"));

ASSERT_EQUALS(0x800, simplecpp::characterLiteralToLL("U'\xe0\xa0\x80'"));

ASSERT_EQUALS(0x10000, simplecpp::characterLiteralToLL("U'\xf0\x90\x80\x80'"));

ASSERT_EQUALS(0x7f, simplecpp::characterLiteralToLL("U'\x7f'"));

ASSERT_EQUALS(0x7ff, simplecpp::characterLiteralToLL("U'\xdf\xbf'"));

ASSERT_EQUALS(0xffff, simplecpp::characterLiteralToLL("U'\xef\xbf\xbf'"));

ASSERT_EQUALS(0xd7ff, simplecpp::characterLiteralToLL("U'\xed\x9f\xbf'"));

ASSERT_EQUALS(0xe000, simplecpp::characterLiteralToLL("U'\xee\x80\x80'"));

ASSERT_EQUALS(0xfffd, simplecpp::characterLiteralToLL("U'\xef\xbf\xbd'"));

ASSERT_EQUALS(0x10ffff, simplecpp::characterLiteralToLL("U'\xf4\x8f\xbf\xbf'"));

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("U'\x80'"), std::runtime_error, "assumed UTF-8 encoded source, but sequence is invalid");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("U'\x80\x8f'"), std::runtime_error, "assumed UTF-8 encoded source, but sequence is invalid");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("U'\x80\x8f\x8f'"), std::runtime_error, "assumed UTF-8 encoded source, but sequence is invalid");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("U'\x80\x8f\x8f\x8f'"), std::runtime_error, "assumed UTF-8 encoded source, but sequence is invalid");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("U'\xbf'"), std::runtime_error, "assumed UTF-8 encoded source, but sequence is invalid");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("U'\xbf\x8f'"), std::runtime_error, "assumed UTF-8 encoded source, but sequence is invalid");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("U'\xbf\x8f\x8f'"), std::runtime_error, "assumed UTF-8 encoded source, but sequence is invalid");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("U'\xbf\x8f\x8f\x8f'"), std::runtime_error, "assumed UTF-8 encoded source, but sequence is invalid");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("U'\xc0'"), std::runtime_error, "assumed UTF-8 encoded source, but sequence is invalid");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("U'\xc0 '"), std::runtime_error, "assumed UTF-8 encoded source, but sequence is invalid");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("U'\xe0\x8f'"), std::runtime_error, "assumed UTF-8 encoded source, but sequence is invalid");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("U'\xe0\x8f '"), std::runtime_error, "assumed UTF-8 encoded source, but sequence is invalid");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("U'\xf0\x8f\x8f'"), std::runtime_error, "assumed UTF-8 encoded source, but sequence is invalid");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("U'\xf0\x8f\x8f '"), std::runtime_error, "assumed UTF-8 encoded source, but sequence is invalid");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("U'\xf8'"), std::runtime_error, "assumed UTF-8 encoded source, but sequence is invalid");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("U'\xff'"), std::runtime_error, "assumed UTF-8 encoded source, but sequence is invalid");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("U'\xc0\xaf'"), std::runtime_error, "assumed UTF-8 encoded source, but sequence is invalid");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("U'\xe0\x80\xaf'"), std::runtime_error, "assumed UTF-8 encoded source, but sequence is invalid");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("U'\xf0\x80\x80\xaf'"), std::runtime_error, "assumed UTF-8 encoded source, but sequence is invalid");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("U'\xc1\xbf'"), std::runtime_error, "assumed UTF-8 encoded source, but sequence is invalid");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("U'\xe0\x9f\xbf'"), std::runtime_error, "assumed UTF-8 encoded source, but sequence is invalid");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("U'\xf0\x8f\xbf\xbf'"), std::runtime_error, "assumed UTF-8 encoded source, but sequence is invalid");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("U'\xc0\x80'"), std::runtime_error, "assumed UTF-8 encoded source, but sequence is invalid");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("U'\xe0\x80\x80'"), std::runtime_error, "assumed UTF-8 encoded source, but sequence is invalid");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("U'\xf0\x80\x80\x80'"), std::runtime_error, "assumed UTF-8 encoded source, but sequence is invalid");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("U'\xed\xa0\x80'"), std::runtime_error, "assumed UTF-8 encoded source, but sequence is invalid");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("U'\xed\xbf\xbf'"), std::runtime_error, "assumed UTF-8 encoded source, but sequence is invalid");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL(""), std::runtime_error, "expected a character literal");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("LU"), std::runtime_error, "expected a character literal");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL(";\n"), std::runtime_error, "expected a character literal");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("u8U"), std::runtime_error, "expected a character literal");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("'\n\n"), std::runtime_error, "raw single quotes and newlines not allowed in character literals");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("''&"), std::runtime_error, "raw single quotes and newlines not allowed in character literals");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("L'\fff"), std::runtime_error, "multiple characters only supported in narrow character literals");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("'\\\n"), std::runtime_error, "unexpected end of character literal");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("'"), std::runtime_error, "missing closing quote in character literal");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("u'"), std::runtime_error, "missing closing quote in character literal");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("L'"), std::runtime_error, "missing closing quote in character literal");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("'a"), std::runtime_error, "missing closing quote in character literal");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("''"), std::runtime_error, "empty character literal");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("L''"), std::runtime_error, "empty character literal");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("U''"), std::runtime_error, "empty character literal");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("u''"), std::runtime_error, "empty character literal");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("u8''"), std::runtime_error, "empty character literal");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("'\\555"), std::runtime_error, "numeric escape sequence too large");

ASSERT_THROW_EQUALS(simplecpp::characterLiteralToLL("u'Ó"), std::runtime_error, "assumed UTF-8 encoded source, but character literal ends unexpectedly");

}

static void combineOperators_floatliteral()

{

ASSERT_EQUALS("1.", preprocess("1."));

ASSERT_EQUALS("1.f", preprocess("1.f"));

ASSERT_EQUALS(".1", preprocess(".1"));

ASSERT_EQUALS(".1f", preprocess(".1f"));

ASSERT_EQUALS("3.1", preprocess("3.1"));

ASSERT_EQUALS("1E7", preprocess("1E7"));

ASSERT_EQUALS("1E-7", preprocess("1E-7"));

ASSERT_EQUALS("1E+7", preprocess("1E+7"));

ASSERT_EQUALS("1.e+7", preprocess("1.e+7"));

ASSERT_EQUALS("0x1E + 7", preprocess("0x1E+7"));

ASSERT_EQUALS("0x1ffp10", preprocess("0x1ffp10"));

ASSERT_EQUALS("0x0p-1", preprocess("0x0p-1"));

ASSERT_EQUALS("0x1.p0", preprocess("0x1.p0"));

ASSERT_EQUALS("0xf.p-1", preprocess("0xf.p-1"));

ASSERT_EQUALS("0x1.2p3", preprocess("0x1.2p3"));

ASSERT_EQUALS("0x1.ap3", preprocess("0x1.ap3"));

ASSERT_EQUALS("0x1.2ap3", preprocess("0x1.2ap3"));

ASSERT_EQUALS("0x1p+3", preprocess("0x1p+3"));

ASSERT_EQUALS("0x1p+3f", preprocess("0x1p+3f"));

ASSERT_EQUALS("0x1p+3L", preprocess("0x1p+3L"));

ASSERT_EQUALS("1p + 3", preprocess("1p+3"));

ASSERT_EQUALS("1.0_a . b", preprocess("1.0_a.b"));

ASSERT_EQUALS("1_a . b", preprocess("1_a.b"));

ASSERT_EQUALS("bool x = d != 0. and b ;", preprocess("bool x = d != 0. and b;"));

}

static void combineOperators_increment()

{

ASSERT_EQUALS("; ++ x ;", preprocess(";++x;"));

ASSERT_EQUALS("; x ++ ;", preprocess(";x++;"));

ASSERT_EQUALS("1 + + 2", preprocess("1++2"));

}

static void combineOperators_coloncolon()

{

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

}

static void combineOperators_andequal()

{

ASSERT_EQUALS("x &= 2 ;", preprocess("x &= 2;"));

ASSERT_EQUALS("void f ( x & = 2 ) ;", preprocess("void f(x &= 2);"));

ASSERT_EQUALS("f ( x &= 2 ) ;", preprocess("f(x &= 2);"));

ASSERT_EQUALS("f ( ) { return new int ( i &= 1 ) ; }", preprocess("f () { return new int(i &= 1); }"));

}

static void combineOperators_ellipsis()

{

ASSERT_EQUALS("void f ( int , ... ) ;", preprocess("void f(int, ...);"));

ASSERT_EQUALS("void f ( ) { switch ( x ) { case 1 ... 4 : } }", preprocess("void f() { switch(x) { case 1 ... 4: } }"));

}

static void comment()

{

simplecpp::DUI dui;

dui.removeComments = true;

ASSERT_EQUALS("// abc", readfile("// abc"));

ASSERT_EQUALS("", preprocess("// abc", dui));

ASSERT_EQUALS("/*\n\n*/abc", readfile("/*\n\n*/abc"));

ASSERT_EQUALS("\n\nabc", preprocess("/*\n\n*/abc", dui));

ASSERT_EQUALS("* p = a / * b / * c ;", readfile("*p=a/ *b/ *c;"));

ASSERT_EQUALS("* p = a / * b / * c ;", preprocess("*p=a/ *b/ *c;", dui));

}

static void comment_multiline()

{

simplecpp::DUI dui;

dui.removeComments = true;

const char code[] = "#define ABC {// \\\n"

"}\n"

"void f() ABC\n";

ASSERT_EQUALS("\n\nvoid f ( ) {", preprocess(code, dui));

const char code1[] = "#define ABC {// \\\r\n"

"}\n"

"void f() ABC\n";

ASSERT_EQUALS("\n\nvoid f ( ) {", preprocess(code1, dui));

const char code2[] = "#define A 1// \\\r"

"\r"

"2\r"

"A\r";

ASSERT_EQUALS("\n\n2\n1", preprocess(code2, dui));

const char code3[] = "void f() {// \\ \n}\n";

ASSERT_EQUALS("void f ( ) {", preprocess(code3, dui));

const char code4[] = "void f() {// \\\\\\\t\t\n}\n";

ASSERT_EQUALS("void f ( ) {", preprocess(code4, dui));

const char code5[] = "void f() {// \\\\\\a\n}\n";

ASSERT_EQUALS("void f ( ) {\n}", preprocess(code5, dui));

const char code6[] = "void f() {// \\\n\n\n}\n";

ASSERT_EQUALS("void f ( ) {\n\n\n}", preprocess(code6, dui));

// #471 ensure there is newline in comment so that line-splicing can be detected by tools

ASSERT_EQUALS("// abc\ndef", readfile("// abc\\\ndef"));

}

static void keep_comments()

{

simplecpp::DUI dui;

dui.removeComments = false;

{

const char code[] = "/* comment */\n";

ASSERT_EQUALS("/* comment */", preprocess(code,dui));

}

{

const char code[] = "// comment\n";

ASSERT_EQUALS("// comment", preprocess(code,dui));

}

{

const char code[] = "#define MACRO /* comment */\nMACRO\n";

ASSERT_EQUALS("\n/* comment */", preprocess(code,dui));

}

}

static void constFold()

{

ASSERT_EQUALS("7", testConstFold("1+2*3"));

ASSERT_EQUALS("15", testConstFold("1+2*(3+4)"));

ASSERT_EQUALS("123", testConstFold("+123"));

ASSERT_EQUALS("1", testConstFold("-123<1"));

ASSERT_EQUALS("6", testConstFold("14 & 7"));

ASSERT_EQUALS("29", testConstFold("13 ^ 16"));

ASSERT_EQUALS("25", testConstFold("24 | 1"));

ASSERT_EQUALS("2", testConstFold("1?2:3"));

ASSERT_EQUALS("24", testConstFold("010+020"));

ASSERT_EQUALS("1", testConstFold("010==8"));

ASSERT_EQUALS("exception", testConstFold("!1 ? 2 :"));

ASSERT_EQUALS("exception", testConstFold("?2:3"));

ASSERT_EQUALS("0", testConstFold("0 && 1/0"));

ASSERT_EQUALS("1", testConstFold("1 || 1/0"));

ASSERT_EQUALS("2", testConstFold("1 ? 2 : 1/0"));

ASSERT_EQUALS("exception", testConstFold("1 && 1/0"));

ASSERT_EQUALS("exception", testConstFold("1/0 && 0"));

ASSERT_EQUALS("exception", testConstFold("(1/0) ? 1 : 2"));

ASSERT_EQUALS("exception", testConstFold("-(1/0) + 1"));

// ?: is right-associative

ASSERT_EQUALS("1", testConstFold("1 ? 1 : 0 ? 2 : 3"));

ASSERT_EQUALS("3", testConstFold("0 ? 1 : 0 ? 2 : 3"));

ASSERT_EQUALS("2", testConstFold("1 ? 2 : 3 ? 4 : 5 ? 6 : 7"));

ASSERT_EQUALS("7", testConstFold("0 ? 2 : 0 ? 4 : 0 ? 6 : 7"));

ASSERT_EQUALS("6", testConstFold("1 ? 0 ? 5 : 6 : 7"));

ASSERT_EQUALS("2", testConstFold("(1 ? 1 : 0) ? 2 : 3"));

ASSERT_EQUALS("1", testConstFold("1 ? 1 : (1/0) ? 2 : 3"));

ASSERT_EQUALS("exception", testConstFold("0 ? 1 : (1/0) ? 2 : 3"));

}

#ifdef __CYGWIN__

static void convertCygwinPath()

{

// absolute paths

ASSERT_EQUALS("X:\\", simplecpp::convertCygwinToWindowsPath("/cygdrive/x")); // initial backslash

ASSERT_EQUALS("X:\\", simplecpp::convertCygwinToWindowsPath("/cygdrive/x/"));

ASSERT_EQUALS("X:\\dir", simplecpp::convertCygwinToWindowsPath("/cygdrive/x/dir"));

ASSERT_EQUALS("X:\\dir\\file", simplecpp::convertCygwinToWindowsPath("/cygdrive/x/dir/file"));

// relative paths

ASSERT_EQUALS("file", simplecpp::convertCygwinToWindowsPath("file"));

ASSERT_EQUALS("dir\\file", simplecpp::convertCygwinToWindowsPath("dir/file"));

ASSERT_EQUALS("..\\dir\\file", simplecpp::convertCygwinToWindowsPath("../dir/file"));

// incorrect Cygwin paths

ASSERT_EQUALS("\\cygdrive", simplecpp::convertCygwinToWindowsPath("/cygdrive"));

ASSERT_EQUALS("\\cygdrive\\", simplecpp::convertCygwinToWindowsPath("/cygdrive/"));

}

#endif

static void define1()

{

const char code[] = "#define A 1+2\n"

"a=A+3;";

ASSERT_EQUALS("# define A 1 + 2\n"

"a = A + 3 ;",

readfile(code));

ASSERT_EQUALS("\na = 1 + 2 + 3 ;",

preprocess(code));

}

static void define2()

{

const char code[] = "#define ADD(A,B) A+B\n"

"ADD(1+2,3);";

ASSERT_EQUALS("# define ADD ( A , B ) A + B\n"

"ADD ( 1 + 2 , 3 ) ;",

readfile(code));

ASSERT_EQUALS("\n1 + 2 + 3 ;",

preprocess(code));

}

static void define3()

{

const char code[] = "#define A 123\n"

"#define B A\n"

"A B";

ASSERT_EQUALS("# define A 123\n"

"# define B A\n"

"A B",

readfile(code));

ASSERT_EQUALS("\n\n123 123",

preprocess(code));

}

static void define4()

{

const char code[] = "#define A 123\n"

"#define B(C) A\n"

"A B(1)";

ASSERT_EQUALS("# define A 123\n"

"# define B ( C ) A\n"

"A B ( 1 )",

readfile(code));

ASSERT_EQUALS("\n\n123 123",

preprocess(code));

}

static void define5()

{

const char code[] = "#define add(x,y) x+y\n"

"add(add(1,2),3)";

ASSERT_EQUALS("\n1 + 2 + 3", preprocess(code));

}

static void define6()

{

const char code[] = "#define A() 1\n"

"A()";

ASSERT_EQUALS("\n1", preprocess(code));

}

static void define7()

{

simplecpp::DUI dui;

dui.removeComments = true;

const char code[] = "#define A(X) X+1\n"

"A(1 /*23*/)";

ASSERT_EQUALS("\n1 + 1", preprocess(code, dui));

}

static void define8() // 6.10.3.10

{

const char code[] = "#define A(X) \n"

"int A[10];";

ASSERT_EQUALS("\nint A [ 10 ] ;", preprocess(code));

}

static void define9()

{

const char code[] = "#define AB ab.AB\n"

"AB.CD\n";

ASSERT_EQUALS("\nab . AB . CD", preprocess(code));

}

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

{

const char code[] = "#define A u8 \"a b\"\n"

"A;";

ASSERT_EQUALS("\nu8 \"a b\" ;", preprocess(code));

}

static void define11() // location of expanded argument

{

const char code[] = "#line 4 \"version.h\"\n"

"#define A(x) B(x)\n"

"#define B(x) x\n"

"#define VER A(1)\n"

"\n"

"#line 10 \"cppcheck.cpp\"\n"

"VER;";

ASSERT_EQUALS("\n#line 10 \"cppcheck.cpp\"\n1 ;", preprocess(code));

}

static void define12()

{

const char code[] = "struct foo x = {\n"

" #define V 0\n"

" .x = V,\n"

"};\n";

ASSERT_EQUALS("struct foo x = {\n"

"# define V 0\n"

". x = V ,\n"

"} ;", readfile(code));

ASSERT_EQUALS("struct foo x = {\n"

"\n"

". x = 0 ,\n"

"} ;", preprocess(code));

}

static void define13()

{

const char code[] = "#define M 180.\n"

"extern void g();\n"

"void f(double d) {\n"

" if (d > M) {}\n"

"}\n";

ASSERT_EQUALS("\nextern void g ( ) ;\n"

"void f ( double d ) {\n"

"if ( d > 180. ) { }\n"

"}", preprocess(code));

}

static void define14() // #296

{

const char code[] = "#define bar(x) x % 2\n"

"#define foo(x) printf(#x \"\\n\")\n"

"\n"

" foo(bar(3));\n";

ASSERT_EQUALS("\n"

"\n"

"\n"

"printf ( \"bar(3)\" \"\\n\" ) ;", preprocess(code));

}

static void define15() // #231

{

const char code[] = "#define CAT(a, b) CAT2(a, b)\n"

"#define CAT2(a, b) a ## b\n"

"#define FOO x\n"

"#define BAR() CAT(F, OO)\n"

"#define BAZ CAT(B, AR)()\n"

"BAZ\n";

ASSERT_EQUALS("\n"

"\n"

"\n"

"\n"

"\n"

"x", preprocess(code));

}

static void define16() // #201

{

const char code[] = "#define ALL_COLORS(warm_colors) \\\n"

" X(Blue) \\\n"

" X(Green) \\\n"

" X(Purple) \\\n"

" warm_colors\n"

"\n"

"#define WARM_COLORS \\\n"

" X(Red) \\\n"

" X(Yellow) \\\n"

" X(Orange)\n"

"\n"

"#define COLOR_SET ALL_COLORS(WARM_COLORS)\n"

"\n"

"#define X(color) #color,\n"

"\n"

"COLOR_SET\n";

ASSERT_EQUALS("\n"

"\n"

"\n"

"\n"

"\n"

"\n"

"\n"

"\n"

"\n"

"\n"

"\n"

"\n"

"\n"

"\n"

"\n"

"\"Blue\" , \"Green\" , \"Purple\" , \"Red\" , \"Yellow\" , \"Orange\" ,", preprocess(code));

}

static void define17() // #185

{

const char code[] = "#define at(x, y) x##y\n"

"#define b(...) \\\n"

"aa(__VA_ARGS__, , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , \\\n"

", , , , , , , , 2)\n"

"#define aa(c, d, a, b, e, f, g, h, ab, ac, i, ad, j, k, l, m, n, o, p, ae, q, \\\n"

"r, s, t, u, v, w, x, y, z, af, ag, ah, ai, aj, ak, al, am, an, ao, \\\n"

"ap) \\\n"

"ap\n"

"#define aq(...) ar(b(__VA_ARGS__), __VA_ARGS__) static_assert(true, \" \")\n"

"#define ar(ap, ...) at(I_, ap)(__VA_ARGS__)\n"

"#define I_2(as, a)\n"

"aq(a, array);\n";

ASSERT_EQUALS("\n"

"\n"

"\n"

"\n"

"\n"

"\n"

"\n"

"\n"

"\n"

"\n"

"\n"

"static_assert ( true , \" \" ) ;", preprocess(code));

}

static void define18() // #130

{

const char code[] = "#define MAC2STR(x) x[0],x[1],x[2],x[3],x[4],x[5]\n"

"#define FT_DEBUG(fmt, args...) if(pGlobalCtx && pGlobalCtx->debug_level>=2) printf(\"FT-dbg: \"fmt, ##args)\n"

"\n"

"FT_DEBUG(\" %02x:%02x:%02x:%02x:%02x:%02x\\n\", MAC2STR(pCtx->wlan_intf_addr[i]));\n";

ASSERT_EQUALS("\n"

"\n"

"\n"

"if ( pGlobalCtx && pGlobalCtx -> debug_level >= 2 ) printf ( \"FT-dbg: \" \" %02x:%02x:%02x:%02x:%02x:%02x\\n\" , pCtx -> wlan_intf_addr [ i ] [ 0 ] , pCtx -> wlan_intf_addr [ i ] [ 1 ] , pCtx -> wlan_intf_addr [ i ] [ 2 ] , pCtx -> wlan_intf_addr [ i ] [ 3 ] , pCtx -> wlan_intf_addr [ i ] [ 4 ] , pCtx -> wlan_intf_addr [ i ] [ 5 ] ) ;", preprocess(code));

}

static void define19() // #124

{

const char code[] = "#define CONCAT(tok) tok##suffix\n"

"\n"

"CONCAT(Test);\n"

"CONCAT(const Test);\n";

ASSERT_EQUALS("\n"

"\n"

"Testsuffix ;\n"

"const Testsuffix ;", preprocess(code));

}

static void define20() // #113

{

const char code[] = "#define TARGS4 T1,T2,T3,T4\n"

"#define FOOIMPL(T__CLASS, TARGS) void foo(const T__CLASS<TARGS>& x) { }\n"

"#define FOOIMPL_4(T__CLASS) FOOIMPL(T__CLASS, TARGS4)\n"

"FOOIMPL_4(y)\n";

ASSERT_EQUALS("\n"

"\n"

"\n"

"void foo ( const y < T1 , T2 , T3 , T4 > & x ) { }", preprocess(code));

}

static void define21() // #66