/*

* Cppcheck - A tool for static C/C++ code analysis

* Copyright (C) 2007-2011 Daniel Marjamäki and Cppcheck team.

*

* This program is free software: you can redistribute it and/or modify

* it under the terms of the GNU General Public License as published by

* the Free Software Foundation, either version 3 of the License, or

* (at your option) any later version.

*

* This program is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

* GNU General Public License for more details.

*

* You should have received a copy of the GNU General Public License

* along with this program. If not, see <http://www.gnu.org/licenses/>.

*/

// The preprocessor that Cppcheck uses is a bit special. Instead of generating

// the code for a known configuration, it generates the code for each configuration.

#include "testsuite.h"

#include "preprocessor.h"

#include "tokenize.h"

#include "token.h"

#include "settings.h"

#include <map>

#include <string>

#include <sstream>

#include <stdexcept>

extern std::ostringstream errout;

extern std::ostringstream output;

class TestPreprocessor : public TestFixture

{

public:

TestPreprocessor() : TestFixture("TestPreprocessor")

{ }

class OurPreprocessor : public Preprocessor

{

public:

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

{

return Preprocessor::replaceIfDefined(str);

}

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

{

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

}

static int getHeaderFileName(std::string &str)

{

return Preprocessor::getHeaderFileName(str);

}

};

private:

void run()

{

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

TEST_CASE(readCode1);

TEST_CASE(readCode2);

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

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

TEST_CASE(error1);

// #error with extended chars

TEST_CASE(error2);

TEST_CASE(error3);

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

TEST_CASE(if_or_2);

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

TEST_CASE(macro_mismatch);

TEST_CASE(macro_linenumbers);

TEST_CASE(macro_nopar);

TEST_CASE(macro_switchCase);

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

TEST_CASE(define_ifdef);

TEST_CASE(define_ifndef1);

TEST_CASE(define_ifndef2);

TEST_CASE(endfile);

TEST_CASE(redundant_config);

TEST_CASE(testPreprocessorRead1);

TEST_CASE(testPreprocessorRead2);

TEST_CASE(testPreprocessorRead3);

TEST_CASE(testPreprocessorRead4);

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

}

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

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

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

}

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

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

{

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

"#warning ê\n"

"123";

// Read string..

std::istringstream istr(filedata);

Settings settings;

Preprocessor preprocessor(&settings, this);

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

}

void error3()

{

Settings settings;

settings.userDefines = "__cplusplus";

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

Preprocessor::getcode(code, "X", "test.c", &settings, this);

ASSERT_EQUALS("[test.c:1]: (error) #error hello world!\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,"",NULL));

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

"A\n"

"#endif\n"

"B\n");

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

}

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

}

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

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

}

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

TODO_ASSERT_EQUALS("#if 0\n\n#elif 1\nB\n#endif\nC\n",

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

}

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

}

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

}

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

}

void includeguard2()

{

// Handling include guards..

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

"foo\n"

"#ifdef ABC\n"

"\n"

"#endif\n"

"#endfile\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");

// Expected configurations: "" and "ABC"

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

ASSERT_EQUALS(true, actual.find("") != actual.end());

ASSERT_EQUALS(true, actual.find("ABC") != actual.end());

}

void ifdefwithfile()

{

// Handling include guards..

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

"#file \"abc.h\"\n"

"class A{};/*\n\n\n\n\n\n\n*/\n"

"#endfile\n"

"#endif\n"

"int main() {}\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");

Tokenizer tok(&settings, this);

std::istringstream codeStream(actual[""]);

tok.tokenize(codeStream, "main.cpp");

ASSERT_EQUALS("\n\n##file 0\n1:\n2:\n3:\n4: int main ( ) { }\n", tok.tokens()->stringifyList());

// Expected configurations: "" and "ABC"

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

ASSERT_EQUALS("\n#file \"abc.h\"\n\n\n\n\n\n\n\n\n#endfile\n\nint main() {}\n", actual[""]);

ASSERT_EQUALS("\n#file \"abc.h\"\nclass A{};\n\n\n\n\n\n\n\n#endfile\n\nint main() {}\n", actual["ABC"]);

}

void newlines()

{

const char filedata[] = "\r\r\n\n";

// Preprocess

std::istringstream istr(filedata);

Settings settings;

Preprocessor preprocessor(&settings, this);

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

}

void comments1()

{

{

const char filedata[] = "/*\n"

"#ifdef WIN32\n"

"#endif\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("\n\n\n\n", actual[""]);

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

}

{

const char filedata[] = "/*\n"

"\x080 #ifdef WIN32\n"

"#endif\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("\n\n\n\n", actual[""]);

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

}

{

const char filedata[] = "void f()\n"

"{\n"

" *p = a / *b / *c;\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("void f()\n{\n*p = a / *b / *c;\n}\n", actual[""]);

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

}

}

void if0()

{

const char filedata[] = " # if /* comment */ 0 // comment\n"

"#ifdef WIN32\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\n\n", actual[""]);

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

}

void if1()

{

const char filedata[] = " # if /* comment */ 1 // comment\n"

"ABC\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("\nABC\n\n", actual[""]);

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

}

void elif()

{

{

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

"ABC\n"

"#elif DEF2\n"

"DEF\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", actual[""]);

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

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

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

}

{

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

"ABC\n"

"#elif(defined DEF2)\n"

"DEF\n"

"#else\n"

"GHI\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\nGHI\n\n", actual[""]);

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

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

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

}

}

void match_cfg_def()

{

{

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

ASSERT_EQUALS(false, Preprocessor::match_cfg_def(cfg, "A>1||defined(B)"));

}

{

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

cfg["A"] = "";

cfg["B"] = "";

ASSERT_EQUALS(true, Preprocessor::match_cfg_def(cfg, "defined(A)&&defined(B)"));

}

{

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

cfg["ABC"] = "";

ASSERT_EQUALS(false, Preprocessor::match_cfg_def(cfg, "defined(A)"));

ASSERT_EQUALS(true, Preprocessor::match_cfg_def(cfg, "!defined(A)"));

ASSERT_EQUALS(false, Preprocessor::match_cfg_def(cfg, "!defined(ABC)&&!defined(DEF)"));

ASSERT_EQUALS(true, Preprocessor::match_cfg_def(cfg, "!defined(A)&&!defined(B)"));