#include <iostream>

#include <sstream>

#include <vector>

#include "simplecpp.h"

static int numberOfFailedAssertions = 0;

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

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

{

if (expected != actual) {

numberOfFailedAssertions++;

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

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

std::cerr << "expected:" << expected << std::endl;

std::cerr << "actual:" << actual << std::endl;

}

return (expected == actual);

}

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

{

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

}

static void testcase(const std::string &name, void (*f)(), int argc, char **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 std::string readfile(const char code[], int sz=-1, simplecpp::OutputList *outputList=nullptr)

{

std::istringstream istr(sz == -1 ? std::string(code) : std::string(code,sz));

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

return simplecpp::TokenList(istr,files,std::string(),outputList).stringify();

}

static std::string preprocess(const char code[], const simplecpp::DUI &dui, simplecpp::OutputList *outputList = NULL)

{

std::istringstream istr(code);

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

std::map<std::string, simplecpp::TokenList*> filedata;

simplecpp::TokenList tokens(istr,files);

tokens.removeComments();

simplecpp::TokenList tokens2(files);

simplecpp::preprocess(tokens2, tokens, files, filedata, dui, outputList);

return tokens2.stringify();

}

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

{

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

}

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::Type::PORTABILITY_BACKSLASH:

ostr << "portability_backslash,";

break;

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

ostr << "unhandled_char_error,";

}

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

}

return ostr.str();

}

static void backslash()

{

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

simplecpp::OutputList outputList;

readfile("//123 \\\n456", -1, &outputList);

ASSERT_EQUALS("", toString(outputList));

readfile("//123 \\ \n456", -1, &outputList);

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

outputList.clear();

readfile("#define A \\\n123", -1, &outputList);

ASSERT_EQUALS("", toString(outputList));

readfile("#define A \\ \n123", -1, &outputList);

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

}

static void builtin()

{

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

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[])

{

std::istringstream istr(code);

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

simplecpp::TokenList expr(istr, files);

try {

expr.constFold();

} catch (std::exception &) {

return "exception";

}

return expr.stringify();

}

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("0x1E + 7", preprocess("0x1E+7"));

}

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);"));

}

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

{

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

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

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

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

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

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

}

static void comment_multiline()

{

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

"}\n"

"void f() ABC\n";

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

}

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"));

}

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/"));

}

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

{

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

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

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

}

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

{

std::istringstream istr("#define A(\nB\n");

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

std::map<std::string, simplecpp::TokenList*> filedata;

simplecpp::OutputList outputList;

simplecpp::TokenList tokens2(files);

simplecpp::preprocess(tokens2, simplecpp::TokenList(istr,files,"test.c"), files, filedata, simplecpp::DUI(), &outputList);

ASSERT_EQUALS("file0,1,syntax_error,Failed to parse #define\n", toString(outputList));

}

static void define_invalid_2()

{

std::istringstream istr("#define\nhas#");

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

std::map<std::string, simplecpp::TokenList*> filedata;

simplecpp::OutputList outputList;

simplecpp::TokenList tokens2(files);

simplecpp::preprocess(tokens2, simplecpp::TokenList(istr,files,"test.c"), files, filedata, simplecpp::DUI(), &outputList);

ASSERT_EQUALS("file0,1,syntax_error,Failed to parse #define\n", toString(outputList));

}

static void define_define_1()

{

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

"#define B A(\n"

"B(i))";

ASSERT_EQUALS("\n\n( ( i ) + 1 )", preprocess(code));

}

static void define_define_2()

{

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

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

"B(0)";

ASSERT_EQUALS("\n\nn = 0", preprocess(code));

}

static void define_define_3()

{

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

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

"A(BC)";

ASSERT_EQUALS("\n\n123", preprocess(code));

}

static void define_define_4()

{

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

"#define TEST(FOO) FOO FOO()\n"

"TEST(FOO1)";

ASSERT_EQUALS("\n\nFOO1", preprocess(code));

}

