// Test library configuration for std.cfg

//

// Usage:

// $ cppcheck --check-library --library=std --enable=style,information --inconclusive --error-exitcode=1 --inline-suppr test/cfg/std.cpp

// =>

// No warnings about bad library configuration, unmatched suppressions, etc. exitcode=0

//

// cppcheck-suppress-file valueFlowBailout

#include <algorithm> // IWYU pragma: keep

#include <array>

#include <bitset>

#include <cassert>

#include <cctype>

#include <cfenv>

#include <cinttypes>

#include <clocale>

#include <cmath>

#include <complex>

#include <csetjmp>

#include <csignal>

#include <cstdarg>

#include <cstdio>

#include <cstdlib>

#include <cstring>

#define __STDC_WANT_LIB_EXT1__ 1

#include <ctime>

#include <cwchar>

#include <cwctype>

#include <deque>

#include <exception>

#include <filesystem>

#include <fstream>

#include <functional>

#ifndef __STDC_NO_THREADS__

#include <threads.h>

#endif

#include <iomanip>

#include <ios> // IWYU pragma: keep

#include <iostream>

#include <istream> // IWYU pragma: keep

#include <iterator>

#include <list> // IWYU pragma: keep

#include <locale>

#include <map>

#include <memory>

#include <mutex>

#include <numeric>

#include <queue>

#include <set>

#include <sstream>

#include <stdexcept>

#include <streambuf> // IWYU pragma: keep

#include <string>

#include <string_view>

#include <system_error>

#include <tuple>

#include <unordered_map>

#include <unordered_set>

#include <utility>

#include <variant>

#include <vector>

#include <version> // IWYU pragma: keep

#ifdef __cpp_lib_span

#include <span>

#endif

#ifdef __cpp_lib_format

#include <format>

#endif

#if __cplusplus <= 201402L

void unreachableCode_std_unexpected(int &x)

{

// cppcheck-suppress unexpectedCalled

std::unexpected();

// cppcheck-suppress unreachableCode

x=42;

}

#endif

#ifdef __cpp_lib_clamp

int ignoredReturnValue_std_clamp(const int x)

{

// cppcheck-suppress ignoredReturnValue

std::clamp(x, 1, -1);

return std::clamp(x, 1, -1);

}

void knownConditionTrueFalse_std_clamp(const int x)

{

// cppcheck-suppress knownConditionTrueFalse

if(std::clamp(-2, -1, 1) == -1){}

// cppcheck-suppress knownConditionTrueFalse

if(std::clamp(2, -1, 1) == 1){}

// cppcheck-suppress knownConditionTrueFalse

if(std::clamp(0, -1, 1) == 0){}

if(std::clamp(x, 0, 2)){}

}

#endif // __cpp_lib_clamp

void unreachableCode_std_terminate(int &x)

{

std::terminate();

// cppcheck-suppress unreachableCode

x=42;

}

bool ignoredReturnValue_std_filesystem_exists(const std::filesystem::path &path, std::error_code& ec)

{

// cppcheck-suppress ignoredReturnValue

std::filesystem::exists(path);

// cppcheck-suppress ignoredReturnValue

std::filesystem::exists(path, ec);

const bool b {std::filesystem::exists(path)};

return b && std::filesystem::exists(path, ec);

}

// https://en.cppreference.com/w/cpp/io/manip/quoted

void uninitvar_std_quoted(std::stringstream &ss, const std::string &input, const char delim, const char escape)

{

ss << std::quoted(input);

ss << std::quoted(input, delim);

ss << std::quoted(input, delim, escape);

char delimChar;

// cppcheck-suppress uninitvar

ss << std::quoted(input, delimChar);

char escapeChar;

// cppcheck-suppress uninitvar

ss << std::quoted(input, delim, escapeChar);

}

int zerodiv_ldexp()

{

int i = std::ldexp(0.0, 42.0);

// cppcheck-suppress zerodiv

return 42 / i;

}

