/*

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

* Copyright (C) 2007-2016 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 <set>

class TestPreprocessor : public TestFixture {

public:

TestPreprocessor()

: TestFixture("TestPreprocessor")

, preprocessor0(settings0, this) {

}

class OurPreprocessor : public Preprocessor {

public:

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

Settings settings;

Preprocessor p(settings);

p.replaceIfDefined(str);

return str;

}

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

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

}

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

return Preprocessor::getHeaderFileName(str);

}

};

private:

Settings settings0;

Preprocessor preprocessor0;

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

TEST_CASE(readCode5); // #7042 - C++14 digit separators

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

TEST_CASE(error1); // #error => don't extract any code

TEST_CASE(error2); // #error with extended chars

TEST_CASE(error3);

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

TEST_CASE(error5);

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_incdec); // separate ++ and -- with space when expanding such macro: '#define M(X) A-X'

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

TEST_CASE(double_include); // #5717

TEST_CASE(invalid_ifs); // #5909

TEST_CASE(garbage);

TEST_CASE(wrongPathOnUnicodeError); // see #6773

TEST_CASE(wrongPathOnErrorDirective);

}

std::string preprocessorRead(const char* code) {

errout.str("");

std::istringstream istr(code);

return preprocessor0.read(istr, "test.c");

}

void preprocess(const char* code, std::map<std::string, std::string>& actual) {

errout.str("");

std::istringstream istr(code);

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

}

void readCode1() {

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

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

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

}

void readCode2() {

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

ASSERT_EQUALS("\" \\\" \\\\ ' /* abc */ \\n\"\n;", preprocessorRead(code));

}

void readCode3() {

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

ASSERT_EQUALS("func(#errorname)", preprocessorRead(code));

}

void readCode4() {

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

ASSERT_EQUALS("char c = '\\ ';", preprocessorRead(code));

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

}

void readCode5() {

ASSERT_EQUALS("int i = 0x100000;", preprocessorRead("int i = 0x1000'00;"));

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

ASSERT_EQUALS("int i = 0x0F0FFFFF;", preprocessorRead("int i = 0x0F0F'FFFF;"));

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

}

void utf16() {

// a => a

{

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

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

std::istringstream istr(s);

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

}

{

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

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

std::istringstream istr(s);

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

}

// extended char => 0xff

{

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

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

std::istringstream istr(s);

const char expected[] = { '\xff', 0 };

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

}

{

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

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

std::istringstream istr(s);

const char expected[] = { '\xff', 0 };

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

}

// \r\n => \n

{

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

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

std::istringstream istr(s);

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

}

{

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

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

std::istringstream istr(s);

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

}

}

void removeComments() {

// #3837 - asm comments

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

" __asm\n"

" {\n"

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

" }\n"

"}\n";

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

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

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

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

// #4873

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

// #5169

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

preprocessor0.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::map<std::string, std::string> actual;

preprocess(filedata, actual);

// Compare results..

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

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

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

}

void test1() {

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

" abcdef\n"

"#else \n"

" qwerty\n"

"#endif \n";

// Preprocess => actual result..

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

preprocess(filedata, actual);

// Compare results..

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

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

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

}

void test2() {

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

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

" # else \n"

" qwerty\n"

" # endif \n";

// Preprocess => actual result..

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

preprocess(filedata, actual);

// Compare results..

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

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

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

}

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::map<std::string, std::string> actual;

preprocess(filedata, actual);

// Compare results..

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

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

}

void test4() {

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

"A\n"

"#endif\t\n"

"#ifdef ABC\n"

"A\n"

"#endif\n";

// Preprocess => actual result..

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

preprocess(filedata, actual);

// Compare results..

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

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

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

}

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::map<std::string, std::string> actual;

preprocess(filedata, actual);

// Compare results..

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

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

}

void test6() {

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

"#if ( A ) \n"

"#if A\n"

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

"#elif defined (A)\n";

// Compare results..

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

}

void test7() {

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

"A\n"

"#ifdef ABC\n"

"B\n"

"#endif\n"

"#endif\n";

// Preprocess => actual result..

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

preprocess(filedata, actual);

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

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

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

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::map<std::string, std::string> actual;

preprocess(filedata, actual);

// 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::map<std::string, std::string> actual;

preprocess(filedata, actual);

// 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::map<std::string, std::string> actual;

preprocess(filedata, actual);

// 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::map<std::string, std::string> actual;

preprocess(filedata, actual);

// 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::map<std::string, std::string> actual;

preprocess(filedata, actual);

// 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::map<std::string, std::string> actual;

preprocess(filedata, actual);

// 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::map<std::string, std::string> actual;

preprocess(filedata, actual);

}

void error1() {

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

";\n"

"#else\n"

"#error abcd\n"

"#endif\n";

// Preprocess => actual result..

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

preprocess(filedata, actual);

// 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 \xAB\n"

"#warning \xAB\n"

"123";

ASSERT_EQUALS("#error\n\n123", preprocessorRead(filedata));

}

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

errout.str("");

Settings settings;

settings.userDefines = "FOO";

settings.force = true; // No message if --force is given

Preprocessor preprocessor(settings, this);

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

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

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

}

void if0_exclude() {

const char* code = "#if 0\n"

"A\n"

"#endif\n"

"B\n";

ASSERT_EQUALS("#if 0\n\n#endif\nB\n", preprocessorRead(code));

const char* code2 = "#if (0)\n"

"A\n"

"#endif\n"

"B\n";

ASSERT_EQUALS("#if 0\n\n#endif\nB\n", preprocessorRead(code2));

}

void if0_whitespace() {

const char* code = " # if 0 \n"

"A\n"

" # endif \n"

"B\n";

ASSERT_EQUALS("#if 0\n\n#endif\nB\n", preprocessorRead(code));

}

void if0_else() {

const char* 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", preprocessorRead(code));

const char* 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", preprocessorRead(code2));

}

void if0_elif() {

const char* 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", preprocessorRead(code));

}

void if0_include_1() {

const char* code = "#if 0\n"

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

"#endif\n"

"AB\n";

ASSERT_EQUALS("#if 0\n\n#endif\nAB\n", preprocessorRead(code));

}

void if0_include_2() {

const char* 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", preprocessorRead(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::map<std::string, std::string> actual;

preprocess(filedata, actual);

// 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::map<std::string, std::string> actual;

preprocess(filedata, actual);

// 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::map<std::string, std::string> actual;

preprocess(filedata, actual);

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

ASSERT_EQUALS("\n\n\n", preprocessorRead(filedata));

}

void comments1() {

{

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

"#ifdef WIN32\n"

"#endif\n"

"*/\n";

// Preprocess => actual result..

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

preprocess(filedata, actual);

// Compare results..

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

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

}

{

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

"\x080 #ifdef WIN32\n"

"#endif\n"

"*/\n";

// Preprocess => actual result..

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

preprocess(filedata, actual);