static void define_define_5()

{

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

"#define Y() X\n"

"A: X()()()\n";

// mcpp outputs "A: X()" and gcc/clang/vc outputs "A: Y"

ASSERT_EQUALS("\n\nA : Y", preprocess(code)); // <- match the output from gcc/clang/vc

}

static void define_define_6()

{

const char code1[] = "#define f(a) a*g\n"

"#define g f\n"

"a: f(2)(9)\n";

ASSERT_EQUALS("\n\na : 2 * f ( 9 )", preprocess(code1));

const char code2[] = "#define f(a) a*g\n"

"#define g(a) f(a)\n"

"a: f(2)(9)\n";

ASSERT_EQUALS("\n\na : 2 * 9 * g", preprocess(code2));

}

static void define_define_7()

{

const char code[] = "#define f(x) g(x\n"

"#define g(x) x()\n"

"f(f))\n";

ASSERT_EQUALS("\n\nf ( )", preprocess(code));

}

static void define_define_8() // line break in nested macro call

{

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

"#define B(X,Y) ((X)+(Y))\n"

"B(0,A(255,x+\n"

"y))\n";

ASSERT_EQUALS("\n\n( ( 0 ) + ( ( ( 255 ) * ( x + y ) ) ) )", preprocess(code));

}

static void define_define_9() // line break in nested macro call

{

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

"#define B(X) X\n"

"A(\nB(dostuff(1,\n2)))\n";

ASSERT_EQUALS("\n\ndostuff ( 1 , 2 )", preprocess(code));

}

static void define_define_10()

{

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

"#define xglue(a, b) glue(a, b)\n"

"#define AB 1\n"

"#define B B 2\n"

"xglue(A, B)\n";

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

}

static void define_define_11()

{

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

"#define XY2(x, y) XY(x, y)\n"

"#define PORT XY2(P, 2)\n"

"#define ABC XY2(PORT, DIR)\n"

"ABC;\n";

ASSERT_EQUALS("\n\n\n\nP2DIR ;", preprocess(code));

}

static void define_define_12()

{

const char code[] = "#define XY(Z) Z\n"

"#define X(ID) X##ID(0)\n"

"X(Y)\n";

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

}

static void define_define_13() // issue #49 - empty macro

{

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

"#define t(a) a\n"

"(t(f))\n";

ASSERT_EQUALS("\n\n( f )", preprocess(code));

}

static void define_define_14() // issue #58 - endless recursion

{

const char code[] = "#define z f(w\n"

"#define f()\n"

"#define w f(z\n"

"w\n";

ASSERT_EQUALS("\n\n\nf ( f ( w", preprocess(code)); // Don't crash

}

static void define_va_args_1()

{

const char code[] = "#define A(fmt...) dostuff(fmt)\n"

"A(1,2);";

ASSERT_EQUALS("\ndostuff ( 1 , 2 ) ;", preprocess(code));

}

static void define_va_args_2()

{

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

"A(f,123);";

ASSERT_EQUALS("\nf ( \"123\" ) ;", preprocess(code));

}

static void define_va_args_3() // min number of arguments

{

const char code[] = "#define A(x, y, z...) 1\n"

"A(1, 2)\n";

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

}

static void define_ifdef()

{

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

"A(1\n"

"#ifdef CFG\n"

"#endif\n"

")\n";

const simplecpp::DUI dui;

simplecpp::OutputList outputList;

preprocess(code, dui, &outputList);

ASSERT_EQUALS("file0,3,syntax_error,failed to expand 'A', it is invalid to use a preprocessor directive as macro parameter\n", toString(outputList));

}

static void dollar()

{

ASSERT_EQUALS("$ab", readfile("$ab"));

ASSERT_EQUALS("a$b", readfile("a$b"));

}

static void error1()