int zerodiv_ilogb()

{

int i = std::ilogb(1.0);

// cppcheck-suppress zerodiv

return 42 / i;

}

int zerodiv_hypot()

{

int i = std::hypot(0.0, 0.0);

// cppcheck-suppress zerodiv

return 42 / i;

}

int zerodiv_fmod()

{

int i = std::fmod(0.0, 42.0);

// cppcheck-suppress zerodiv

return 42 / i;

}

int zerodiv_fmin()

{

int i = std::fmin(0.0, 0.0);

// cppcheck-suppress zerodiv

return 42 / i;

}

int zerodiv_fmax()

{

int i = std::fmax(0.0, 0.0);

// cppcheck-suppress zerodiv

return 42 / i;

}

int zerodiv_floor()

{

int i = std::floor(0.0);

// cppcheck-suppress zerodiv

return 42 / i;

}

int zerodiv_fabs()

{

int i = std::fabs(-0.0) + std::fabs(+0.0) + std::fabs(0.0);

// cppcheck-suppress zerodiv

return 42 / i;

}

int zerodiv_fdim()

{

int i = std::fdim(1.0, 1.0);

// cppcheck-suppress zerodiv

return 42 / i;

}

int zerodiv_trunc()

{

int i = std::trunc(0);

// cppcheck-suppress zerodiv

return 42 / i;

}

int zerodiv_ceil()

{

int i = std::ceil(0);

// cppcheck-suppress zerodiv

return 42 / i;

}

int zerodiv_sqrt()

{

int i = std::sqrt(0);

// cppcheck-suppress zerodiv

return 42 / i;

}

int zerodiv_cbrt()

{

int i = std::cbrt(0);

// cppcheck-suppress zerodiv

return 42 / i;

}

int zerodiv_erf()

{

int i = std::erf(0);

// cppcheck-suppress zerodiv

return 42 / i;

}

int zerodiv_erfc()

{

int i = std::erfc(42);

// cppcheck-suppress zerodiv

return 42 / i;

}

int zerodiv_asin()

{

int i = std::asin(0);

// cppcheck-suppress zerodiv

return 42 / i;

}

int zerodiv_acos()

{

int i = std::acos(1);

// cppcheck-suppress zerodiv

return 42 / i;

}

int zerodiv_asinh()

{

int i = std::asinh(0);

// cppcheck-suppress zerodiv

return 42 / i;

}

int zerodiv_acosh()

{

int i = std::acosh(1);

// cppcheck-suppress zerodiv

return 42 / i;

}

int zerodiv_log1p()

{

int i = std::log1p(0);

// cppcheck-suppress zerodiv

return 42 / i;

}

int zerodiv_nearbyint()

{

int i = std::nearbyint(0);

// cppcheck-suppress zerodiv

return 42 / i;

}

int zerodiv_round()

{

int i = std::round(0);

// cppcheck-suppress zerodiv

return 42 / i;

}

int zerodiv_sinh()

{

int i = std::sinh(0);

// cppcheck-suppress zerodiv

return 42 / i;

}

int zerodiv_tanh()

{

int i = std::tanh(0);

// cppcheck-suppress zerodiv

return 42 / i;

}

int zerodiv_atanh()

{

int i = std::atanh(0);

// cppcheck-suppress zerodiv

return 42 / i;

}

int zerodiv_atan()

{

int i = std::atan(0);

// cppcheck-suppress zerodiv

return 42 / i;

}

int zerodiv_sin()

{

int i = std::sin(0)+std::sin(M_PI)+std::sin(2*M_PI);

// cppcheck-suppress zerodiv

return 42 / i;

}

int zerodiv_expm1()

{

int i = std::expm1(0);

// cppcheck-suppress zerodiv

return 42 / i;

}

int moduloofone_cos()

{

int i = std::cos(0);

// cppcheck-suppress moduloofone

return 42 % i;

}

