TestPreprocessor() : TestFixture("TestPreprocessor") {

Preprocessor::macroChar = '$';

}

class OurPreprocessor : public Preprocessor {

public:

static std::string replaceIfDefined(const std::string &str) {

Preprocessor p;

return p.replaceIfDefined(str);

}

static std::string expandMacros(const std::string& code, ErrorLogger *errorLogger = 0) {

return Preprocessor::expandMacros(code, "file.cpp", "", errorLogger);

}

static int getHeaderFileName(std::string &str) {

return Preprocessor::getHeaderFileName(str);

}

};

void run() {

// Just read the code into a string. Perform simple cleanup of the code

TEST_CASE(readCode1);

TEST_CASE(readCode2); // #4308 - convert C++11 raw string to plain old C string

TEST_CASE(readCode3);

TEST_CASE(readCode4); // #4351 - escaped whitespace in gcc

// reading utf-16 file

TEST_CASE(utf16);

// remove comments

TEST_CASE(removeComments);

// The bug that started the whole work with the new preprocessor

TEST_CASE(Bug2190219);

TEST_CASE(test1);

TEST_CASE(test2);

TEST_CASE(test3);

TEST_CASE(test4);

TEST_CASE(test5);

TEST_CASE(test6);

TEST_CASE(test7);

TEST_CASE(test7a);

TEST_CASE(test7b);

TEST_CASE(test7c);

TEST_CASE(test7d);

TEST_CASE(test7e);

TEST_CASE(test8); // #if A==1 => cfg: A=1

TEST_CASE(test9); // Don't crash for invalid code

TEST_CASE(test10); // Ticket #5139

// #error => don't extract any code

TEST_CASE(error1);

// #error with extended chars

TEST_CASE(error2);

TEST_CASE(error3);

TEST_CASE(error4); // #2919 - wrong filename is reported

TEST_CASE(if0_exclude);

TEST_CASE(if0_whitespace);

TEST_CASE(if0_else);

TEST_CASE(if0_elif);

// Don't handle include in a #if 0 block

TEST_CASE(if0_include_1);

TEST_CASE(if0_include_2);

// Handling include guards (don't create extra configuration for it)

TEST_CASE(includeguard1);

TEST_CASE(includeguard2);

TEST_CASE(newlines);

TEST_CASE(comments1);

TEST_CASE(if0);

TEST_CASE(if1);

TEST_CASE(elif);

// Test the Preprocessor::match_cfg_def

TEST_CASE(match_cfg_def);

TEST_CASE(if_cond1);

TEST_CASE(if_cond2);

TEST_CASE(if_cond3);

TEST_CASE(if_cond4);

TEST_CASE(if_cond5);

TEST_CASE(if_cond6);

TEST_CASE(if_cond8);

TEST_CASE(if_cond9);

TEST_CASE(if_cond10);

TEST_CASE(if_cond11);

TEST_CASE(if_cond12);

TEST_CASE(if_cond13);

TEST_CASE(if_cond14);

TEST_CASE(if_cond15); // #4456 - segfault

TEST_CASE(if_or_1);

TEST_CASE(if_or_2);

TEST_CASE(if_macro_eq_macro); // #3536

TEST_CASE(ticket_3675);

TEST_CASE(ticket_3699);

TEST_CASE(ticket_4922); // #4922

TEST_CASE(multiline1);

TEST_CASE(multiline2);

TEST_CASE(multiline3);

TEST_CASE(multiline4);

TEST_CASE(multiline5);

TEST_CASE(remove_asm);

TEST_CASE(if_defined); // "#if defined(AAA)" => "#ifdef AAA"

TEST_CASE(if_not_defined); // "#if !defined(AAA)" => "#ifndef AAA"

// Macros..

TEST_CASE(macro_simple1);

TEST_CASE(macro_simple2);

TEST_CASE(macro_simple3);

TEST_CASE(macro_simple4);

TEST_CASE(macro_simple5);

TEST_CASE(macro_simple6);

TEST_CASE(macro_simple7);

TEST_CASE(macro_simple8);

TEST_CASE(macro_simple9);

TEST_CASE(macro_simple10);

TEST_CASE(macro_simple11);

TEST_CASE(macro_simple12);

TEST_CASE(macro_simple13);

TEST_CASE(macro_simple14);

TEST_CASE(macro_simple15);

TEST_CASE(macro_simple16); // #4703: Macro parameters not trimmed

TEST_CASE(macro_simple17); // #5074: isExpandedMacro not set

TEST_CASE(macro_simple18); // (1e-7)

TEST_CASE(macroInMacro1);

TEST_CASE(macroInMacro2);

TEST_CASE(macro_mismatch);

TEST_CASE(macro_linenumbers);

TEST_CASE(macro_nopar);

TEST_CASE(macro_switchCase);

TEST_CASE(macro_NULL); // skip #define NULL .. it is replaced in the tokenizer

TEST_CASE(string1);

TEST_CASE(string2);

TEST_CASE(string3);

TEST_CASE(preprocessor_undef);

TEST_CASE(defdef); // Defined multiple times

TEST_CASE(preprocessor_doublesharp);

TEST_CASE(preprocessor_include_in_str);

TEST_CASE(va_args_1);

TEST_CASE(va_args_2);

TEST_CASE(va_args_3);

TEST_CASE(va_args_4);

TEST_CASE(multi_character_character);

TEST_CASE(stringify);

TEST_CASE(stringify2);

TEST_CASE(stringify3);

TEST_CASE(stringify4);

TEST_CASE(stringify5);

TEST_CASE(ifdefwithfile);

TEST_CASE(pragma);

TEST_CASE(pragma_asm_1);

TEST_CASE(pragma_asm_2);

TEST_CASE(pragma_once);

TEST_CASE(endifsemicolon);

TEST_CASE(missing_doublequote);

TEST_CASE(handle_error);

TEST_CASE(dup_defines);

TEST_CASE(unicodeInCode);

TEST_CASE(unicodeInComment);

TEST_CASE(unicodeInString);

TEST_CASE(define_part_of_func);

TEST_CASE(conditionalDefine);

TEST_CASE(multiline_comment);

TEST_CASE(macro_parameters);

TEST_CASE(newline_in_macro);

TEST_CASE(includes);

TEST_CASE(ifdef_ifdefined);

// define and then ifdef

TEST_CASE(define_if1);

TEST_CASE(define_if2);

TEST_CASE(define_if3);

TEST_CASE(define_if4); // #4079 - #define X +123

TEST_CASE(define_if5); // #4516 - #define B (A & 0x00f0)

TEST_CASE(define_if6); // #4863 - #define B (A?-1:1)

TEST_CASE(define_ifdef);

TEST_CASE(define_ifndef1);

TEST_CASE(define_ifndef2);

TEST_CASE(ifndef_define);

TEST_CASE(undef_ifdef);

TEST_CASE(endfile);

TEST_CASE(redundant_config);

TEST_CASE(testPreprocessorRead1);

TEST_CASE(testPreprocessorRead2);

TEST_CASE(testPreprocessorRead3);

TEST_CASE(testPreprocessorRead4);

TEST_CASE(invalid_define_1); // #2605 - hang for: '#define ='

TEST_CASE(invalid_define_2); // #4036 - hang for: '#define () {(int f(x) }'

// Show 'missing include' warnings

TEST_CASE(missingInclude);

// inline suppression, missingInclude

TEST_CASE(inline_suppression_for_missing_include);

// Using -D to predefine symbols

TEST_CASE(predefine1);

TEST_CASE(predefine2);

TEST_CASE(predefine3);

TEST_CASE(predefine4);

TEST_CASE(predefine5); // automatically define __cplusplus

TEST_CASE(predefine6); // using -D and -f => check all matching configurations

// Test Preprocessor::simplifyCondition

TEST_CASE(simplifyCondition);

TEST_CASE(invalidElIf); // #2942 segfault

// Defines are given: test Preprocessor::handleIncludes

TEST_CASE(def_handleIncludes);

TEST_CASE(def_missingInclude);

TEST_CASE(def_handleIncludes_ifelse1); // problems in handleIncludes for #else

TEST_CASE(def_handleIncludes_ifelse2);

TEST_CASE(def_handleIncludes_ifelse3); // #4868 - crash

TEST_CASE(def_valueWithParentheses); // #3531

// Using -U to undefine symbols

TEST_CASE(undef1);

TEST_CASE(undef2);

TEST_CASE(undef3);

TEST_CASE(undef4);

TEST_CASE(undef5);

TEST_CASE(undef6);

TEST_CASE(undef7);

TEST_CASE(undef8);

TEST_CASE(undef9);

TEST_CASE(undef10);

TEST_CASE(handleUndef);

TEST_CASE(macroChar);

TEST_CASE(validateCfg);

TEST_CASE(if_sizeof);

}