{

std::istringstream istr("#error hello world!\n");

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

std::map<std::string, simplecpp::TokenList*> filedata;

simplecpp::OutputList outputList;

simplecpp::TokenList tokens2(files);

simplecpp::preprocess(tokens2, simplecpp::TokenList(istr,files,"test.c"), files, filedata, simplecpp::DUI(), &outputList);

ASSERT_EQUALS("file0,1,#error,#error hello world!\n", toString(outputList));

}

static void error2()

{

std::istringstream istr("#error it's an error\n");

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

std::map<std::string, simplecpp::TokenList*> filedata;

simplecpp::OutputList outputList;

simplecpp::TokenList tokens2(files);

simplecpp::preprocess(tokens2, simplecpp::TokenList(istr,files,"test.c"), files, filedata, simplecpp::DUI(), &outputList);

ASSERT_EQUALS("file0,1,#error,#error it's an error\n", toString(outputList));

}

static void error3()

{

std::istringstream istr("#error \"bla bla\\\n"

" bla bla.\"\n");

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

simplecpp::OutputList outputList;

simplecpp::TokenList rawtokens(istr, files, "test.c", &outputList);

ASSERT_EQUALS("", toString(outputList));

}

static void error4()

{

// "#error x\n1"

std::istringstream istr(std::string("\xFE\xFF\x00\x23\x00\x65\x00\x72\x00\x72\x00\x6f\x00\x72\x00\x20\x00\x78\x00\x0a\x00\x31", 22));

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

std::map<std::string, simplecpp::TokenList*> filedata;

simplecpp::OutputList outputList;

simplecpp::TokenList tokens2(files);

simplecpp::preprocess(tokens2, simplecpp::TokenList(istr,files,"test.c"), files, filedata, simplecpp::DUI(), &outputList);

ASSERT_EQUALS("file0,1,#error,#error x\n", toString(outputList));

}

static void error5()

{

// "#error x\n1"

std::istringstream istr(std::string("\xFF\xFE\x23\x00\x65\x00\x72\x00\x72\x00\x6f\x00\x72\x00\x20\x00\x78\x00\x0a\x00\x78\x00\x31\x00", 22));

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

std::map<std::string, simplecpp::TokenList*> filedata;

simplecpp::OutputList outputList;

simplecpp::TokenList tokens2(files);

simplecpp::preprocess(tokens2, simplecpp::TokenList(istr,files,"test.c"), files, filedata, simplecpp::DUI(), &outputList);

ASSERT_EQUALS("file0,1,#error,#error x\n", toString(outputList));

}

static void garbage()

{

const simplecpp::DUI dui;

simplecpp::OutputList outputList;

outputList.clear();

preprocess("#ifdef\n", dui, &outputList);

ASSERT_EQUALS("file0,1,syntax_error,Syntax error in #ifdef\n", toString(outputList));

outputList.clear();

preprocess("#define TEST2() A ##\nTEST2()\n", dui, &outputList);

ASSERT_EQUALS("file0,1,syntax_error,failed to expand 'TEST2', Invalid ## usage when expanding 'TEST2'.\n", toString(outputList));

outputList.clear();

preprocess("#define CON(a,b) a##b##\nCON(1,2)\n", dui, &outputList);

ASSERT_EQUALS("file0,1,syntax_error,failed to expand 'CON', Invalid ## usage when expanding 'CON'.\n", toString(outputList));

}

static void garbage_endif()

{

const simplecpp::DUI dui;

simplecpp::OutputList outputList;

outputList.clear();

preprocess("#elif A<0\n", dui, &outputList);

ASSERT_EQUALS("file0,1,syntax_error,#elif without #if\n", toString(outputList));

outputList.clear();

preprocess("#else\n", dui, &outputList);

ASSERT_EQUALS("file0,1,syntax_error,#else without #if\n", toString(outputList));

outputList.clear();

preprocess("#endif\n", dui, &outputList);

ASSERT_EQUALS("file0,1,syntax_error,#endif without #if\n", toString(outputList));

}

static void hash()