int moduloofone_exp()

{

int i = std::exp(0);

// cppcheck-suppress moduloofone

return 42 % i;

}

int moduloofone_exp2()

{

int i = std::exp2(0);

// cppcheck-suppress moduloofone

return 42 % i;

}

int moduloofone_pow()

{

int i = std::pow(2, 0);

// cppcheck-suppress moduloofone

return 42 % i;

}

char* invalidFunctionArgStr_strncpy(char * destination)

{

// Copies the first num characters of source to destination.

// If the end of the source C string (which is signaled by a null-character)

// is found before num characters have been copied, destination

// is padded with zeros until a total of num characters have been written to it.

const char source = 'x';

const std::size_t num = 1U;

return strncpy(destination, &source, num);

}

void invalidFunctionArgStr_fprintf(FILE *stream, const char *format)

{

const char formatBuf[] = {'%','d'};

// cppcheck-suppress invalidFunctionArgStr

(void)fprintf(stream,formatBuf,42);

(void)fprintf(stream,format,42);

}

void invalidFunctionArgStr_fopen(const char * const fileName, const char * const mode)

{

const char fileNameBuf[] = {'f','i','l','e'};

const char modeBuf[] = {'r'};

// cppcheck-suppress invalidFunctionArgStr

FILE *fp = fopen(fileName, modeBuf);

// cppcheck-suppress nullPointerOutOfResources

fclose(fp);

// cppcheck-suppress invalidFunctionArgStr

fp = fopen(fileNameBuf, mode);

// cppcheck-suppress nullPointerOutOfResources

fclose(fp);

}

float invalidFunctionArg_remquo (float x, float y, int* quo )

{

// cppcheck-suppress invalidFunctionArg

(void) std::remquo(x,0.0f,quo);

// cppcheck-suppress invalidFunctionArg

(void) std::remquof(x,0.0f,quo);

return std::remquo(x,y,quo);

}

double invalidFunctionArg_remquo (double x, double y, int* quo )

{

// cppcheck-suppress invalidFunctionArg

(void) std::remquo(x,0.0,quo);

// cppcheck-suppress invalidFunctionArg

(void) std::remquo(x,0.0f,quo);

// cppcheck-suppress invalidFunctionArg

(void) std::remquo(x,0.0L,quo);

return std::remquo(x,y,quo);

}

double invalidFunctionArg_remquo (long double x, long double y, int* quo )

{

// cppcheck-suppress invalidFunctionArg

(void) std::remquo(x,0.0L,quo);

// cppcheck-suppress invalidFunctionArg

(void) std::remquol(x,0.0L,quo);

return std::remquo(x,y,quo);

}

void invalidFunctionArg_remainderl(long double f1, long double f2)

{

// cppcheck-suppress invalidFunctionArg

(void)std::remainderl(f1,0.0);

// cppcheck-suppress invalidFunctionArg

(void)std::remainderl(f1,0.0L);

(void)std::remainderl(f1,f2);

}

void invalidFunctionArg_remainder(double f1, double f2)

{

// cppcheck-suppress invalidFunctionArg

(void)std::remainder(f1,0.0);

(void)std::remainder(f1,f2);

}

void invalidFunctionArg_remainderf(float f1, float f2)

{

// cppcheck-suppress invalidFunctionArg

(void)std::remainderf(f1,0.0);

// cppcheck-suppress invalidFunctionArg

(void)std::remainderf(f1,0.0f);

(void)std::remainderf(f1,f2);

}

void uninitvar_std_fstream_open(std::fstream &fs, const std::string &strFileName, const char* filename, std::ios_base::openmode mode)

{

std::string s;

const char *ptr;

std::ios_base::openmode m;

fs.open(s, mode);

// cppcheck-suppress uninitvar

fs.open(ptr, mode);

// TODO cppcheck-suppress uninitvar

fs.open(filename, m);

// TODO cppcheck-suppress uninitvar

fs.open(strFileName, m);

fs.open(s);

// TODO cppcheck-suppress uninitvar

fs.open(ptr);

}