void readCode1() {

const char code[] = " \t a //\n"

" #aa\t /* remove this */\tb \r\n";

Settings settings;

Preprocessor preprocessor(&settings, this);

std::istringstream istr(code);

std::string codestr(preprocessor.read(istr,"test.c"));

ASSERT_EQUALS("a\n#aa b\n", codestr);

}

void readCode2() {

const char code[] = "R\"( \" /* abc */ \n)\";";

Settings settings;

Preprocessor preprocessor(&settings, this);

std::istringstream istr(code);

std::string codestr(preprocessor.read(istr,"test.c"));

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

}

void readCode3() {

const char code[] = "func(#errorname)";

Settings settings;

Preprocessor preprocessor(&settings, this);

std::istringstream istr(code);

std::string codestr(preprocessor.read(istr,"test.c"));

ASSERT_EQUALS("func(#errorname)", codestr);

}

void readCode4() {

const char code[] = "char c = '\\ ';";

Settings settings;

errout.str("");

Preprocessor preprocessor(&settings, this);

std::istringstream istr(code);

ASSERT_EQUALS("char c = '\\ ';", preprocessor.read(istr,"test.c"));

ASSERT_EQUALS("", errout.str());

}

void utf16() {

Settings settings;

Preprocessor preprocessor(&settings, this);

// a => a

{

const char code[] = { (char)0xff, (char)0xfe, 'a', '\0' };

std::string s(code, sizeof(code));

std::istringstream istr(s);

ASSERT_EQUALS("a", preprocessor.read(istr, "test.c"));

}

{

const char code[] = { (char)0xfe, (char)0xff, '\0', 'a' };

std::string s(code, sizeof(code));

std::istringstream istr(s);

ASSERT_EQUALS("a", preprocessor.read(istr, "test.c"));

}

// extended char => 0xff

{

const char code[] = { (char)0xff, (char)0xfe, 'a', 'a' };

std::string s(code, sizeof(code));

std::istringstream istr(s);

const char expected[] = { (char)0xff, 0 };

ASSERT_EQUALS(expected, preprocessor.read(istr, "test.c"));

}

{

const char code[] = { (char)0xfe, (char)0xff, 'a', 'a' };

std::string s(code, sizeof(code));

std::istringstream istr(s);

const char expected[] = { (char)0xff, 0 };

ASSERT_EQUALS(expected, preprocessor.read(istr, "test.c"));

}

// \r\n => \n

{

const char code[] = { (char)0xff, (char)0xfe, '\r', '\0', '\n', '\0' };

std::string s(code, sizeof(code));

std::istringstream istr(s);

ASSERT_EQUALS("\n", preprocessor.read(istr, "test.c"));

}

{

const char code[] = { (char)0xfe, (char)0xff, '\0', '\r', '\0', '\n' };

std::string s(code, sizeof(code));

std::istringstream istr(s);

ASSERT_EQUALS("\n", preprocessor.read(istr, "test.c"));

}

}