{

ASSERT_EQUALS("x = \"1\"", preprocess("x=#__LINE__"));

const char code[] = "#define a(x) #x\n"

"a(1)\n"

"a(2+3)";

ASSERT_EQUALS("\n"

"\"1\"\n"

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

ASSERT_EQUALS("\n\"\\\"abc\\\\0\\\"\"", preprocess("#define str(x) #x\nstr(\"abc\\0\")\n"));

ASSERT_EQUALS("\n\n( \"123\" )",

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

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

"B(123)"));

}

static void hashhash1() // #4703

{

const char code[] = "#define MACRO( A, B, C ) class A##B##C##Creator {};\n"

"MACRO( B\t, U , G )";

ASSERT_EQUALS("\nclass BUGCreator { } ;", preprocess(code));

}

static void hashhash2()

{

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

"#define B 0\n"

"A(B)";

ASSERT_EQUALS("\n\naB", preprocess(code));

}

static void hashhash3()

{

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

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

"a(A(B))";

ASSERT_EQUALS("\n\nAAB", preprocess(code));

}

static void hashhash4() // nonstandard gcc/clang extension for empty varargs

{

const char *code;

code = "#define A(x,y...) a(x,##y)\n"

"A(1)\n";

ASSERT_EQUALS("\na ( 1 )", preprocess(code));

code = "#define A(x, ...) a(x, ## __VA_ARGS__)\n"

"#define B(x, ...) A(x, ## __VA_ARGS__)\n"

"B(1);";

ASSERT_EQUALS("\n\na ( 1 ) ;", preprocess(code));

}

static void hashhash5()

{

ASSERT_EQUALS("x1", preprocess("x##__LINE__"));

}

static void hashhash6()

{

const char *code;

code = "#define A(X, ...) LOG(X, ##__VA_ARGS__)\n"

"A(1,(int)2)";

ASSERT_EQUALS("\nLOG ( 1 , ( int ) 2 )", preprocess(code));

code = "#define A(X, ...) LOG(X, ##__VA_ARGS__)\n"

"#define B(X, ...) A(X, ##__VA_ARGS__)\n"

"#define C(X, ...) B(X, ##__VA_ARGS__)\n"

"C(1,(int)2)";

ASSERT_EQUALS("\n\n\nLOG ( 1 , ( int ) 2 )", preprocess(code));

}

static void hashhash7() // # ## # (C standard; 6.10.3.3.p4)

{

const char *code;

code = "#define hash_hash # ## #\n"

"x hash_hash y";

ASSERT_EQUALS("\nx ## y", preprocess(code));

}

static void hashhash8()

{

const char code[] = "#define a(xy) x##y = xy\n"

"a(123);";

ASSERT_EQUALS("\nxy = 123 ;", preprocess(code));

}

static void hashhash9()

{

const char * code = "#define ADD_OPERATOR(OP) void operator OP ## = (void) { x = x OP 1; }\n"

"ADD_OPERATOR(+);\n"

"ADD_OPERATOR(-);\n"

"ADD_OPERATOR(*);\n"

"ADD_OPERATOR(/);\n"

"ADD_OPERATOR(%);\n"

"ADD_OPERATOR(&);\n"

"ADD_OPERATOR(|);\n"

"ADD_OPERATOR(^);\n"

"ADD_OPERATOR(<<);\n"

"ADD_OPERATOR(>>);\n";

const char expected[] = "\n"

"void operator += ( void ) { x = x + 1 ; } ;\n"

"void operator -= ( void ) { x = x - 1 ; } ;\n"

"void operator *= ( void ) { x = x * 1 ; } ;\n"

"void operator /= ( void ) { x = x / 1 ; } ;\n"

"void operator %= ( void ) { x = x % 1 ; } ;\n"

"void operator &= ( void ) { x = x & 1 ; } ;\n"

"void operator |= ( void ) { x = x | 1 ; } ;\n"

"void operator ^= ( void ) { x = x ^ 1 ; } ;\n"

"void operator <<= ( void ) { x = x << 1 ; } ;\n"

"void operator >>= ( void ) { x = x >> 1 ; } ;";

ASSERT_EQUALS(expected, preprocess(code));

const simplecpp::DUI dui;

simplecpp::OutputList outputList;

code = "#define A +##x\n"

"A";

outputList.clear();

preprocess(code, dui, &outputList);

ASSERT_EQUALS("file0,1,syntax_error,failed to expand 'A', Invalid ## usage when expanding 'A'.\n", toString(outputList));

code = "#define A 2##=\n"

"A";

outputList.clear();

preprocess(code, dui, &outputList);

ASSERT_EQUALS("file0,1,syntax_error,failed to expand 'A', Invalid ## usage when expanding 'A'.\n", toString(outputList));

code = "#define A <<##x\n"

"A";

outputList.clear();

preprocess(code, dui, &outputList);

ASSERT_EQUALS("file0,1,syntax_error,failed to expand 'A', Invalid ## usage when expanding 'A'.\n", toString(outputList));

}