void uninitvar_std_ifstream_open(std::ifstream &ifs, const std::string &strFileName, const char* filename, std::ios_base::openmode mode)

{

std::string s;

const char *ptr;

std::ios_base::openmode m;

ifs.open(s, mode);

// cppcheck-suppress uninitvar

ifs.open(ptr, mode);

// TODO cppcheck-suppress uninitvar

ifs.open(filename, m);

// TODO cppcheck-suppress uninitvar

ifs.open(strFileName, m);

ifs.open(s);

// TODO cppcheck-suppress uninitvar

ifs.open(ptr);

}

void uninitvar_std_ofstream_open(std::ofstream &os, const std::string &strFileName, const char* filename, std::ios_base::openmode mode)

{

std::string s;

const char *ptr;

std::ios_base::openmode m;

os.open(s, mode);

// cppcheck-suppress uninitvar

os.open(ptr, mode);

// TODO cppcheck-suppress uninitvar

os.open(filename, m);

// TODO cppcheck-suppress uninitvar

os.open(strFileName, m);

os.open(s);

// TODO cppcheck-suppress uninitvar

os.open(ptr);

}

void uninitvar_std_ofstream_precision(std::ofstream& os)

{

std::streamsize s;

// cppcheck-suppress uninitvar

os.precision(s);

}

void nullPointer_std_filebuf_open(std::filebuf &fb, const std::string &strFileName, const char* filename, std::ios_base::openmode mode)

{

// cppcheck-suppress nullPointer

(void)fb.open(nullptr, mode);

(void)fb.open(filename, mode);

(void)fb.open(strFileName, mode);

}

void nullPointer_std_ofstream_open(std::ofstream &os, const std::string &strFileName, const char* filename, std::ios_base::openmode mode)

{

// cppcheck-suppress nullPointer

os.open(nullptr, mode);

os.open(filename, mode);

os.open(strFileName, mode);

// cppcheck-suppress nullPointer

os.open(nullptr);

os.open(filename);

os.open(strFileName);

}

void nullPointer_std_fstream_open(std::fstream &fs, const std::string &strFileName, const char* filename, std::ios_base::openmode mode)

{

// cppcheck-suppress nullPointer

fs.open(nullptr, mode);

fs.open(filename, mode);

fs.open(strFileName, mode);

// cppcheck-suppress nullPointer

fs.open(nullptr);

fs.open(filename);

fs.open(strFileName);

}

void nullPointer_std_ifstream_open(std::ifstream &is, const std::string &strFileName, const char* filename, std::ios_base::openmode mode)

{

// cppcheck-suppress nullPointer

is.open(nullptr, mode);

is.open(filename, mode);

is.open(strFileName, mode);

// cppcheck-suppress nullPointer

is.open(nullptr);

is.open(filename);

is.open(strFileName);

}

void bufferAccessOutOfBounds_std_fstream_write(std::fstream &fs, const char* s, std::streamsize n)

{

const char buf[42] = {0};

(void)fs.write(buf,42);

// cppcheck-suppress bufferAccessOutOfBounds

(void)fs.write(buf,43);

(void)fs.write(buf,n);

(void)fs.write(s,n);

}

void bufferAccessOutOfBounds_std_ostream_write(std::ostream &os, const char* s, std::streamsize n)

{

const char buf[42] = {0};

(void)os.write(buf,42);

// cppcheck-suppress bufferAccessOutOfBounds

(void)os.write(buf,43);

(void)os.write(buf,n);

(void)os.write(s,n);

}

void bufferAccessOutOfBounds_std_ostringstream_write(std::ostringstream &oss, const char* s, std::streamsize n)