void removeComments() {

Settings settings;

Preprocessor preprocessor(&settings, this);

// #3837 - asm comments

const char code[] = "void test(void) {\n"

" __asm\n"

" {\n"

" ;---- тест\n"

" }\n"

"}\n";

ASSERT_EQUALS(true, std::string::npos == preprocessor.removeComments(code, "3837.c").find("----"));

ASSERT_EQUALS(" __asm123", preprocessor.removeComments(" __asm123", "3837.cpp"));

ASSERT_EQUALS("\" __asm { ; } \"", preprocessor.removeComments("\" __asm { ; } \"", "3837.cpp"));

ASSERT_EQUALS("__asm__ volatile { \"\" }", preprocessor.removeComments("__asm__ volatile { \"\" }", "3837.cpp"));

// #4873

ASSERT_EQUALS("__asm { }", preprocessor.removeComments("__asm { /* This is a comment */ }", "4873.cpp"));

// #5169

ASSERT_EQUALS("#define A(B) __asm__(\"int $3\"); int wait=1;\n",

preprocessor.removeComments("#define A(B) __asm__(\"int $3\"); /**/ int wait=1;\n", "5169.c"));

}

void Bug2190219() {

const char filedata[] = "int main()\n"

"{\n"

"#ifdef __cplusplus\n"

" int* flags = new int[10];\n"

"#else\n"

" int* flags = (int*)malloc((10)*sizeof(int));\n"

"#endif\n"

"\n"

"#ifdef __cplusplus\n"

" delete [] flags;\n"

"#else\n"

" free(flags);\n"

"#endif\n"

"}\n";

// Expected result..

std::map<std::string, std::string> expected;

expected[""] = "int main()\n"

"{\n"

"\n"

"\n"

"\n"

"int* flags = (int*)malloc((10)*sizeof(int));\n"

"\n"

"\n"

"\n"

"\n"

"\n"

"free(flags);\n"

"\n"

"}\n";

expected["__cplusplus"] = "int main()\n"

"{\n"

"\n"

"int* flags = new int[10];\n"

"\n"

"\n"

"\n"

"\n"

"\n"

"delete [] flags;\n"

"\n"

"\n"

"\n"

"}\n";

// Preprocess => actual result..

std::istringstream istr(filedata);

std::map<std::string, std::string> actual;

Settings settings;

Preprocessor preprocessor(&settings, this);

preprocessor.preprocess(istr, actual, "file.c");

// Compare results..

ASSERT_EQUALS(expected[""], actual[""]);

ASSERT_EQUALS(expected["__cplusplus"], actual["__cplusplus"]);

ASSERT_EQUALS(2, static_cast<unsigned int>(actual.size()));

}

