TestCharVar() : TestFixture("TestCharVar") {}

Settings settings;

void run() override {

settings.platform(Settings::Unspecified);

settings.severity.enable(Severity::warning);

settings.severity.enable(Severity::portability);

TEST_CASE(array_index_1);

TEST_CASE(array_index_2);

TEST_CASE(bitop);

}

#define check(code) check_(code, __FILE__, __LINE__)

void check_(const char code[], const char* file, int line) {

// Clear the error buffer..

errout.str("");

// Tokenize..

Tokenizer tokenizer(&settings, this);

std::istringstream istr(code);

ASSERT_LOC(tokenizer.tokenize(istr, "test.cpp"), file, line);

// Check char variable usage..

CheckOther checkOther(&tokenizer, &settings, this);

checkOther.checkCharVariable();

}

void array_index_1() {

check("int buf[256];\n"

"void foo()\n"

"{\n"

" unsigned char ch = 0x80;\n"

" buf[ch] = 0;\n"

"}");

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

check("int buf[256];\n"

"void foo()\n"

"{\n"

" char ch = 0x80;\n"

" buf[ch] = 0;\n"

"}");

ASSERT_EQUALS("[test.cpp:5]: (portability) 'char' type used as array index.\n", errout.str());

check("int buf[256];\n"

"void foo()\n"

"{\n"

" char ch = 0;\n"

" buf[ch] = 0;\n"

"}");

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

check("int buf[256];\n"

"void foo()\n"

"{\n"

" signed char ch = 0;\n"

" buf[ch] = 0;\n"

"}");

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

check("int buf[256];\n"

"void foo()\n"

"{\n"

" char ch = 0x80;\n"

" buf[ch] = 0;\n"

"}");

ASSERT_EQUALS("[test.cpp:5]: (portability) 'char' type used as array index.\n", errout.str());

check("int buf[256];\n"

"void foo(signed char ch)\n"

"{\n"

" buf[ch] = 0;\n"

"}");

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

check("int buf[256];\n"

"void foo(char ch)\n"

"{\n"

" buf[ch] = 0;\n"

"}");

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

check("void foo(char* buf)\n"

"{\n"

" char ch = 0x80;"

" buf[ch] = 0;\n"

"}");

ASSERT_EQUALS("[test.cpp:3]: (portability) 'char' type used as array index.\n", errout.str());

check("void foo(char* buf)\n"

"{\n"

" char ch = 0;"

" buf[ch] = 0;\n"

"}");

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

check("void foo(char* buf)\n"

"{\n"

" buf['A'] = 0;\n"

"}");

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

check("void foo(char* buf, char ch)\n"

"{\n"

" buf[ch] = 0;\n"

"}");

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

check("int flags[256];\n"

"void foo(const char* str)\n"

"{\n"

" flags[*str] = 0;\n"

"}");

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

check("int flags[256];\n"

"void foo(const char* str)\n"

"{\n"

" flags[(unsigned char)*str] = 0;\n"

"}");

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

check("void foo(const char str[])\n"

"{\n"

" map[str] = 0;\n"

"}");

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

}

void array_index_2() {

// #3282 - False positive

check("void foo(char i);\n"

"void bar(int i) {\n"

" const char *s = \"abcde\";\n"

" foo(s[i]);\n"

"}");

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

}

void bitop() {

check("void foo(int *result) {\n"

" signed char ch = -1;\n"

" *result = a | ch;\n"

"}");

ASSERT_EQUALS("[test.cpp:3]: (warning) When using 'char' variables in bit operations, sign extension can generate unexpected results.\n", errout.str());

check("void foo(int *result) {\n"

" unsigned char ch = -1;\n"

" *result = a | ch;\n"

"}");

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

check("void foo(char *result) {\n"

" signed char ch = -1;\n"

" *result = a | ch;\n"

"}");

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

// 0x03 & ..

check("void foo(int *result) {\n"

" signed char ch = -1;\n"

" *result = 0x03 | ch;\n"

"}");

ASSERT_EQUALS("[test.cpp:3]: (warning) When using 'char' variables in bit operations, sign extension can generate unexpected results.\n", errout.str());

check("void foo(int *result) {\n"

" signed char ch = -1;\n"

" *result = 0x03 & ch;\n"

"}");

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

}