{

const char buf[42] = {0};

(void)oss.write(buf,42);

// cppcheck-suppress bufferAccessOutOfBounds

(void)oss.write(buf,43);

(void)oss.write(buf,n);

(void)oss.write(s,n);

}

void bufferAccessOutOfBounds_std_ofstream_write(std::ofstream &os, const char* s, std::streamsize n)

{

const char buf[42] = {0};

(void)os.write(buf,42);

// cppcheck-suppress bufferAccessOutOfBounds

(void)os.write(buf,43);

(void)os.write(buf,n);

(void)os.write(s,n);

}

void bufferAccessOutOfBounds_std_ifstream_get(std::ifstream& in, std::streambuf& sb)

{

char cBuf[10];

// cppcheck-suppress bufferAccessOutOfBounds

in.getline(cBuf, 100);

// cppcheck-suppress bufferAccessOutOfBounds

in.read(cBuf, 100);

// cppcheck-suppress bufferAccessOutOfBounds

in.readsome(cBuf, 100);

// cppcheck-suppress bufferAccessOutOfBounds

in.get(cBuf, 100);

// cppcheck-suppress bufferAccessOutOfBounds

in.get(cBuf, 100, 'a');

// cppcheck-suppress bufferAccessOutOfBounds

in.getline(cBuf, 100, 'a');

in.get(sb, 'a');

in.close();

}

void invalidFunctionArg_fesetexceptflag(const fexcept_t* flagp, int excepts)

{

(void)std::fesetexceptflag(flagp, excepts);

// cppcheck-suppress invalidFunctionArg

(void)std::fesetexceptflag(flagp, 0);

(void)std::fesetexceptflag(flagp, FE_DIVBYZERO);

(void)std::fesetexceptflag(flagp, FE_INEXACT);

(void)std::fesetexceptflag(flagp, FE_INVALID);

(void)std::fesetexceptflag(flagp, FE_OVERFLOW);

(void)std::fesetexceptflag(flagp, FE_UNDERFLOW);

(void)std::fesetexceptflag(flagp, FE_ALL_EXCEPT);

// cppcheck-suppress invalidFunctionArg

(void)std::fesetexceptflag(flagp, FE_ALL_EXCEPT+1);

}

void invalidFunctionArg_fetestexcept(int excepts)

{

(void)std::fetestexcept(excepts);

// cppcheck-suppress invalidFunctionArg

(void)std::fetestexcept(0);

(void)std::fetestexcept(FE_DIVBYZERO);

(void)std::fetestexcept(FE_INEXACT);

(void)std::fetestexcept(FE_INVALID);

(void)std::fetestexcept(FE_OVERFLOW);

(void)std::fetestexcept(FE_UNDERFLOW);

(void)std::fetestexcept(FE_ALL_EXCEPT);

// cppcheck-suppress invalidFunctionArg

(void)std::fetestexcept(FE_ALL_EXCEPT+1);

}

void nullPointer_fprintf(FILE *Stream, const char *Format, int Argument)

{

// cppcheck-suppress nullPointer

(void)std::fprintf(Stream, nullptr, Argument);

// no warning is expected

(void)std::fprintf(Stream, Format, Argument);

}

void bufferAccessOutOfBounds_wcsftime(wchar_t* ptr, size_t maxsize, const wchar_t* format, const struct tm* timeptr)

{

wchar_t buf[42];

(void)std::wcsftime(buf, 42, format, timeptr);

// TODO cppcheck-suppress bufferAccessOutOfBounds

(void)std::wcsftime(buf, 43, format, timeptr);

(void)std::wcsftime(ptr, maxsize, format, timeptr);

}

int qsort_cmpfunc (const void * a, const void * b) {

return (*static_cast<const int*>(a) - *static_cast<const int*>(b));

}

void nullPointer_qsort(void *base, std::size_t n, std::size_t size, int (*cmp)(const void *, const void *))