void test1() {

const char filedata[] = "#ifdef WIN32 \n"

" abcdef\n"

"#else \n"

" qwerty\n"

"#endif \n";

// Preprocess => actual result..

std::istringstream istr(filedata);

std::map<std::string, std::string> actual;

Settings settings;

Preprocessor preprocessor(&settings, this);

preprocessor.preprocess(istr, actual, "file.c");

// Compare results..

ASSERT_EQUALS("\n\n\nqwerty\n\n", actual[""]);

ASSERT_EQUALS("\nabcdef\n\n\n\n", actual["WIN32"]);

ASSERT_EQUALS(2, static_cast<unsigned int>(actual.size()));

}

void test2() {

const char filedata[] = "# ifndef WIN32\n"

" \" # ifdef WIN32\" // a comment\n"

" # else \n"

" qwerty\n"

" # endif \n";

// Preprocess => actual result..

std::istringstream istr(filedata);

std::map<std::string, std::string> actual;

Settings settings;

Preprocessor preprocessor(&settings, this);

preprocessor.preprocess(istr, actual, "file.c");

// Compare results..

ASSERT_EQUALS("\n\" # ifdef WIN32\"\n\n\n\n", actual[""]);

ASSERT_EQUALS("\n\n\nqwerty\n\n", actual["WIN32"]);

ASSERT_EQUALS(2, static_cast<unsigned int>(actual.size()));

}

void test3() {

const char filedata[] = "#ifdef ABC\n"

"a\n"

"#ifdef DEF\n"

"b\n"

"#endif\n"

"c\n"

"#endif\n";

// Preprocess => actual result..

std::istringstream istr(filedata);

std::map<std::string, std::string> actual;

Settings settings;

Preprocessor preprocessor(&settings, this);

preprocessor.preprocess(istr, actual, "file.c");

// Compare results..

ASSERT_EQUALS("\n\n\n\n\n\n\n", actual[""]);

ASSERT_EQUALS("\na\n\n\n\nc\n\n", actual["ABC"]);

ASSERT_EQUALS("\na\n\nb\n\nc\n\n", actual["ABC;DEF"]);

ASSERT_EQUALS(3, static_cast<unsigned int>(actual.size()));

}

