/*

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

* Copyright (C) 2007-2026 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/>.

*/

#include "checkio.h"

#include "errortypes.h"

#include "fixture.h"

#include "helpers.h"

#include "platform.h"

#include "settings.h"

#include <cstddef>

#include <string>

class TestIO : public TestFixture {

public:

TestIO() : TestFixture("TestIO") {}

private:

const Settings settings = settingsBuilder().library("std.cfg").library("windows.cfg").library("qt.cfg").build();

/*const*/ Settings settings1 = settingsBuilder().library("std.cfg").library("windows.cfg").library("qt.cfg").severity(Severity::warning).severity(Severity::style).build();

void run() override {

mNewTemplate = true;

TEST_CASE(coutCerrMisusage);

TEST_CASE(wrongMode_simple);

TEST_CASE(wrongMode_complex);

TEST_CASE(useClosedFile);

TEST_CASE(fileIOwithoutPositioning);

TEST_CASE(seekOnAppendedFile);

TEST_CASE(fflushOnInputStream);

TEST_CASE(incompatibleFileOpen);

TEST_CASE(testWrongfeofUsage); // #958

TEST_CASE(testScanf1); // Scanf without field limiters

TEST_CASE(testScanf2);

TEST_CASE(testScanf3); // #3494

TEST_CASE(testScanf4); // #ticket 2553

TEST_CASE(testScanf5); // #10632

mNewTemplate = false;

TEST_CASE(testScanfArgument);

TEST_CASE(testPrintfArgument);

TEST_CASE(testPrintfArgumentVariables);

mNewTemplate = true;

TEST_CASE(testPosixPrintfScanfParameterPosition); // #4900

TEST_CASE(testMicrosoftPrintfArgument); // ticket #4902

TEST_CASE(testMicrosoftScanfArgument);

TEST_CASE(testMicrosoftCStringFormatArguments); // ticket #4920

TEST_CASE(testMicrosoftSecurePrintfArgument);

TEST_CASE(testMicrosoftSecureScanfArgument);

TEST_CASE(testQStringFormatArguments);

TEST_CASE(testTernary); // ticket #6182

TEST_CASE(testUnsignedConst); // ticket #6132

TEST_CASE(testAstType); // #7014

TEST_CASE(testPrintf0WithSuffix); // ticket #7069

TEST_CASE(testReturnValueTypeStdLib);

TEST_CASE(testPrintfTypeAlias1);

TEST_CASE(testPrintfAuto); // #8992

TEST_CASE(testPrintfParenthesis); // #8489

TEST_CASE(testStdDistance); // #10304

TEST_CASE(testParameterPack); // #11289

TEST_CASE(testDefaultSignInt); // #13363

TEST_CASE(testPrintfWithGeneric); // #13592

}

struct CheckOptions

{

bool inconclusive = false;

bool portability = false;

Platform::Type platform = Platform::Type::Unspecified;

char defaultSign = '\0';

bool onlyFormatStr = false;

bool cpp = true;

};

#define check(...) check_(__FILE__, __LINE__, __VA_ARGS__)

template<size_t size>

void check_(const char* file, int line, const char (&code)[size], const CheckOptions& options = make_default_obj()) {

// TODO: using dedicated Settings (i.e. copying it) object causes major slowdown

settings1.severity.setEnabled(Severity::portability, options.portability);

settings1.certainty.setEnabled(Certainty::inconclusive, options.inconclusive);

PLATFORM(settings1.platform, options.platform);

settings1.platform.defaultSign = options.defaultSign;

// Tokenize..

SimpleTokenizer tokenizer(settings1, *this, options.cpp);

ASSERT_LOC(tokenizer.tokenize(code), file, line);

// Check..

if (options.onlyFormatStr) {

CheckIOImpl checkIO(&tokenizer, settings1, *this);

checkIO.checkWrongPrintfScanfArguments();

return;

}

CheckIO check;

runChecks(check, tokenizer, *this);

}

void coutCerrMisusage() {

check(

"void foo() {\n"

" std::cout << std::cout;\n"

"}");

ASSERT_EQUALS("[test.cpp:2:3]: (error) Invalid usage of output stream: '<< std::cout'. [coutCerrMisusage]\n", errout_str());

check(

"void foo() {\n"

" std::cout << (std::cout);\n"

"}");

ASSERT_EQUALS("[test.cpp:2:3]: (error) Invalid usage of output stream: '<< std::cout'. [coutCerrMisusage]\n", errout_str());

check(

"void foo() {\n"

" std::cout << \"xyz\" << std::cout;\n"

"}");

ASSERT_EQUALS("[test.cpp:2:3]: (error) Invalid usage of output stream: '<< std::cout'. [coutCerrMisusage]\n", errout_str());

check(

"void foo(int i) {\n"

" std::cout << i << std::cerr;\n"

"}");

ASSERT_EQUALS("[test.cpp:2:3]: (error) Invalid usage of output stream: '<< std::cerr'. [coutCerrMisusage]\n", errout_str());

check(

"void foo() {\n"

" std::cout << \"xyz\";\n"

" std::cout << \"xyz\";\n"

"}");

ASSERT_EQUALS("", errout_str());

check(

"void foo() {\n"

" std::cout << std::cout.good();\n"

"}");

ASSERT_EQUALS("", errout_str());

check(

"void foo() {\n"

" unknownObject << std::cout;\n"

"}");

ASSERT_EQUALS("", errout_str());

check(

"void foo() {\n"

" MACRO(std::cout <<, << std::cout)\n"

"}");

ASSERT_EQUALS("", errout_str());

}

void wrongMode_simple() {

// Read mode

check("void foo(FILE*& f) {\n"

" f = fopen(name, \"r\");\n"

" fread(buffer, 5, 6, f);\n"

" rewind(f);\n"

" fwrite(buffer, 5, 6, f);\n"

"}");

ASSERT_EQUALS("[test.cpp:5:5]: (error) Write operation on a file that was opened only for reading. [writeReadOnlyFile]\n", errout_str());

check("void foo(FILE*& f) {\n"

" f = _wfopen(name, L\"r\");\n"

" fread(buffer, 5, 6, f);\n"

" rewind(f);\n"

" fwrite(buffer, 5, 6, f);\n"

"}", dinit(CheckOptions, $.platform = Platform::Type::Win32W));

ASSERT_EQUALS("[test.cpp:5:5]: (error) Write operation on a file that was opened only for reading. [writeReadOnlyFile]\n", errout_str());

check("void foo(FILE*& f) {\n"

" f = _tfopen(name, _T(\"r\"));\n"

" fread(buffer, 5, 6, f);\n"

" rewind(f);\n"

" fwrite(buffer, 5, 6, f);\n"

"}", dinit(CheckOptions, $.platform = Platform::Type::Win32A));

ASSERT_EQUALS("[test.cpp:5:5]: (error) Write operation on a file that was opened only for reading. [writeReadOnlyFile]\n", errout_str());

check("void foo(FILE*& f) {\n"

" f = _tfopen(name, _T(\"r\"));\n"

" fread(buffer, 5, 6, f);\n"

" rewind(f);\n"

" fwrite(buffer, 5, 6, f);\n"

"}", dinit(CheckOptions, $.platform = Platform::Type::Win32W));

ASSERT_EQUALS("[test.cpp:5:5]: (error) Write operation on a file that was opened only for reading. [writeReadOnlyFile]\n", errout_str());

check("void foo(FILE*& f) {\n"

" _wfopen_s(&f, name, L\"r\");\n"

" fread(buffer, 5, 6, f);\n"

" rewind(f);\n"

" fwrite(buffer, 5, 6, f);\n"

"}", dinit(CheckOptions, $.platform = Platform::Type::Win32W));

ASSERT_EQUALS("[test.cpp:5:5]: (error) Write operation on a file that was opened only for reading. [writeReadOnlyFile]\n", errout_str());

check("void foo(FILE*& f) {\n"

" _tfopen_s(&f, name, _T(\"r\"));\n"

" fread(buffer, 5, 6, f);\n"

" rewind(f);\n"

" fwrite(buffer, 5, 6, f);\n"

"}", dinit(CheckOptions, $.platform = Platform::Type::Win32A));

ASSERT_EQUALS("[test.cpp:5:5]: (error) Write operation on a file that was opened only for reading. [writeReadOnlyFile]\n", errout_str());

check("void foo(FILE*& f) {\n"

" _tfopen_s(&f, name, _T(\"r\"));\n"

" fread(buffer, 5, 6, f);\n"

" rewind(f);\n"

" fwrite(buffer, 5, 6, f);\n"

"}", dinit(CheckOptions, $.platform = Platform::Type::Win32W));

ASSERT_EQUALS("[test.cpp:5:5]: (error) Write operation on a file that was opened only for reading. [writeReadOnlyFile]\n", errout_str());

check("void foo(FILE*& f) {\n"

" f = fopen(name, \"r+\");\n"

" fwrite(buffer, 5, 6, f);\n"

"}");

ASSERT_EQUALS("", errout_str());

check("void foo(FILE*& f) {\n"

" f = _wfopen(name, L\"r+\");\n"

" fwrite(buffer, 5, 6, f);\n"

"}", dinit(CheckOptions, $.platform = Platform::Type::Win32W));

ASSERT_EQUALS("", errout_str());

check("void foo(FILE*& f) {\n"

" f = _tfopen(name, _T(\"r+\"));\n"

" fwrite(buffer, 5, 6, f);\n"

"}", dinit(CheckOptions, $.platform = Platform::Type::Win32A));

ASSERT_EQUALS("", errout_str());

check("void foo(FILE*& f) {\n"

" f = _tfopen(name, _T(\"r+\"));\n"

" fwrite(buffer, 5, 6, f);\n"

"}", dinit(CheckOptions, $.platform = Platform::Type::Win32W));

ASSERT_EQUALS("", errout_str());

check("void foo(FILE*& f) {\n"

" _wfopen_s(&f, name, L\"r+\");\n"

" fwrite(buffer, 5, 6, f);\n"

"}", dinit(CheckOptions, $.platform = Platform::Type::Win32W));

ASSERT_EQUALS("", errout_str());

check("void foo(FILE*& f) {\n"

" _tfopen_s(&f, name, _T(\"r+\"));\n"

" fwrite(buffer, 5, 6, f);\n"

"}", dinit(CheckOptions, $.platform = Platform::Type::Win32A));

ASSERT_EQUALS("", errout_str());

check("void foo(FILE*& f) {\n"

" _tfopen_s(&f, name, _T(\"r+\"));\n"

" fwrite(buffer, 5, 6, f);\n"

"}", dinit(CheckOptions, $.platform = Platform::Type::Win32W));

ASSERT_EQUALS("", errout_str());

check("void foo(FILE*& f) {\n"

" f = tmpfile();\n"

" fwrite(buffer, 5, 6, f);\n"

"}", dinit(CheckOptions, $.platform = Platform::Type::Win32W));

ASSERT_EQUALS("", errout_str());

// Write mode

check("void foo(FILE*& f) {\n"

" f = fopen(name, \"w\");\n"

" fwrite(buffer, 5, 6, f);\n"

" rewind(f);\n"

" fread(buffer, 5, 6, f);\n"

"}");

ASSERT_EQUALS("[test.cpp:5:5]: (error) Read operation on a file that was opened only for writing. [readWriteOnlyFile]\n", errout_str());

check("void foo(FILE*& f) {\n"

" f = fopen(name, \"w+\");\n"

" fread(buffer, 5, 6, f);\n"

"}");

ASSERT_EQUALS("", errout_str());

check("void foo(FILE*& f) {\n"

" f = tmpfile();\n"

" fread(buffer, 5, 6, f);\n"

"}");

ASSERT_EQUALS("", errout_str());

// Append mode

check("void foo(FILE*& f) {\n"

" f = fopen(name, \"a\");\n"

" fwrite(buffer, 5, 6, f);\n"

" rewind(f);\n"

" fread(buffer, 5, 6, f);\n"

"}");

ASSERT_EQUALS("[test.cpp:4:5]: (warning) Repositioning operation performed on a file opened in append mode has no effect. [seekOnAppendedFile]\n"

"[test.cpp:5:5]: (error) Read operation on a file that was opened only for writing. [readWriteOnlyFile]\n", errout_str());

check("void foo(FILE*& f) {\n"

" f = fopen(name, \"a+\");\n"

" fread(buffer, 5, 6, f);\n"

"}");

ASSERT_EQUALS("", errout_str());

// Variable declared locally

check("void foo() {\n"

" FILE* f = fopen(name, \"r\");\n"

" fwrite(buffer, 5, 6, f);\n"

" fclose(f);\n"

"}");

ASSERT_EQUALS("[test.cpp:3:5]: (error) Write operation on a file that was opened only for reading. [writeReadOnlyFile]\n", errout_str());

// Call unknown function

check("void foo(FILE*& f) {\n"

" f = fopen(name, \"a\");\n"

" fwrite(buffer, 5, 6, f);\n"

" bar(f);\n"

" fread(buffer, 5, 6, f);\n"

"}");

ASSERT_EQUALS("", errout_str());

// freopen and tmpfile

check("void foo(FILE*& f) {\n"

" f = freopen(name, \"r\", f);\n"

" fwrite(buffer, 5, 6, f);\n"

"}");

ASSERT_EQUALS("[test.cpp:3:5]: (error) Write operation on a file that was opened only for reading. [writeReadOnlyFile]\n", errout_str());

check("void foo(FILE*& f) {\n"

" f = _wfreopen(name, L\"r\", f);\n"

" fwrite(buffer, 5, 6, f);\n"

"}", dinit(CheckOptions, $.platform = Platform::Type::Win32W));

ASSERT_EQUALS("[test.cpp:3:5]: (error) Write operation on a file that was opened only for reading. [writeReadOnlyFile]\n", errout_str());

check("void foo(FILE*& f) {\n"

" f = _tfreopen(name, _T(\"r\"), f);\n"

" fwrite(buffer, 5, 6, f);\n"

"}", dinit(CheckOptions, $.platform = Platform::Type::Win32A));

ASSERT_EQUALS("[test.cpp:3:5]: (error) Write operation on a file that was opened only for reading. [writeReadOnlyFile]\n", errout_str());

check("void foo(FILE*& f) {\n"

" f = _tfreopen(name, _T(\"r\"), f);\n"

" fwrite(buffer, 5, 6, f);\n"

"}", dinit(CheckOptions, $.platform = Platform::Type::Win32W));

ASSERT_EQUALS("[test.cpp:3:5]: (error) Write operation on a file that was opened only for reading. [writeReadOnlyFile]\n", errout_str());

check("void foo(FILE*& f) {\n"

" f = _wfreopen_s(&f, name, L\"r\", f);\n"

" fwrite(buffer, 5, 6, f);\n"

"}", dinit(CheckOptions, $.platform = Platform::Type::Win32W));

ASSERT_EQUALS("[test.cpp:3:5]: (error) Write operation on a file that was opened only for reading. [writeReadOnlyFile]\n", errout_str());

check("void foo(FILE*& f) {\n"

" f = _tfreopen_s(&f, name, _T(\"r\"), f);\n"

" fwrite(buffer, 5, 6, f);\n"

"}", dinit(CheckOptions, $.platform = Platform::Type::Win32A));

ASSERT_EQUALS("[test.cpp:3:5]: (error) Write operation on a file that was opened only for reading. [writeReadOnlyFile]\n", errout_str());

check("void foo(FILE*& f) {\n"

" f = _tfreopen_s(&f, name, _T(\"r\"), f);\n"

" fwrite(buffer, 5, 6, f);\n"

"}", dinit(CheckOptions, $.platform = Platform::Type::Win32W));

ASSERT_EQUALS("[test.cpp:3:5]: (error) Write operation on a file that was opened only for reading. [writeReadOnlyFile]\n", errout_str());

// Crash tests

check("void foo(FILE*& f) {\n"

" f = fopen(name, mode);\n" // No assertion failure (#3830)

" fwrite(buffer, 5, 6, f);\n"

"}");

ASSERT_EQUALS("", errout_str());

check("void fopen(std::string const &filepath, std::string const &mode);"); // #3832

}

void wrongMode_complex() {

check("void foo(FILE* f) {\n"

" if(a) f = fopen(name, \"w\");\n"

" else f = fopen(name, \"r\");\n"

" if(a) fwrite(buffer, 5, 6, f);\n"

" else fread(buffer, 5, 6, f);\n"

"}");

ASSERT_EQUALS("", errout_str());

check("void foo() {\n"

" FILE* f;\n"

" if(a) f = fopen(name, \"w\");\n"

" else f = fopen(name, \"r\");\n"

" if(a) fwrite(buffer, 5, 6, f);\n"

" else fread(buffer, 5, 6, f);\n"

"}");

ASSERT_EQUALS("", errout_str());

check("void foo() {\n"

" FILE* f = fopen(name, \"w\");\n"

" if(a) fwrite(buffer, 5, 6, f);\n"

" else fread(buffer, 5, 6, f);\n"

"}");

ASSERT_EQUALS("[test.cpp:4:11]: (error) Read operation on a file that was opened only for writing. [readWriteOnlyFile]\n", errout_str());

}

void useClosedFile() {

check("void foo(FILE*& f) {\n"

" fclose(f);\n"

" fwrite(buffer, 5, 6, f);\n"

" clearerr(f);\n"

" fread(buffer, 5, 6, f);\n"

" ungetc('a', f);\n"

" ungetwc(L'a', f);\n"

" rewind(f);\n"

"}");

ASSERT_EQUALS("[test.cpp:3:5]: (error) Used file that is not opened. [useClosedFile]\n"

"[test.cpp:4:5]: (error) Used file that is not opened. [useClosedFile]\n"

"[test.cpp:5:5]: (error) Used file that is not opened. [useClosedFile]\n"

"[test.cpp:6:5]: (error) Used file that is not opened. [useClosedFile]\n"

"[test.cpp:7:5]: (error) Used file that is not opened. [useClosedFile]\n"

"[test.cpp:8:5]: (error) Used file that is not opened. [useClosedFile]\n", errout_str());

check("void foo(FILE*& f) {\n"

" if(!ferror(f)) {\n"

" fclose(f);\n"

" return;"

" }\n"

" fwrite(buffer, 5, 6, f);\n"

"}");

ASSERT_EQUALS("", errout_str());

check("void foo(FILE*& f) {\n"

" fclose(f);\n"

" f = fopen(name, \"r\");\n"

" fread(buffer, 5, 6, f);\n"

"}");

ASSERT_EQUALS("", errout_str());

check("void foo(FILE*& f) {\n"

" f = fopen(name, \"r\");\n"

" f = g;\n"

" fwrite(buffer, 5, 6, f);\n"

"}");

ASSERT_EQUALS("", errout_str());

check("void foo() {\n"

" FILE* f;\n"

" fwrite(buffer, 5, 6, f);\n"

"}");

ASSERT_EQUALS("[test.cpp:3:5]: (error) Used file that is not opened. [useClosedFile]\n", errout_str());

check("void foo() {\n"

" FILE* f(stdout);\n"

" fwrite(buffer, 5, 6, f);\n"

"}");

ASSERT_EQUALS("", errout_str());

check("void foo() {\n" // #3965

" FILE* f[3];\n"

" f[0] = fopen(name, mode);\n"

" fclose(f[0]);\n"

"}");

ASSERT_EQUALS("", errout_str());

// #4368: multiple functions

check("static FILE *fp = NULL;\n"

"\n"

"void close()\n"

"{\n"

" fclose(fp);\n"

"}\n"

"\n"

"void dump()\n"

"{\n"

" if (fp == NULL) return;\n"

" fprintf(fp, \"Here's the output.\\n\");\n"

"}\n"

"\n"

"int main()\n"

"{\n"

" fp = fopen(\"test.txt\", \"w\");\n"

" dump();\n"

" close();\n"

" return 0;\n"

"}");

ASSERT_EQUALS("", errout_str());

check("static FILE *fp = NULL;\n"

"\n"

"void close()\n"

"{\n"

" fclose(fp);\n"

"}\n"

"\n"

"void dump()\n"

"{\n"

" fclose(fp);\n"

" fprintf(fp, \"Here's the output.\\n\");\n"

"}");

ASSERT_EQUALS("[test.cpp:11:3]: (error) Used file that is not opened. [useClosedFile]\n", errout_str());

// #4466

check("void chdcd_parse_nero(FILE *infile) {\n"

" switch (mode) {\n"

" case 0x0300:\n"

" fclose(infile);\n"

" return;\n"

" case 0x0500:\n"

" fclose(infile);\n"

" return;\n"

" }\n"

"}");

ASSERT_EQUALS("", errout_str());

check("void chdcd_parse_nero(FILE *infile) {\n"

" switch (mode) {\n"

" case 0x0300:\n"

" fclose(infile);\n"

" exit(0);\n"

" case 0x0500:\n"

" fclose(infile);\n"

" return;\n"

" }\n"

"}");

ASSERT_EQUALS("", errout_str());

// #4649

check("void foo() {\n"

" struct {FILE *f1; FILE *f2;} a;\n"

" a.f1 = fopen(name,mode);\n"

" a.f2 = fopen(name,mode);\n"

" fclose(a.f1);\n"

" fclose(a.f2);\n"

"}");

ASSERT_EQUALS("", errout_str());

// #1473

check("void foo() {\n"

" FILE *a = fopen(\"aa\", \"r\");\n"

" while (fclose(a)) {}\n"

"}");

ASSERT_EQUALS("[test.cpp:3:12]: (warning) fclose() used as loop condition may skip loop body or double-close file handle. [fcloseInLoopCondition]\n", errout_str());

check("void foo() {\n"

" FILE *a = fopen(\"aa\", \"r\");\n"

" while (fclose(a)) {\n"

" break;\n"

" }\n"

"}");

ASSERT_EQUALS("", errout_str());

check("void foo() {\n"

" FILE *a = fopen(\"aa\", \"r\");\n"

" while (fclose(a)) {\n"

" a = fopen(\"aa\", \"r\");\n"

" }\n"

"}");

ASSERT_EQUALS("", errout_str());

check("void foo() {\n"

" FILE *a = fopen(\"aa\", \"r\");\n"

" do {} while (fclose(a));\n"

"}");

ASSERT_EQUALS("[test.cpp:3:18]: (warning) fclose() used as loop condition may skip loop body or double-close file handle. [fcloseInLoopCondition]\n", errout_str());

// #6823

check("void foo() {\n"

" FILE f[2];\n"

" f[0] = fopen(\"1\", \"w\");\n"

" f[1] = fopen(\"2\", \"w\");\n"

" fclose(f[0]);\n"

" fclose(f[1]);\n"

"}");

ASSERT_EQUALS("", errout_str());

// #12236

check("void f() {\n"

" FILE* f = fopen(\"abc\", \"r\");\n"

" decltype(fclose(f)) y;\n"

" y = fclose(f);\n"

"}\n");

ASSERT_EQUALS("", errout_str());

}

void fileIOwithoutPositioning() {

check("void foo(FILE* f) {\n"

" fwrite(buffer, 5, 6, f);\n"

" fread(buffer, 5, 6, f);\n"

"}");

ASSERT_EQUALS("[test.cpp:3:5]: (error) Read and write operations without a call to a positioning function (fseek, fsetpos or rewind) or fflush in between result in undefined behaviour. [IOWithoutPositioning]\n", errout_str());

check("void foo(FILE* f) {\n"

" fread(buffer, 5, 6, f);\n"

" fwrite(buffer, 5, 6, f);\n"

"}");

ASSERT_EQUALS("[test.cpp:3:5]: (error) Read and write operations without a call to a positioning function (fseek, fsetpos or rewind) or fflush in between result in undefined behaviour. [IOWithoutPositioning]\n", errout_str());

check("void foo(FILE* f, bool read) {\n"

" if(read)\n"

" fread(buffer, 5, 6, f);\n"

" else\n"

" fwrite(buffer, 5, 6, f);\n"

"}");

ASSERT_EQUALS("", errout_str());

check("void foo(FILE* f) {\n"

" fread(buffer, 5, 6, f);\n"

" fflush(f);\n"

" fwrite(buffer, 5, 6, f);\n"

"}");

ASSERT_EQUALS("", errout_str());

check("void foo(FILE* f) {\n"

" fread(buffer, 5, 6, f);\n"

" rewind(f);\n"

" fwrite(buffer, 5, 6, f);\n"

"}");

ASSERT_EQUALS("", errout_str());

check("void foo(FILE* f) {\n"

" fread(buffer, 5, 6, f);\n"

" fsetpos(f, pos);\n"

" fwrite(buffer, 5, 6, f);\n"

"}");

ASSERT_EQUALS("", errout_str());

check("void foo(FILE* f) {\n"

" fread(buffer, 5, 6, f);\n"

" fseek(f, 0, SEEK_SET);\n"

" fwrite(buffer, 5, 6, f);\n"

"}");

ASSERT_EQUALS("", errout_str());

check("void foo(FILE* f) {\n"

" fread(buffer, 5, 6, f);\n"

" long pos = ftell(f);\n"

" fwrite(buffer, 5, 6, f);\n"

"}");

ASSERT_EQUALS("[test.cpp:4:5]: (error) Read and write operations without a call to a positioning function (fseek, fsetpos or rewind) or fflush in between result in undefined behaviour. [IOWithoutPositioning]\n", errout_str());

// #6452 - member functions

check("class FileStream {\n"

" void insert(const ByteVector &data, ulong start);\n"

" void seek(long offset, Position p);\n"

" FileStreamPrivate *d;\n"

"};\n"

"void FileStream::insert(const ByteVector &data, ulong start) {\n"

" int bytesRead = fread(aboutToOverwrite.data(), 1, bufferLength, d->file);\n"

" seek(writePosition);\n"

" fwrite(buffer.data(), sizeof(char), buffer.size(), d->file);\n"

"}");

ASSERT_EQUALS("", errout_str());

check("class FileStream {\n"

" void insert(const ByteVector &data, ulong start);\n"

" FileStreamPrivate *d;\n"

"};\n"

"void FileStream::insert(const ByteVector &data, ulong start) {\n"

" int bytesRead = fread(aboutToOverwrite.data(), 1, bufferLength, d->file);\n"

" unknown(writePosition);\n"

" fwrite(buffer.data(), sizeof(char), buffer.size(), d->file);\n"

"}");

ASSERT_EQUALS("", errout_str());

check("class FileStream {\n"

" void insert(const ByteVector &data, ulong start);\n"

" FileStreamPrivate *d;\n"

"};\n"

"void known(int);\n"

"void FileStream::insert(const ByteVector &data, ulong start) {\n"

" int bytesRead = fread(aboutToOverwrite.data(), 1, bufferLength, d->file);\n"

" known(writePosition);\n"

" fwrite(buffer.data(), sizeof(char), buffer.size(), d->file);\n"

"}");

ASSERT_EQUALS("[test.cpp:9:5]: (error) Read and write operations without a call to a positioning function (fseek, fsetpos or rewind) or fflush in between result in undefined behaviour. [IOWithoutPositioning]\n", errout_str());

check("class FileStream {\n"

" void insert(const ByteVector &data, ulong start);\n"

" FileStreamPrivate *d;\n"

"};\n"

"void known(int);\n"

"void FileStream::insert(const ByteVector &data, ulong start) {\n"

" int bytesRead = fread(X::data(), 1, bufferLength, d->file);\n"

" known(writePosition);\n"

" fwrite(X::data(), sizeof(char), buffer.size(), d->file);\n"

"}");

ASSERT_EQUALS("[test.cpp:9:5]: (error) Read and write operations without a call to a positioning function (fseek, fsetpos or rewind) or fflush in between result in undefined behaviour. [IOWithoutPositioning]\n", errout_str());

}

void seekOnAppendedFile() {

check("void foo() {\n"

" FILE* f = fopen(\"\", \"a+\");\n"

" fseek(f, 0, SEEK_SET);\n"

"}");

ASSERT_EQUALS("", errout_str());

check("void foo() {\n"

" FILE* f = fopen(\"\", \"w\");\n"

" fseek(f, 0, SEEK_SET);\n"

"}");

ASSERT_EQUALS("", errout_str());

check("void foo() {\n"

" FILE* f = fopen(\"\", \"a\");\n"

" fseek(f, 0, SEEK_SET);\n"

"}");

ASSERT_EQUALS("[test.cpp:3:5]: (warning) Repositioning operation performed on a file opened in append mode has no effect. [seekOnAppendedFile]\n", errout_str());

check("void foo() {\n"

" FILE* f = fopen(\"\", \"a\");\n"

" fflush(f);\n"

"}");

ASSERT_EQUALS("", errout_str()); // #5578

check("void foo() {\n"

" FILE* f = fopen(\"\", \"a\");\n"

" fclose(f);\n"

" f = fopen(\"\", \"r\");\n"

" fseek(f, 0, SEEK_SET);\n"

"}");

ASSERT_EQUALS("", errout_str()); // #6566

}

void fflushOnInputStream() {

check("void foo()\n"

"{\n"

" fflush(stdin);\n"

"}", dinit(CheckOptions, $.portability = true));

ASSERT_EQUALS("[test.cpp:3:5]: (portability) fflush() called on input stream 'stdin' may result in undefined behaviour on non-linux systems. [fflushOnInputStream]\n", errout_str());

check("void foo()\n"

"{\n"

" fflush(stdout);\n"

"}", dinit(CheckOptions, $.portability = true));

ASSERT_EQUALS("", errout_str());

check("void foo(FILE*& f) {\n"

" f = fopen(path, \"r\");\n"

" fflush(f);\n"

"}", dinit(CheckOptions, $.portability = true));

ASSERT_EQUALS("[test.cpp:3:5]: (portability) fflush() called on input stream 'f' may result in undefined behaviour on non-linux systems. [fflushOnInputStream]\n", errout_str());

check("void foo(FILE*& f) {\n"

" f = fopen(path, \"w\");\n"

" fflush(f);\n"

"}", dinit(CheckOptions, $.portability = true));

ASSERT_EQUALS("", errout_str());

check("void foo(FILE*& f) {\n"

" fflush(f);\n"

"}", dinit(CheckOptions, $.portability = true));

ASSERT_EQUALS("", errout_str());

}

void incompatibleFileOpen() {

check("void foo() {\n"

" FILE *f1 = fopen(\"tmp\", \"wt\");\n"

" FILE *f2 = fopen(\"tmp\", \"rt\");\n"

"}");

ASSERT_EQUALS("[test.cpp:3:16]: (warning) The file '\"tmp\"' is opened for read and write access at the same time on different streams [incompatibleFileOpen]\n", errout_str());

}

void testWrongfeofUsage() { // ticket #958

check("void foo(FILE * fp) {\n"

" while (!feof(fp)) \n"

" {\n"

" char line[100];\n"

" fgets(line, sizeof(line), fp);\n"

" dostuff(line);\n"

" }\n"

"}");

ASSERT_EQUALS("[test.cpp:2:10]: (warning) Using feof() as a loop condition causes the last line to be processed twice. [wrongfeofUsage]\n", errout_str());

check("int foo(FILE *fp) {\n"

" char line[100];\n"

" while (fgets(line, sizeof(line), fp)) {}\n"

" if (!feof(fp))\n"

" return 1;\n"

" return 0;\n"

"}");

ASSERT_EQUALS("", errout_str());

check("void foo(FILE *fp){\n"

" char line[100];\n"

" fgets(line, sizeof(line), fp);\n"

" while (!feof(fp)){\n"

" dostuff(line);\n"

" fgets(line, sizeof(line), fp);"

" }\n"

"}");

ASSERT_EQUALS("", errout_str());

check("void foo(FILE *fp) {\n"

" char line[100];\n"

" do {\n"

" fgets(line, sizeof(line), fp);\n"

" dostuff(line);\n"

" } while (!feof(fp));\n"

"}");

ASSERT_EQUALS("[test.cpp:6:12]: (warning) Using feof() as a loop condition causes the last line to be processed twice. [wrongfeofUsage]\n", errout_str());

check("void foo(FILE *fp) {\n"

" char line[100];\n"

" do {\n"

" dostuff(line);\n"

" fgets(line, sizeof(line), fp);\n"

" } while (!feof(fp));\n"

"}");

ASSERT_EQUALS("", errout_str());

}

void testScanf1() {

check("void foo() {\n"

" int a, b;\n"

" FILE *file = fopen(\"test\", \"r\");\n"

" a = fscanf(file, \"aa %s\", bar);\n"

" b = scanf(\"aa %S\", bar);\n"

" b = scanf(\"aa %ls\", bar);\n"

" sscanf(foo, \"%[^~]\", bar);\n"

" scanf(\"%dx%s\", &b, bar);\n"

" fclose(file);\n"

"}");

ASSERT_EQUALS("[test.cpp:4:9]: (warning) fscanf() without field width limits can crash with huge input data. [invalidscanf]\n"

"[test.cpp:5:9]: (warning) scanf() without field width limits can crash with huge input data. [invalidscanf]\n"

"[test.cpp:6:9]: (warning) scanf() without field width limits can crash with huge input data. [invalidscanf]\n"

"[test.cpp:7:5]: (warning) sscanf() without field width limits can crash with huge input data. [invalidscanf]\n"

"[test.cpp:8:5]: (warning) scanf() without field width limits can crash with huge input data. [invalidscanf]\n", errout_str());

}

void testScanf2() {

check("void foo() {\n"

" scanf(\"%5s\", bar);\n" // Width specifier given

" scanf(\"%5[^~]\", bar);\n" // Width specifier given

" scanf(\"aa%%s\", bar);\n" // No %s

" scanf(\"aa%d\", &a);\n" // No %s

" scanf(\"aa%ld\", &a);\n" // No %s

" scanf(\"%*[^~]\");\n" // Ignore input

"}");

ASSERT_EQUALS("[test.cpp:4:5]: (warning) scanf format string requires 0 parameters but 1 is given. [wrongPrintfScanfArgNum]\n", errout_str());

}

void testScanf3() { // ticket #3494

check("void f() {\n"

" char str[8];\n"

" scanf(\"%7c\", str);\n"

" scanf(\"%8c\", str);\n"

" scanf(\"%9c\", str);\n"

"}");

ASSERT_EQUALS("[test.cpp:5:3]: (error) Width 9 given in format string (no. 1) is larger than destination buffer 'str[8]', use %8c to prevent overflowing it. [invalidScanfFormatWidth]\n", errout_str());

}

void testScanf4() { // ticket #2553

check("void f()\n"

"{\n"

" char str [8];\n"

" scanf (\"%70s\",str);\n"

"}");

ASSERT_EQUALS("[test.cpp:4:3]: (error) Width 70 given in format string (no. 1) is larger than destination buffer 'str[8]', use %7s to prevent overflowing it. [invalidScanfFormatWidth]\n", errout_str());

}

void testScanf5() { // #10632

check("char s1[42], s2[42];\n"

"void test() {\n"

" scanf(\"%42s%42[a-z]\", s1, s2);\n"

"}");

ASSERT_EQUALS("[test.cpp:3:5]: (error) Width 42 given in format string (no. 1) is larger than destination buffer 's1[42]', use %41s to prevent overflowing it. [invalidScanfFormatWidth]\n"

"[test.cpp:3:5]: (error) Width 42 given in format string (no. 2) is larger than destination buffer 's2[42]', use %41[a-z] to prevent overflowing it. [invalidScanfFormatWidth]\n", errout_str());

}

#define TEST_SCANF_CODE(format, type) \

"void f(){" type " x; scanf(\"" format "\", &x);}"

#define TEST_SCANF_ERR(format, formatStr, type) \

"[test.c:1]: (warning) " format " in format string (no. 1) requires '" formatStr " *' but the argument type is '" type " *'.\n"

#define TEST_SCANF_ERR_AKA_(file, format, formatStr, type, akaType) \

"[" file ":1]: (portability) " format " in format string (no. 1) requires '" formatStr " *' but the argument type is '" type " * {aka " akaType " *}'.\n"

#define TEST_SCANF_ERR_AKA(format, formatStr, type, akaType) \

TEST_SCANF_ERR_AKA_("test.c", format, formatStr, type, akaType)

#define TEST_SCANF_ERR_AKA_CPP(format, formatStr, type, akaType) \

TEST_SCANF_ERR_AKA_("test.cpp", format, formatStr, type, akaType)

#define TEST_PRINTF_CODE(format, type) \

"void f(" type " x){printf(\"" format "\", x);}"

#define TEST_PRINTF_ERR(format, requiredType, actualType) \

"[test.c:1]: (warning) " format " in format string (no. 1) requires '" requiredType "' but the argument type is '" actualType "'.\n"

#define TEST_PRINTF_ERR_AKA_(file, format, requiredType, actualType, akaType) \

"[" file ":1]: (portability) " format " in format string (no. 1) requires '" requiredType "' but the argument type is '" actualType " {aka " akaType "}'.\n"

#define TEST_PRINTF_ERR_AKA(format, requiredType, actualType, akaType) \

TEST_PRINTF_ERR_AKA_("test.c", format, requiredType, actualType, akaType)

#define TEST_PRINTF_ERR_AKA_CPP(format, requiredType, actualType, akaType) \

TEST_PRINTF_ERR_AKA_("test.cpp", format, requiredType, actualType, akaType)

template<size_t size>

void testFormatStrNoWarn(const char *filename, unsigned int linenr, const char (&code)[size],

bool cpp = false) {

check(code, dinit(CheckOptions, $.inconclusive = true, $.platform = Platform::Type::Unix32, $.onlyFormatStr = true, $.cpp = cpp));

assertEquals(filename, linenr, "", errout_str());

check(code, dinit(CheckOptions, $.inconclusive = true, $.platform = Platform::Type::Unix64, $.onlyFormatStr = true, $.cpp = cpp));

assertEquals(filename, linenr, "", errout_str());

check(code, dinit(CheckOptions, $.inconclusive = true, $.platform = Platform::Type::Win32A, $.onlyFormatStr = true, $.cpp = cpp));

assertEquals(filename, linenr, "", errout_str());

check(code, dinit(CheckOptions, $.inconclusive = true, $.platform = Platform::Type::Win32W, $.onlyFormatStr = true, $.cpp = cpp));

assertEquals(filename, linenr, "", errout_str());

check(code, dinit(CheckOptions, $.inconclusive = true, $.platform = Platform::Type::Win64, $.onlyFormatStr = true, $.cpp = cpp));

assertEquals(filename, linenr, "", errout_str());

}

template<size_t size>

void testFormatStrWarn(const char *filename, unsigned int linenr,

const char (&code)[size], const char* testScanfErrString,

bool cpp = false) {

check(code, dinit(CheckOptions, $.inconclusive = true, $.platform = Platform::Type::Unix32, $.onlyFormatStr = true, $.cpp = cpp));

assertEquals(filename, linenr, testScanfErrString, errout_str());

check(code, dinit(CheckOptions, $.inconclusive = true, $.platform = Platform::Type::Unix64, $.onlyFormatStr = true, $.cpp = cpp));

assertEquals(filename, linenr, testScanfErrString, errout_str());

check(code, dinit(CheckOptions, $.inconclusive = true, $.platform = Platform::Type::Win32A, $.onlyFormatStr = true, $.cpp = cpp));

assertEquals(filename, linenr, testScanfErrString, errout_str());

check(code, dinit(CheckOptions, $.inconclusive = true, $.platform = Platform::Type::Win32W, $.onlyFormatStr = true, $.cpp = cpp));

assertEquals(filename, linenr, testScanfErrString, errout_str());

check(code, dinit(CheckOptions, $.inconclusive = true, $.platform = Platform::Type::Win64, $.onlyFormatStr = true, $.cpp = cpp));

assertEquals(filename, linenr, testScanfErrString, errout_str());

}

template<size_t size>

void testFormatStrWarnAka(const char *filename, unsigned int linenr,

const char (&code)[size], const char* testScanfErrAkaString, const char* testScanfErrAkaWin64String,

bool cpp = false) {

check(code, dinit(CheckOptions, $.inconclusive = true, $.portability = true, $.platform = Platform::Type::Unix32, $.onlyFormatStr = true, $.cpp = cpp));

assertEquals(filename, linenr, testScanfErrAkaString, errout_str());

check(code, dinit(CheckOptions, $.inconclusive = true, $.portability = true, $.platform = Platform::Type::Unix64, $.onlyFormatStr = true, $.cpp = cpp));

assertEquals(filename, linenr, testScanfErrAkaString, errout_str());

check(code, dinit(CheckOptions, $.inconclusive = true, $.portability = true, $.platform = Platform::Type::Win32A, $.onlyFormatStr = true, $.cpp = cpp));

assertEquals(filename, linenr, testScanfErrAkaString, errout_str());

check(code, dinit(CheckOptions, $.inconclusive = true, $.portability = true, $.platform = Platform::Type::Win32W, $.onlyFormatStr = true, $.cpp = cpp));

assertEquals(filename, linenr, testScanfErrAkaString, errout_str());

check(code, dinit(CheckOptions, $.inconclusive = true, $.portability = true, $.platform = Platform::Type::Win64, $.onlyFormatStr = true, $.cpp = cpp));

assertEquals(filename, linenr, testScanfErrAkaWin64String, errout_str());

}

template<size_t size>

void testFormatStrWarnAkaWin64(const char *filename, unsigned int linenr,

const char (&code)[size], const char* testScanfErrAkaWin64String,

bool cpp = false) {

check(code, dinit(CheckOptions, $.inconclusive = true, $.portability = true, $.platform = Platform::Type::Unix32, $.onlyFormatStr = true, $.cpp = cpp));

assertEquals(filename, linenr, "", errout_str());

check(code, dinit(CheckOptions, $.inconclusive = true, $.portability = true, $.platform = Platform::Type::Unix64, $.onlyFormatStr = true, $.cpp = cpp));

assertEquals(filename, linenr, "", errout_str());

check(code, dinit(CheckOptions, $.inconclusive = true, $.portability = true, $.platform = Platform::Type::Win32A, $.onlyFormatStr = true, $.cpp = cpp));

assertEquals(filename, linenr, "", errout_str());

check(code, dinit(CheckOptions, $.inconclusive = true, $.portability = true, $.platform = Platform::Type::Win32W, $.onlyFormatStr = true, $.cpp = cpp));

assertEquals(filename, linenr, "", errout_str());

check(code, dinit(CheckOptions, $.inconclusive = true, $.portability = true, $.platform = Platform::Type::Win64, $.onlyFormatStr = true, $.cpp = cpp));

assertEquals(filename, linenr, testScanfErrAkaWin64String, errout_str());

}

template<size_t size>

void testFormatStrWarnAkaWin32(const char *filename, unsigned int linenr,

const char (&code)[size], const char* testScanfErrAkaString,

bool cpp = false) {

check(code, dinit(CheckOptions, $.inconclusive = true, $.portability = true, $.platform = Platform::Type::Unix32, $.onlyFormatStr = true, $.cpp = cpp));

assertEquals(filename, linenr, testScanfErrAkaString, errout_str());

check(code, dinit(CheckOptions, $.inconclusive = true, $.portability = true, $.platform = Platform::Type::Unix64, $.onlyFormatStr = true, $.cpp = cpp));

assertEquals(filename, linenr, testScanfErrAkaString, errout_str());

check(code, dinit(CheckOptions, $.inconclusive = true, $.portability = true, $.platform = Platform::Type::Win32A, $.onlyFormatStr = true, $.cpp = cpp));

assertEquals(filename, linenr, testScanfErrAkaString, errout_str());

check(code, dinit(CheckOptions, $.inconclusive = true, $.portability = true, $.platform = Platform::Type::Win32W, $.onlyFormatStr = true, $.cpp = cpp));

assertEquals(filename, linenr, testScanfErrAkaString, errout_str());

check(code, dinit(CheckOptions, $.inconclusive = true, $.portability = true, $.platform = Platform::Type::Win64, $.onlyFormatStr = true, $.cpp = cpp));

assertEquals(filename, linenr, "", errout_str());

}

#define TEST_SCANF_NOWARN(FORMAT, FORMATSTR, TYPE) \

testFormatStrNoWarn(__FILE__, __LINE__, TEST_SCANF_CODE(FORMAT, TYPE))

#define TEST_SCANF_NOWARN_CPP(FORMAT, FORMATSTR, TYPE) \

testFormatStrNoWarn(__FILE__, __LINE__, TEST_SCANF_CODE(FORMAT, TYPE), true)

#define TEST_SCANF_WARN(FORMAT, FORMATSTR, TYPE) \

testFormatStrWarn(__FILE__, __LINE__, TEST_SCANF_CODE(FORMAT, TYPE), TEST_SCANF_ERR(FORMAT, FORMATSTR, TYPE))

#define TEST_SCANF_WARN_AKA(FORMAT, FORMATSTR, TYPE, AKATYPE, AKATYPE_WIN64) \

testFormatStrWarnAka(__FILE__, __LINE__, TEST_SCANF_CODE(FORMAT, TYPE), TEST_SCANF_ERR_AKA(FORMAT, FORMATSTR, TYPE, AKATYPE), TEST_SCANF_ERR_AKA(FORMAT, FORMATSTR, TYPE, AKATYPE_WIN64))

#define TEST_SCANF_WARN_AKA_CPP(FORMAT, FORMATSTR, TYPE, AKATYPE, AKATYPE_WIN64) \

testFormatStrWarnAka(__FILE__, __LINE__, TEST_SCANF_CODE(FORMAT, TYPE), TEST_SCANF_ERR_AKA_CPP(FORMAT, FORMATSTR, TYPE, AKATYPE), TEST_SCANF_ERR_AKA_CPP(FORMAT, FORMATSTR, TYPE, AKATYPE_WIN64), true)

#define TEST_SCANF_WARN_AKA_WIN64(FORMAT, FORMATSTR, TYPE, AKATYPE_WIN64) \

testFormatStrWarnAkaWin64(__FILE__, __LINE__, TEST_SCANF_CODE(FORMAT, TYPE), TEST_SCANF_ERR_AKA(FORMAT, FORMATSTR, TYPE, AKATYPE_WIN64))

#define TEST_SCANF_WARN_AKA_CPP_WIN64(FORMAT, FORMATSTR, TYPE, AKATYPE_WIN64) \