{

// cppcheck-suppress nullPointer

std::qsort(nullptr, n, size, qsort_cmpfunc);

// cppcheck-suppress nullPointer

std::qsort(base, n, size, nullptr);

std::qsort(base, n, size, qsort_cmpfunc);

}

void nullPointer_vfprintf(FILE *Stream, const char *Format, va_list Arg)

{

// cppcheck-suppress nullPointer

(void)std::vfprintf(Stream, nullptr, Arg);

(void)std::vfprintf(Stream, Format, Arg);

}

void nullPointer_vfwprintf(FILE *Stream, const wchar_t *Format, va_list Arg)

{

// cppcheck-suppress nullPointer

(void)std::vfwprintf(Stream, nullptr, Arg);

(void)std::vfwprintf(Stream, Format, Arg);

}

void *bufferAccessOutOfBounds_memchr(void *s, int c, size_t n)

{

char buf[42]={0};

(void)std::memchr(buf,c,42);

// cppcheck-suppress bufferAccessOutOfBounds

(void)std::memchr(buf,c,43);

return std::memchr(s,c,n);

}

// As with all bounds-checked functions, localtime_s is only guaranteed to be available if __STDC_LIB_EXT1__ is defined by the implementation and if the user defines __STDC_WANT_LIB_EXT1__ to the integer constant 1 before including time.h.

#ifdef __STDC_LIB_EXT1__

void uninitvar_localtime_s(const std::time_t *restrict time, struct tm *restrict result)

{

// cppcheck-suppress valueFlowBailoutIncompleteVar

const std::time_t *restrict Time;

// TODO cppcheck-suppress uninitvar

(void)std::localtime_s(Time, result);

(void)std::localtime_s(time, result);

}

void nullPointer_localtime_s(const std::time_t *restrict time, struct tm *restrict result)

{

// cppcheck-suppress nullPointer

(void)std::localtime_s(NULL, result);

// cppcheck-suppress nullPointer

(void)std::localtime_s(time, NULL);

(void)std::localtime_s(time, result);

}

void memleak_localtime_s(const std::time_t *restrict time, struct tm *restrict result) // #9258

{

const time_t t = time(0);

const struct tm* const now = new tm();

if (localtime_s(now, &t) == 0) {

// cppcheck-suppress valueFlowBailoutIncompleteVar

std::cout << now->tm_mday << std::endl;

}

// cppcheck-suppress memleak

}

#endif // __STDC_LIB_EXT1__

size_t nullPointer_strftime(char *s, size_t max, const char *fmt, const struct tm *p)

{

// cppcheck-suppress nullPointer

(void) std::strftime(NULL,max,fmt,p);

// cppcheck-suppress nullPointer

(void) std::strftime(s,max,NULL,p);

// cppcheck-suppress nullPointer

(void) std::strftime(s,max,fmt,NULL);

return std::strftime(s,max,fmt,p);

}

size_t bufferAccessOutOfBounds_wcsrtombs(char * dest, const wchar_t ** src, size_t len, mbstate_t * ps)

{

char buf[42];

(void)std::wcsrtombs(buf,src,42,ps);

// cppcheck-suppress bufferAccessOutOfBounds

(void)std::wcsrtombs(buf,src,43,ps);

return std::wcsrtombs(dest,src,len,ps);

}

void deallocuse_wcrtomb(char *buff) { // #13119

free(buff);

// cppcheck-suppress deallocuse

wcrtomb(buff, L'x', nullptr);

}

void invalidFunctionArg_std_string_substr(const std::string &str, std::size_t pos, std::size_t len) {

// cppcheck-suppress invalidFunctionArg

(void)str.substr(-1,len);

// cppcheck-suppress invalidFunctionArg

(void)str.substr(pos,-1);

// no warning is expected for

(void)str.substr(pos,len);

// cppcheck-suppress valueFlowBailoutIncompleteVar

(void)str.substr(pos, std::string::npos);

}