void test4() {

const char filedata[] = "#ifdef ABC\n"

"A\n"

"#endif\t\n"

"#ifdef ABC\n"

"A\n"

"#endif\n";

// Preprocess => actual result..

std::istringstream istr(filedata);

std::map<std::string, std::string> actual;

Settings settings;

Preprocessor preprocessor(&settings, this);

preprocessor.preprocess(istr, actual, "file.c");

// Compare results..

ASSERT_EQUALS("\n\n\n\n\n\n", actual[""]);

ASSERT_EQUALS("\nA\n\n\nA\n\n", actual["ABC"]);

ASSERT_EQUALS(2, static_cast<unsigned int>(actual.size()));

}

void test5() {

const char filedata[] = "#ifdef ABC\n"

"A\n"

"#else\n"

"B\n"

"#ifdef DEF\n"

"C\n"

"#endif\n"

"#endif\n";

// Preprocess => actual result..

std::istringstream istr(filedata);

std::map<std::string, std::string> actual;

Settings settings;

Preprocessor preprocessor(&settings, this);

preprocessor.preprocess(istr, actual, "file.c");

// Compare results..

ASSERT_EQUALS("\n\n\nB\n\n\n\n\n", actual[""]);

ASSERT_EQUALS("\nA\n\n\n\n\n\n\n", actual["ABC"]);

ASSERT_EQUALS("\n\n\nB\n\nC\n\n\n", actual["DEF"]);

ASSERT_EQUALS(3, static_cast<unsigned int>(actual.size()));

}

void test6() {

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

"#if ( A ) \n"

"#if A\n"

"#if defined((A))\n"

"#elif defined (A)\n";

std::istringstream istr(filedata);

Settings settings;

Preprocessor preprocessor(&settings, this);

const std::string actual(preprocessor.read(istr, "test.c"));

// Compare results..

ASSERT_EQUALS("#if A\n#if A\n#if A\n#if defined(A)\n#elif defined(A)\n", actual);

}

void test7() {

const char filedata[] = "#ifdef ABC\n"

"A\n"

"#ifdef ABC\n"

"B\n"

"#endif\n"

"#endif\n";

// Preprocess => actual result..

std::istringstream istr(filedata);

std::map<std::string, std::string> actual;

Settings settings;

Preprocessor preprocessor(&settings, this);

errout.str("");

preprocessor.preprocess(istr, actual, "file.c");

// Make sure an error message is written..

TODO_ASSERT_EQUALS("[file.c:3]: (error) ABC is already guaranteed to be defined\n",

"",

errout.str());

// Compare results..

ASSERT_EQUALS("\n\n\n\n\n\n", actual[""]);

ASSERT_EQUALS("\nA\n\nB\n\n\n", actual["ABC"]);

ASSERT_EQUALS(2, static_cast<unsigned int>(actual.size()));

test7a();

test7b();

test7c();

test7d();

}

void test7a() {

const char filedata[] = "#ifndef ABC\n"

"A\n"

"#ifndef ABC\n"

"B\n"

"#endif\n"

"#endif\n";

// Preprocess => actual result..

std::istringstream istr(filedata);

std::map<std::string, std::string> actual;

Settings settings;

Preprocessor preprocessor(&settings, this);

errout.str("");

preprocessor.preprocess(istr, actual, "file.c");

// Make sure an error message is written..

TODO_ASSERT_EQUALS("[file.c:3]: (error) ABC is already guaranteed NOT to be defined\n",

"", errout.str());

// Compare results..

ASSERT_EQUALS(2, static_cast<unsigned int>(actual.size()));

}

void test7b() {

const char filedata[] = "#ifndef ABC\n"

"A\n"

"#ifdef ABC\n"

"B\n"

"#endif\n"

"#endif\n";

// Preprocess => actual result..

std::istringstream istr(filedata);

std::map<std::string, std::string> actual;

Settings settings;

Preprocessor preprocessor(&settings, this);

errout.str("");

preprocessor.preprocess(istr, actual, "file.c");

// Make sure an error message is written..

TODO_ASSERT_EQUALS("[file.c:3]: (error) ABC is already guaranteed NOT to be defined\n",

"", errout.str());

// Compare results..

ASSERT_EQUALS(2, static_cast<unsigned int>(actual.size()));

}