static void hashhash_invalid_1()

{

std::istringstream istr("#define f(a) (##x)\nf(1)");

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

std::map<std::string, simplecpp::TokenList*> filedata;

simplecpp::OutputList outputList;

simplecpp::TokenList tokens2(files);

simplecpp::preprocess(tokens2, simplecpp::TokenList(istr,files,"test.c"), files, filedata, simplecpp::DUI(), &outputList);

ASSERT_EQUALS("file0,1,syntax_error,failed to expand 'f', Invalid ## usage when expanding 'f'.\n", toString(outputList));

}

static void hashhash_invalid_2()

{

std::istringstream istr("#define f(a) (x##)\nf(1)");

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

std::map<std::string, simplecpp::TokenList*> filedata;

simplecpp::OutputList outputList;

simplecpp::TokenList tokens2(files);

simplecpp::preprocess(tokens2, simplecpp::TokenList(istr,files,"test.c"), files, filedata, simplecpp::DUI(), &outputList);

ASSERT_EQUALS("file0,1,syntax_error,failed to expand 'f', Invalid ## usage when expanding 'f'.\n", toString(outputList));

}

static void ifdef1()

{

const char code[] = "#ifdef A\n"

"1\n"

"#else\n"

"2\n"

"#endif";

ASSERT_EQUALS("\n\n\n2", preprocess(code));

}

static void ifdef2()

{

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

"#ifdef A\n"

"1\n"

"#else\n"

"2\n"

"#endif";

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

}

static void ifndef()

{

const char code1[] = "#define A\n"

"#ifndef A\n"

"1\n"

"#endif";

ASSERT_EQUALS("", preprocess(code1));

const char code2[] = "#ifndef A\n"

"1\n"

"#endif";

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

}

static void ifA()

{

const char code[] = "#if A==1\n"

"X\n"

"#endif";

ASSERT_EQUALS("", preprocess(code));

simplecpp::DUI dui;

dui.defines.push_back("A=1");

ASSERT_EQUALS("\nX", preprocess(code, dui));

}

static void ifCharLiteral()

{

const char code[] = "#if ('A'==0x41)\n"

"123\n"

"#endif";

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

}

static void ifDefined()

{

const char code[] = "#if defined(A)\n"

"X\n"

"#endif";

simplecpp::DUI dui;

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

dui.defines.push_back("A=1");

ASSERT_EQUALS("\nX", preprocess(code, dui));

}

static void ifDefinedNoPar()

{

const char code[] = "#if defined A\n"

"X\n"

"#endif";

simplecpp::DUI dui;

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

dui.defines.push_back("A=1");

ASSERT_EQUALS("\nX", preprocess(code, dui));

}

static void ifDefinedNested()

{

const char code[] = "#define FOODEF defined(FOO)\n"

"#if FOODEF\n"

"X\n"

"#endif";

simplecpp::DUI dui;

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

dui.defines.push_back("FOO=1");

ASSERT_EQUALS("\n\nX", preprocess(code, dui));

}