void invalidFunctionArg_std_wstring_substr(const std::wstring &str, std::size_t pos, std::size_t len) {

// cppcheck-suppress invalidFunctionArg

(void)str.substr(-1,len);

// cppcheck-suppress invalidFunctionArg

(void)str.substr(pos,-1);

// no warning is expected for

(void)str.substr(pos,len);

// cppcheck-suppress valueFlowBailoutIncompleteVar

(void)str.substr(pos, std::wstring::npos);

}

double invalidFunctionArg_log10(double d = 0.0) {

// cppcheck-suppress invalidFunctionArg

return log10(d);

}

void uninitvar_std_next(const std::vector<int> &v, int count)

{

// No warning shall be shown:

if (std::next(v.begin()) != v.end()) {}

if (std::next(v.begin(), count) != v.end()) {}

std::vector<int>::iterator it;

// cppcheck-suppress uninitvar

if (std::next(it) != v.end()) {}

std::vector<int>::const_iterator const_it;

// cppcheck-suppress uninitvar

if (std::next(const_it) != v.end()) {}

std::vector<int>::reverse_iterator rit;

// cppcheck-suppress uninitvar

if (std::next(rit) != v.rend()) {}

std::vector<int>::const_reverse_iterator const_rit;

// cppcheck-suppress uninitvar

if (std::next(const_rit) != v.rend()) {}

}

void uninitvar_std_prev(const std::vector<int> &v, int count)

{

// No warning shall be shown:

if (std::prev(v.begin()) != v.end()) {}

if (std::prev(v.begin(), count) != v.end()) {}

std::vector<int>::iterator it;

// cppcheck-suppress uninitvar

if (std::prev(it) != v.end()) {}

std::vector<int>::const_iterator const_it;

// cppcheck-suppress uninitvar

if (std::prev(const_it) != v.end()) {}

std::vector<int>::reverse_iterator rit;

// cppcheck-suppress uninitvar

if (std::prev(rit) != v.rend()) {}

std::vector<int>::const_reverse_iterator const_rit;

// cppcheck-suppress uninitvar

if (std::prev(const_rit) != v.rend()) {}

}

void overlappingWriteFunction_wcscat(wchar_t *src, wchar_t *dest)

{

// No warning shall be shown:

(void)wcscat(dest, src);

// cppcheck-suppress overlappingWriteFunction

(void)wcscat(src, src);

}

void overlappingWriteFunction_wcsxfrm(wchar_t *s1, const wchar_t *s2, size_t n)

{

// No warning shall be shown:

(void)wcsxfrm(s1, s2, n);

}

char * overlappingWriteFunction_strcat(char *src, char *dest)

{

// No warning shall be shown:

(void)strcat(dest, src);

// cppcheck-suppress overlappingWriteFunction

return strcat(src, src);

}

int nullPointer_wcsncmp(const wchar_t* s1, const wchar_t* s2, size_t n)

{

// cppcheck-suppress nullPointer

(void) std::wcsncmp(NULL,s2,n);

// cppcheck-suppress nullPointer

(void) std::wcsncmp(s1,NULL,n);

return std::wcsncmp(s1,s2,n);

}

wchar_t* nullPointer_wcsncpy(wchar_t *s, const wchar_t *cs, size_t n)

{

// cppcheck-suppress nullPointer

(void) std::wcsncpy(NULL,cs,n);

// cppcheck-suppress nullPointer

(void) std::wcsncpy(s,NULL,n);

return std::wcsncpy(s,cs,n);

}

char * overlappingWriteFunction_strncat(const char *src, char *dest, const std::size_t count)

{

// No warning shall be shown:

(void)strncat(dest, src, 42);

(void)strncat(dest, src, count);

(void)strncat(dest, dest, count);

// cppcheck-suppress overlappingWriteFunction

(void)strncat(dest, dest+1, 2);

char buffer[] = "strncat";

// cppcheck-suppress overlappingWriteFunction

return strncat(buffer, buffer + 1, 3);

}