void test7c() {

const char filedata[] = "#ifdef ABC\n"

"A\n"

"#ifndef ABC\n"

"B\n"

"#endif\n"

"#endif\n";

// Preprocess => actual result..

std::istringstream istr(filedata);

std::map<std::string, std::string> actual;

Settings settings;

Preprocessor preprocessor(&settings, this);

errout.str("");

preprocessor.preprocess(istr, actual, "file.c");

// Make sure an error message is written..

TODO_ASSERT_EQUALS("[file.c:3]: (error) ABC is already guaranteed to be defined\n",

"",

errout.str());

// Compare results..

ASSERT_EQUALS(2, static_cast<unsigned int>(actual.size()));

}

void test7d() {

const char filedata[] = "#if defined(ABC)\n"

"A\n"

"#if defined(ABC)\n"

"B\n"

"#endif\n"

"#endif\n";

// Preprocess => actual result..

std::istringstream istr(filedata);

std::map<std::string, std::string> actual;

Settings settings;

Preprocessor preprocessor(&settings, this);

errout.str("");

preprocessor.preprocess(istr, actual, "file.c");

// Make sure an error message is written..

TODO_ASSERT_EQUALS("[file.c:3]: (error) ABC is already guaranteed to be defined\n",

"",

errout.str());

// Compare results..

ASSERT_EQUALS(2, static_cast<unsigned int>(actual.size()));

}

void test7e() {

const char filedata[] = "#ifdef ABC\n"

"#file \"test.h\"\n"

"#ifndef test_h\n"

"#define test_h\n"

"#ifdef ABC\n"

"#endif\n"

"#endif\n"

"#endfile\n"

"#endif\n";

// Preprocess => actual result..

std::istringstream istr(filedata);

std::map<std::string, std::string> actual;

Settings settings;

Preprocessor preprocessor(&settings, this);

errout.str("");

preprocessor.preprocess(istr, actual, "file.c");

// Make sure an error message is written..

ASSERT_EQUALS("",

errout.str());

// Compare results..

ASSERT_EQUALS(2, static_cast<unsigned int>(actual.size()));

}

void test8() {

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

"1\n"

"#endif\n";

// Preprocess => actual result..

std::istringstream istr(filedata);

std::map<std::string, std::string> actual;

Settings settings;

Preprocessor preprocessor(&settings, this);

errout.str("");

preprocessor.preprocess(istr, actual, "file.c");

// No error..

ASSERT_EQUALS("", errout.str());

// Compare results..

ASSERT_EQUALS(2U, actual.size());

ASSERT_EQUALS("\n\n\n", actual[""]);

ASSERT_EQUALS("\n1\n\n", actual["A=1"]);

}

void test9() {

const char filedata[] = "#if\n"

"#else\n"

"#endif\n";

// Preprocess => actual result..

std::istringstream istr(filedata);

std::map<std::string, std::string> actual;

Settings settings;

settings._maxConfigs = 1;

settings.userDefines = "X";

Preprocessor preprocessor(&settings, this);

preprocessor.preprocess(istr, actual, "file.c"); // <- don't crash

}

void test10() { // Ticket #5139

const char filedata[] = "#define foo a.foo\n"

"#define bar foo\n"

"#define baz bar+0\n"

"#if 0\n"

"#endif";

// Preprocess => actual result..

std::istringstream istr(filedata);

std::map<std::string, std::string> actual;

Settings settings;

Preprocessor preprocessor(&settings, this);

preprocessor.preprocess(istr, actual, "file.c");

}

void error1() {

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

";\n"

"#else\n"

"#error abcd\n"

"#endif\n";

// Preprocess => actual result..

std::istringstream istr(filedata);

std::map<std::string, std::string> actual;

Settings settings;

Preprocessor preprocessor(&settings, this);

errout.str("");

preprocessor.preprocess(istr, actual, "file.c");

// Compare results..

ASSERT_EQUALS(2, static_cast<unsigned int>(actual.size()));

ASSERT_EQUALS("", actual[""]);

ASSERT_EQUALS("\n;\n\n\n\n", actual["A"]);

}

void error2() {

errout.str("");

const char filedata[] = "#error \xAB\n"

"#warning \xAB\n"

"123";

// Read string..

std::istringstream istr(filedata);

Settings settings;

Preprocessor preprocessor(&settings, this);

ASSERT_EQUALS("#error\n\n123", preprocessor.read(istr,"test.c"));

}