static void ifDefinedNestedNoPar()

{

const char code[] = "#define FOODEF defined FOO\n"

"#if FOODEF\n"

"X\n"

"#endif";

simplecpp::DUI dui;

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

dui.defines.push_back("FOO=1");

ASSERT_EQUALS("\n\nX", preprocess(code, dui));

}

static void ifDefinedInvalid1() // #50 - invalid unterminated defined

{

const char code[] = "#if defined(A";

simplecpp::DUI dui;

simplecpp::OutputList outputList;

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

simplecpp::TokenList tokens2(files);

std::istringstream istr(code);

std::map<std::string, simplecpp::TokenList*> filedata;

simplecpp::preprocess(tokens2, simplecpp::TokenList(istr,files), files, filedata, dui, &outputList);

ASSERT_EQUALS("file0,1,syntax_error,failed to evaluate #if condition\n", toString(outputList));

}

static void ifDefinedInvalid2()

{

const char code[] = "#if defined";

simplecpp::DUI dui;

simplecpp::OutputList outputList;

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

simplecpp::TokenList tokens2(files);

std::istringstream istr(code);

std::map<std::string, simplecpp::TokenList*> filedata;

simplecpp::preprocess(tokens2, simplecpp::TokenList(istr,files), files, filedata, dui, &outputList);

ASSERT_EQUALS("file0,1,syntax_error,failed to evaluate #if condition\n", toString(outputList));

}

static void ifLogical()

{

const char code[] = "#if defined(A) || defined(B)\n"

"X\n"

"#endif";

simplecpp::DUI dui;

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

dui.defines.clear();

dui.defines.push_back("A=1");

ASSERT_EQUALS("\nX", preprocess(code, dui));

dui.defines.clear();

dui.defines.push_back("B=1");

ASSERT_EQUALS("\nX", preprocess(code, dui));

}

static void ifSizeof()

{

const char code[] = "#if sizeof(unsigned short)==2\n"

"X\n"

"#else\n"

"Y\n"

"#endif";

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

}

static void elif()

{

const char code1[] = "#ifndef X\n"

"1\n"

"#elif 1<2\n"

"2\n"

"#else\n"

"3\n"

"#endif";

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

const char code2[] = "#ifdef X\n"

"1\n"

"#elif 1<2\n"

"2\n"

"#else\n"

"3\n"

"#endif";

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

const char code3[] = "#ifdef X\n"

"1\n"

"#elif 1>2\n"

"2\n"

"#else\n"

"3\n"

"#endif";

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

}

static void ifif()

{

// source code from LLVM

const char code[] = "#if defined(__has_include)\n"

"#if __has_include(<sanitizer / coverage_interface.h>)\n"

"#endif\n"

"#endif\n";

ASSERT_EQUALS("", preprocess(code));

}

static void ifoverflow()

{

// source code from CLANG

const char code[] = "#if 0x7FFFFFFFFFFFFFFF*2\n"

"#endif\n"

"#if 0xFFFFFFFFFFFFFFFF*2\n"

"#endif\n"

"#if 0x7FFFFFFFFFFFFFFF+1\n"

"#endif\n"

"#if 0xFFFFFFFFFFFFFFFF+1\n"

"#endif\n"

"#if 0x7FFFFFFFFFFFFFFF--1\n"

"#endif\n"

"#if 0xFFFFFFFFFFFFFFFF--1\n"

"#endif\n"

"123";

(void)preprocess(code);

}

static void ifdiv0()

{

const char code[] = "#if 1000/0\n"

"#endif\n"

"123";

ASSERT_EQUALS("", preprocess(code));

}

static void ifalt() // using "and", "or", etc

{

const char *code;

code = "#if 1 and 1\n"

"1\n"

"#else\n"

"2\n"

"#endif\n";

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

code = "#if 1 or 0\n"

"1\n"