wchar_t * overlappingWriteFunction_wcsncat(const wchar_t *src, wchar_t *dest, const std::size_t count)

{

// No warning shall be shown:

(void)wcsncat(dest, src, 42);

(void)wcsncat(dest, src, count);

(void)wcsncat(dest, dest, count);

// cppcheck-suppress overlappingWriteFunction

(void)wcsncat(dest, dest+1, 2);

wchar_t buffer[] = L"strncat";

// cppcheck-suppress overlappingWriteFunction

return wcsncat(buffer, buffer + 1, 3);

}

wchar_t * overlappingWriteFunction_wcscpy(wchar_t *src, wchar_t *dest)

{

// No warning shall be shown:

(void)wcscpy(dest, src);

const wchar_t * destBuf = dest;

// TODO-cppcheck-suppress overlappingWriteFunction #10355

(void)wcscpy(dest, destBuf);

// cppcheck-suppress overlappingWriteFunction

return wcscpy(src, src);

}

wchar_t * overlappingWriteFunction_wcsncpy(wchar_t *buf, const std::size_t count)

{

// No warning shall be shown:

(void)wcsncpy(&buf[0], &buf[3], count); // size is not known

(void)wcsncpy(&buf[0], &buf[3], 3U); // no-overlap

// cppcheck-suppress overlappingWriteFunction

return wcsncpy(&buf[0], &buf[3], 4U);

}

char * overlappingWriteFunction_strncpy(char *buf, const std::size_t count)

{

// No warning shall be shown:

(void)strncpy(&buf[0], &buf[3], count); // size is not known

(void)strncpy(&buf[0], &buf[3], 3U); // no-overlap

// cppcheck-suppress overlappingWriteFunction

return strncpy(&buf[0], &buf[3], 4U);

}

void * overlappingWriteFunction_memmove(void)

{

// No warning shall be shown:

char str[] = "memmove handles overlapping data well";

return memmove(str,str+3,4);

}

std::bitset<10> std_bitset_test_ignoredReturnValue()

{

std::bitset<10> b1("1111010000");

// cppcheck-suppress ignoredReturnValue

b1.test(2);

return b1;

}

std::bitset<10> std_bitset_all_ignoredReturnValue()

{

std::bitset<10> b1("1111010000");

// cppcheck-suppress ignoredReturnValue

b1.all();

return b1;

}

std::bitset<10> std_bitset_none_ignoredReturnValue()

{

std::bitset<10> b1("1111010000");

// cppcheck-suppress ignoredReturnValue

b1.none();

return b1;

}

std::bitset<10> std_bitset_any_ignoredReturnValue()

{

std::bitset<10> b1("1111010000");

// cppcheck-suppress ignoredReturnValue

b1.any();

return b1;

}

std::bitset<10> std_bitset_size_ignoredReturnValue()

{

std::bitset<10> b1("1111010000");

// cppcheck-suppress ignoredReturnValue

b1.size();

return b1;

}

std::bitset<10> std_bitset_count_ignoredReturnValue()

{

std::bitset<10> b1("1111010000");

// cppcheck-suppress ignoredReturnValue

b1.count();

return b1;

}

void std_unordered_set_count_ignoredReturnValue(const std::unordered_set<int>& u)

{

int i;

// cppcheck-suppress [uninitvar, ignoredReturnValue]

u.count(i);

}

void std_unordered_map_count_ignoredReturnValue(const std::unordered_map<int, int>& u)

{

int i;

// cppcheck-suppress [uninitvar, ignoredReturnValue]

u.count(i);

}

void std_multimap_count_ignoredReturnValue(const std::multimap<int, int>& m)

{

int i;

// cppcheck-suppress [uninitvar, ignoredReturnValue]

m.count(i);

}

void std_unordered_map_insert_unnitvar(std::unordered_set<int>& u)

{

int i;

// cppcheck-suppress uninitvar

u.insert(i);

}