void error3() {

errout.str("");

Settings settings;

settings.userDefines = "__cplusplus";

Preprocessor preprocessor(&settings, this);

const std::string code("#error hello world!\n");

preprocessor.getcode(code, "X", "test.c");

ASSERT_EQUALS("[test.c:1]: (error) #error hello world!\n", errout.str());

}

// Ticket #2919 - wrong filename reported for #error

void error4() {

// In included file

{

errout.str("");

Settings settings;

settings.userDefines = "TEST";

Preprocessor preprocessor(&settings, this);

const std::string code("#file \"ab.h\"\n#error hello world!\n#endfile");

preprocessor.getcode(code, "TEST", "test.c");

ASSERT_EQUALS("[ab.h:1]: (error) #error hello world!\n", errout.str());

}

// After including a file

{

errout.str("");

Settings settings;

settings.userDefines = "TEST";

Preprocessor preprocessor(&settings, this);

const std::string code("#file \"ab.h\"\n\n#endfile\n#error aaa");

preprocessor.getcode(code, "TEST", "test.c");

ASSERT_EQUALS("[test.c:2]: (error) #error aaa\n", errout.str());

}

}

void if0_exclude() {

Settings settings;

Preprocessor preprocessor(&settings, this);

std::istringstream code("#if 0\n"

"A\n"

"#endif\n"

"B\n");

ASSERT_EQUALS("#if 0\n\n#endif\nB\n", preprocessor.read(code,""));

std::istringstream code2("#if (0)\n"

"A\n"

"#endif\n"

"B\n");

ASSERT_EQUALS("#if 0\n\n#endif\nB\n", preprocessor.read(code2,""));

}

void if0_whitespace() {

Settings settings;

Preprocessor preprocessor(&settings, this);

std::istringstream code(" # if 0 \n"

"A\n"

" # endif \n"

"B\n");

ASSERT_EQUALS("#if 0\n\n#endif\nB\n", preprocessor.read(code,""));

}

void if0_else() {

Settings settings;

Preprocessor preprocessor(&settings, this);

std::istringstream code("#if 0\n"

"A\n"

"#else\n"

"B\n"

"#endif\n"

"C\n");

ASSERT_EQUALS("#if 0\n\n#else\nB\n#endif\nC\n", preprocessor.read(code,""));

std::istringstream code2("#if 1\n"

"A\n"

"#else\n"

"B\n"

"#endif\n"

"C\n");

TODO_ASSERT_EQUALS("#if 1\nA\n#else\n\n#endif\nC\n",

"#if 1\nA\n#else\nB\n#endif\nC\n", preprocessor.read(code2,""));

}

void if0_elif() {

Settings settings;

Preprocessor preprocessor(&settings, this);

std::istringstream code("#if 0\n"

"A\n"

"#elif 1\n"

"B\n"

"#endif\n"

"C\n");

ASSERT_EQUALS("#if 0\n\n#elif 1\nB\n#endif\nC\n", preprocessor.read(code,""));

}

void if0_include_1() {

Settings settings;

Preprocessor preprocessor(&settings, this);

std::istringstream code("#if 0\n"

"#include \"a.h\"\n"

"#endif\n"

"AB\n");

ASSERT_EQUALS("#if 0\n\n#endif\nAB\n", preprocessor.read(code,""));

}

void if0_include_2() {

Settings settings;

Preprocessor preprocessor(&settings, this);

std::istringstream code("#if 0\n"

"#include \"a.h\"\n"

"#ifdef WIN32\n"

"#else\n"

"#endif\n"

"#endif\n"

"AB\n");

ASSERT_EQUALS("#if 0\n\n#ifdef WIN32\n#else\n#endif\n#endif\nAB\n", preprocessor.read(code,""));

}

void includeguard1() {

// Handling include guards..

const char filedata[] = "#file \"abc.h\"\n"

"#ifndef abcH\n"

"#define abcH\n"

"#endif\n"

"#endfile\n"

"#ifdef ABC\n"

"#endif";

// Preprocess => actual result..

std::istringstream istr(filedata);

std::map<std::string, std::string> actual;

Settings settings;

Preprocessor preprocessor(&settings, this);

preprocessor.preprocess(istr, actual, "file.c");

// Expected configurations: "" and "ABC"

ASSERT_EQUALS(2, static_cast<unsigned int>(actual.size()));

}