2008-12-19 22:15:18 +01:00
/*
2009-01-21 21:04:20 +01:00
* Cppcheck - A tool for static C / C + + code analysis
2012-01-01 00:05:37 +01:00
* Copyright ( C ) 2007 - 2012 Daniel Marjamäki and Cppcheck team .
2008-12-19 22:15:18 +01:00
*
* 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
2009-09-27 17:08:31 +02:00
* along with this program . If not , see < http : //www.gnu.org/licenses/>.
2008-12-19 22:15:18 +01:00
*/
2011-02-19 09:33:29 +01:00
# include "preprocessor.h"
2009-10-25 12:49:06 +01:00
# include "tokenize.h"
# include "checkother.h"
2008-12-19 22:15:18 +01:00
# include "testsuite.h"
# include <sstream>
extern std : : ostringstream errout ;
2011-10-13 20:53:06 +02:00
class TestOther : public TestFixture {
2008-12-19 22:15:18 +01:00
public :
TestOther ( ) : TestFixture ( " TestOther " )
{ }
private :
2011-10-13 20:53:06 +02:00
void run ( ) {
2011-07-28 07:28:24 +02:00
TEST_CASE ( assignBoolToPointer ) ;
2011-07-28 08:12:21 +02:00
2009-03-28 07:49:47 +01:00
TEST_CASE ( zeroDiv1 ) ;
TEST_CASE ( zeroDiv2 ) ;
2009-08-23 05:34:19 +02:00
TEST_CASE ( zeroDiv3 ) ;
2009-08-30 21:02:09 +02:00
TEST_CASE ( zeroDiv4 ) ;
2011-08-24 02:12:29 +02:00
TEST_CASE ( zeroDiv5 ) ;
2011-09-10 16:12:53 +02:00
TEST_CASE ( zeroDiv6 ) ;
2009-03-28 07:49:47 +01:00
2009-01-15 17:57:51 +01:00
TEST_CASE ( sprintf1 ) ; // Dangerous usage of sprintf
2009-01-10 12:19:17 +01:00
TEST_CASE ( sprintf2 ) ;
2009-01-10 15:29:59 +01:00
TEST_CASE ( sprintf3 ) ;
2009-01-15 17:57:51 +01:00
TEST_CASE ( sprintf4 ) ; // struct member
2010-02-01 19:46:51 +01:00
TEST_CASE ( strPlusChar1 ) ; // "/usr" + '/'
TEST_CASE ( strPlusChar2 ) ; // "/usr" + ch
TEST_CASE ( strPlusChar3 ) ; // ok: path + "/sub" + '/'
2009-02-04 19:49:19 +01:00
2009-03-24 20:24:03 +01:00
TEST_CASE ( varScope1 ) ;
2009-03-24 20:59:56 +01:00
TEST_CASE ( varScope2 ) ;
2009-05-27 19:38:26 +02:00
TEST_CASE ( varScope3 ) ;
2009-06-12 16:17:51 +02:00
TEST_CASE ( varScope4 ) ;
2009-08-16 21:12:57 +02:00
TEST_CASE ( varScope5 ) ;
2009-09-17 21:05:12 +02:00
TEST_CASE ( varScope6 ) ;
2009-10-06 17:45:28 +02:00
TEST_CASE ( varScope7 ) ;
2010-01-21 18:50:56 +01:00
TEST_CASE ( varScope8 ) ;
2011-10-05 20:30:36 +02:00
TEST_CASE ( varScope9 ) ; // classes may have extra side-effects
2010-08-26 21:57:48 +02:00
TEST_CASE ( varScope10 ) ; // Undefined macro FOR
2011-10-05 20:30:36 +02:00
TEST_CASE ( varScope11 ) ; // #2475 - struct initialization is not inner scope
2012-05-24 15:34:59 +02:00
TEST_CASE ( varScope12 ) ;
TEST_CASE ( varScope13 ) ; // variable usage in inner loop
2009-03-27 17:19:34 +01:00
2009-06-18 22:26:21 +02:00
TEST_CASE ( oldStylePointerCast ) ;
2012-02-26 11:56:32 +01:00
TEST_CASE ( invalidPointerCast ) ;
2009-07-25 00:36:15 +02:00
2009-10-04 10:05:58 +02:00
TEST_CASE ( dangerousStrolUsage ) ;
TEST_CASE ( passedByValue ) ;
2010-04-02 02:19:38 +02:00
2010-04-02 07:32:03 +02:00
TEST_CASE ( mathfunctionCall1 ) ;
2011-11-17 16:31:16 +01:00
TEST_CASE ( cctypefunctionCall ) ;
2010-04-13 19:30:25 +02:00
2010-05-15 14:06:45 +02:00
TEST_CASE ( sizeofsizeof ) ;
2010-08-06 22:57:10 +02:00
TEST_CASE ( sizeofCalculation ) ;
2010-06-15 08:45:46 +02:00
2010-06-30 09:10:30 +02:00
TEST_CASE ( switchRedundantAssignmentTest ) ;
2012-05-29 06:19:22 +02:00
TEST_CASE ( switchRedundantBitwiseOperationTest ) ;
2011-02-19 09:33:29 +01:00
TEST_CASE ( switchFallThroughCase ) ;
2011-12-07 18:20:52 +01:00
TEST_CASE ( unreachableCode ) ;
2010-08-14 15:15:12 +02:00
2010-08-15 06:28:22 +02:00
TEST_CASE ( selfAssignment ) ;
2010-10-01 17:23:22 +02:00
TEST_CASE ( trac1132 ) ;
2011-03-20 09:55:26 +01:00
TEST_CASE ( testMisusedScopeObjectDoesNotPickFunction1 ) ;
TEST_CASE ( testMisusedScopeObjectDoesNotPickFunction2 ) ;
2010-10-01 17:23:22 +02:00
TEST_CASE ( testMisusedScopeObjectPicksClass ) ;
TEST_CASE ( testMisusedScopeObjectPicksStruct ) ;
TEST_CASE ( testMisusedScopeObjectDoesNotPickIf ) ;
TEST_CASE ( testMisusedScopeObjectDoesNotPickConstructorDeclaration ) ;
2010-10-02 10:43:12 +02:00
TEST_CASE ( testMisusedScopeObjectDoesNotPickFunctor ) ;
2010-10-02 14:59:04 +02:00
TEST_CASE ( testMisusedScopeObjectDoesNotPickLocalClassConstructors ) ;
2010-10-02 12:26:29 +02:00
TEST_CASE ( testMisusedScopeObjectDoesNotPickUsedObject ) ;
2010-12-25 08:43:52 +01:00
TEST_CASE ( testMisusedScopeObjectDoesNotPickPureC ) ;
2011-01-31 20:07:41 +01:00
TEST_CASE ( testMisusedScopeObjectDoesNotPickNestedClass ) ;
2010-10-03 23:16:11 +02:00
TEST_CASE ( trac2071 ) ;
2010-10-13 11:31:41 +02:00
TEST_CASE ( trac2084 ) ;
2012-04-12 14:02:09 +02:00
TEST_CASE ( trac3693 ) ;
2010-10-10 22:05:06 +02:00
TEST_CASE ( assignmentInAssert ) ;
2011-07-17 04:06:23 +02:00
2012-04-26 15:23:47 +02:00
TEST_CASE ( modulo ) ;
2011-07-17 04:06:23 +02:00
TEST_CASE ( incorrectLogicOperator1 ) ;
TEST_CASE ( incorrectLogicOperator2 ) ;
2012-03-15 20:38:28 +01:00
TEST_CASE ( incorrectLogicOperator3 ) ;
2011-08-19 19:28:37 +02:00
TEST_CASE ( secondAlwaysTrueFalseWhenFirstTrueError ) ;
2012-03-12 19:06:30 +01:00
TEST_CASE ( incorrectLogicOp_condSwapping ) ;
2011-07-17 04:06:23 +02:00
2011-01-06 11:31:58 +01:00
TEST_CASE ( memsetZeroBytes ) ;
2011-01-22 19:21:56 +01:00
2011-01-24 19:04:56 +01:00
TEST_CASE ( sizeofForArrayParameter ) ;
2011-05-16 21:16:25 +02:00
TEST_CASE ( sizeofForNumericParameter ) ;
2011-01-24 21:40:49 +01:00
TEST_CASE ( clarifyCalculation ) ;
2011-02-08 19:49:29 +01:00
2011-08-19 00:14:15 +02:00
TEST_CASE ( clarifyCondition1 ) ; // if (a = b() < 0)
TEST_CASE ( clarifyCondition2 ) ; // if (a & b == c)
2011-08-19 13:40:54 +02:00
TEST_CASE ( clarifyCondition3 ) ; // if (! a & b)
2011-09-13 02:46:00 +02:00
TEST_CASE ( clarifyCondition4 ) ; // ticket #3110
2012-04-08 18:07:11 +02:00
TEST_CASE ( clarifyCondition5 ) ; // #3609 CWinTraits<WS_CHILD|WS_VISIBLE>..
2011-10-06 22:01:48 +02:00
TEST_CASE ( bitwiseOnBoolean ) ; // if (bool & bool)
2011-03-09 22:20:14 +01:00
2012-04-02 15:45:51 +02:00
TEST_CASE ( comparisonOfBoolExpressionWithInt1 ) ;
TEST_CASE ( comparisonOfBoolExpressionWithInt2 ) ;
2012-05-22 19:01:21 +02:00
TEST_CASE ( comparisonOfBoolExpressionWithInt3 ) ;
2011-10-10 19:11:17 +02:00
2011-02-08 19:49:29 +01:00
TEST_CASE ( incorrectStringCompare ) ;
2011-02-11 23:38:23 +01:00
TEST_CASE ( incrementBoolean ) ;
2011-10-05 20:30:36 +02:00
TEST_CASE ( comparisonOfBoolWithInt1 ) ;
TEST_CASE ( comparisonOfBoolWithInt2 ) ;
TEST_CASE ( comparisonOfBoolWithInt3 ) ;
TEST_CASE ( comparisonOfBoolWithInt4 ) ;
2011-11-06 08:21:34 +01:00
TEST_CASE ( comparisonOfBoolWithInt5 ) ;
2011-04-09 21:14:01 +02:00
TEST_CASE ( duplicateIf ) ;
2012-05-14 09:57:30 +02:00
TEST_CASE ( duplicateIf1 ) ; // ticket 3689
2011-04-09 23:05:27 +02:00
TEST_CASE ( duplicateBranch ) ;
2012-05-30 01:30:37 +02:00
TEST_CASE ( duplicateBranch1 ) ; // tests extracted by http://www.viva64.com/en/b/0149/ ( Comparision between PVS-Studio and cppcheck ): Errors detected in Quake 3: Arena by PVS-Studio: Fragement 2
2011-04-19 01:20:27 +02:00
TEST_CASE ( duplicateExpression1 ) ;
TEST_CASE ( duplicateExpression2 ) ; // ticket #2730
2011-11-10 21:49:14 +01:00
TEST_CASE ( duplicateExpression3 ) ; // ticket #3317
2011-12-01 17:46:33 +01:00
TEST_CASE ( duplicateExpression4 ) ; // ticket #3354 (++)
2012-05-17 07:26:57 +02:00
TEST_CASE ( duplicateExpression5 ) ; // ticket #3749 (macros with same values)
2011-04-26 07:45:27 +02:00
TEST_CASE ( alwaysTrueFalseStringCompare ) ;
2012-03-23 21:47:13 +01:00
TEST_CASE ( checkPointerSizeof ) ;
2011-08-07 01:23:09 +02:00
TEST_CASE ( checkSignOfUnsignedVariable ) ;
2011-10-11 08:41:39 +02:00
TEST_CASE ( checkForSuspiciousSemicolon1 ) ;
TEST_CASE ( checkForSuspiciousSemicolon2 ) ;
2012-01-15 01:19:34 +01:00
TEST_CASE ( checkDoubleFree ) ;
2008-12-19 22:15:18 +01:00
}
2012-04-05 10:38:29 +02:00
void check ( const char code [ ] , const char * filename = NULL , bool experimental = false , bool inconclusive = true ) {
2010-12-01 18:00:55 +01:00
// Clear the error buffer..
errout . str ( " " ) ;
Settings settings ;
2011-08-07 09:28:08 +02:00
settings . addEnabled ( " style " ) ;
2012-04-05 10:38:29 +02:00
settings . inconclusive = inconclusive ;
2011-11-21 07:31:06 +01:00
settings . experimental = experimental ;
2010-12-01 18:00:55 +01:00
2008-12-19 22:15:18 +01:00
// Tokenize..
2010-12-01 18:00:55 +01:00
Tokenizer tokenizer ( & settings , this ) ;
2008-12-19 22:15:18 +01:00
std : : istringstream istr ( code ) ;
2010-12-25 08:43:52 +01:00
tokenizer . tokenize ( istr , filename ? filename : " test.cpp " ) ;
2008-12-19 22:15:18 +01:00
2010-04-21 08:38:25 +02:00
// Check..
2009-03-20 18:16:21 +01:00
CheckOther checkOther ( & tokenizer , & settings , this ) ;
2011-10-23 12:20:43 +02:00
checkOther . runChecks ( & tokenizer , & settings , this ) ;
2010-05-15 14:06:45 +02:00
// Simplify token list..
tokenizer . simplifyTokenList ( ) ;
2011-10-23 12:20:43 +02:00
checkOther . runSimplifiedChecks ( & tokenizer , & settings , this ) ;
2008-12-19 22:15:18 +01:00
}
2011-10-13 20:53:06 +02:00
class SimpleSuppressor : public ErrorLogger {
2011-02-19 09:33:29 +01:00
public :
SimpleSuppressor ( Settings & settings , ErrorLogger * next )
: _settings ( settings ) , _next ( next )
{ }
2011-10-13 20:53:06 +02:00
virtual void reportOut ( const std : : string & outmsg ) {
2011-02-19 09:33:29 +01:00
_next - > reportOut ( outmsg ) ;
}
2011-10-13 20:53:06 +02:00
virtual void reportErr ( const ErrorLogger : : ErrorMessage & msg ) {
2011-02-19 09:33:29 +01:00
if ( ! msg . _callStack . empty ( ) & & ! _settings . nomsg . isSuppressed ( msg . _id , msg . _callStack . begin ( ) - > getfile ( ) , msg . _callStack . begin ( ) - > line ) )
_next - > reportErr ( msg ) ;
}
private :
Settings & _settings ;
ErrorLogger * _next ;
} ;
2011-10-13 20:53:06 +02:00
void check_preprocess_suppress ( const char precode [ ] , const char * filename = NULL ) {
2011-02-19 09:33:29 +01:00
// Clear the error buffer..
errout . str ( " " ) ;
if ( filename = = NULL )
filename = " test.cpp " ;
Settings settings ;
2011-08-07 09:28:08 +02:00
settings . addEnabled ( " style " ) ;
2011-09-03 15:30:30 +02:00
settings . addEnabled ( " performance " ) ;
2011-04-10 15:55:08 +02:00
settings . experimental = true ;
2011-02-19 09:33:29 +01:00
// Preprocess file..
2012-01-06 08:01:50 +01:00
SimpleSuppressor logger ( settings , this ) ;
Preprocessor preprocessor ( & settings , & logger ) ;
2011-02-19 09:33:29 +01:00
std : : list < std : : string > configurations ;
std : : string filedata = " " ;
std : : istringstream fin ( precode ) ;
preprocessor . preprocess ( fin , filedata , configurations , filename , settings . _includePaths ) ;
2012-01-06 08:01:50 +01:00
const std : : string code = preprocessor . getcode ( filedata , " " , filename ) ;
2011-02-19 09:33:29 +01:00
// Tokenize..
Tokenizer tokenizer ( & settings , & logger ) ;
std : : istringstream istr ( code ) ;
tokenizer . tokenize ( istr , filename ) ;
2011-03-04 08:26:14 +01:00
tokenizer . simplifyGoto ( ) ;
2011-02-19 09:33:29 +01:00
// Check..
CheckOther checkOther ( & tokenizer , & settings , & logger ) ;
checkOther . checkSwitchCaseFallThrough ( ) ;
2011-04-26 07:45:27 +02:00
checkOther . checkAlwaysTrueOrFalseStringCompare ( ) ;
2011-02-19 20:02:28 +01:00
logger . reportUnmatchedSuppressions ( settings . nomsg . getUnmatchedLocalSuppressions ( filename ) ) ;
2011-02-19 09:33:29 +01:00
}
2009-03-27 17:19:34 +01:00
2011-10-13 20:53:06 +02:00
void assignBoolToPointer ( ) {
2011-07-28 07:28:24 +02:00
check ( " void foo(bool *p) { \n "
" p = false; \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:2]: (error) Assigning bool value to pointer (converting bool value to address) \n " , errout . str ( ) ) ;
}
2011-10-13 20:53:06 +02:00
void zeroDiv1 ( ) {
2009-03-28 07:49:47 +01:00
check ( " void foo() \n "
" { \n "
" int a = 0; \n "
" double b = 1.; \n "
" cout<<b/a; \n "
" } " ) ;
2009-05-31 21:48:55 +02:00
ASSERT_EQUALS ( " [test.cpp:5]: (error) Division by zero \n " , errout . str ( ) ) ;
2009-03-28 07:49:47 +01:00
}
2011-10-13 20:53:06 +02:00
void zeroDiv2 ( ) {
2009-03-28 07:49:47 +01:00
check ( " void foo() \n "
" { \n "
" int sum = 0; \n "
" int n = 100; \n "
" for(int i = 0; i < n; i ++) \n "
" { \n "
" sum += i; \n "
" } \n "
" cout<<b/sum; \n "
" } \n " ) ;
2009-06-05 02:39:36 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2009-03-28 07:49:47 +01:00
2009-06-05 23:33:13 +02:00
check ( " void foo() \n "
" { \n "
" int a = 0 ? (2/0) : 0; \n "
" } \n " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2009-03-28 07:49:47 +01:00
2011-10-13 20:53:06 +02:00
void zeroDiv3 ( ) {
2009-08-23 05:34:19 +02:00
check ( " void f() \n "
" { \n "
" div_t divresult = div (1,0); \n "
" } \n " ) ;
ASSERT_EQUALS ( " [test.cpp:3]: (error) Division by zero \n " , errout . str ( ) ) ;
}
2011-10-13 20:53:06 +02:00
void zeroDiv4 ( ) {
2009-08-30 21:02:09 +02:00
check ( " void f() \n "
" { \n "
" long a = b / 0x6; \n "
" } \n " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check ( " void f() \n "
" { \n "
" long a = b / 0x0; \n "
" } \n " ) ;
ASSERT_EQUALS ( " [test.cpp:3]: (error) Division by zero \n " , errout . str ( ) ) ;
check ( " void f() \n "
" { \n "
" long a = b / 0L; \n "
" } \n " ) ;
ASSERT_EQUALS ( " [test.cpp:3]: (error) Division by zero \n " , errout . str ( ) ) ;
check ( " void f() \n "
" { \n "
" long a = b / 0ul; \n "
" } \n " ) ;
ASSERT_EQUALS ( " [test.cpp:3]: (error) Division by zero \n " , errout . str ( ) ) ;
check ( " void f() \n "
" { \n "
" div_t divresult = div (1,0L); \n "
" } \n " ) ;
ASSERT_EQUALS ( " [test.cpp:3]: (error) Division by zero \n " , errout . str ( ) ) ;
check ( " void f() \n "
" { \n "
" div_t divresult = div (1,0x5); \n "
" } \n " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2009-09-01 16:00:26 +02:00
2009-09-01 21:06:46 +02:00
// Don't warn about floating points (gcc doesn't warn either)
// and floating points are handled differently than integers.
2009-09-01 16:00:26 +02:00
check ( " void f() \n "
" { \n "
" long a = b / 0.0; \n "
" } \n " ) ;
2009-09-01 21:06:46 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2009-09-01 16:00:26 +02:00
check ( " void f() \n "
" { \n "
" long a = b / 0.5; \n "
" } \n " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2009-09-01 21:06:46 +02:00
// Don't warn about 0.0
2009-09-01 16:00:26 +02:00
check ( " void f() \n "
" { \n "
" div_t divresult = div (1,0.0); \n "
" } \n " ) ;
2009-09-01 21:06:46 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2009-09-01 16:00:26 +02:00
check ( " void f() \n "
" { \n "
" div_t divresult = div (1,0.5); \n "
" } \n " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2009-08-30 21:02:09 +02:00
}
2011-10-13 20:53:06 +02:00
void zeroDiv5 ( ) {
2011-08-24 02:12:29 +02:00
check ( " void f() \n "
" { { { \n "
" long a = b / 0; \n "
" } } } \n " ) ;
ASSERT_EQUALS ( " [test.cpp:3]: (error) Division by zero \n " , errout . str ( ) ) ;
}
2011-10-13 20:53:06 +02:00
void zeroDiv6 ( ) {
2011-09-10 16:12:53 +02:00
check ( " void f() \n "
" { { { \n "
" int a = b % 0; \n "
" } } } \n " ) ;
ASSERT_EQUALS ( " [test.cpp:3]: (error) Division by zero \n " , errout . str ( ) ) ;
}
2009-01-08 22:08:14 +01:00
2011-10-13 20:53:06 +02:00
void sprintfUsage ( const char code [ ] ) {
2010-12-01 18:00:55 +01:00
// Clear the error buffer..
errout . str ( " " ) ;
Settings settings ;
2009-01-08 07:24:08 +01:00
// Tokenize..
2010-12-01 18:00:55 +01:00
Tokenizer tokenizer ( & settings , this ) ;
2009-01-08 07:24:08 +01:00
std : : istringstream istr ( code ) ;
tokenizer . tokenize ( istr , " test.cpp " ) ;
2009-01-11 11:03:21 +01:00
//tokenizer.tokens()->printOut( "tokens" );
2009-01-08 07:24:08 +01:00
// Check for redundant code..
2009-03-20 18:16:21 +01:00
CheckOther checkOther ( & tokenizer , & settings , this ) ;
2009-07-05 22:16:43 +02:00
checkOther . invalidFunctionUsage ( ) ;
2009-01-08 07:24:08 +01:00
}
2009-01-08 22:08:14 +01:00
2011-10-13 20:53:06 +02:00
void sprintf1 ( ) {
2009-01-08 22:08:14 +01:00
sprintfUsage ( " void foo() \n "
" { \n "
" char buf[100]; \n "
" sprintf(buf, \" %s \" ,buf); \n "
" } \n " ) ;
2010-12-26 20:40:58 +01:00
ASSERT_EQUALS ( " [test.cpp:4]: (error) Undefined behavior: variable is used as parameter and destination in s[n]printf(). \n " , errout . str ( ) ) ;
2009-01-08 07:24:08 +01:00
}
2009-01-10 12:19:17 +01:00
2011-10-13 20:53:06 +02:00
void sprintf2 ( ) {
2009-01-10 12:19:17 +01:00
sprintfUsage ( " void foo() \n "
" { \n "
" char buf[100]; \n "
" sprintf(buf, \" %i \" ,sizeof(buf)); \n "
" } \n " ) ;
2009-06-05 02:39:36 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2009-01-10 12:19:17 +01:00
}
2009-01-10 15:27:31 +01:00
2011-10-13 20:53:06 +02:00
void sprintf3 ( ) {
2009-01-10 15:27:31 +01:00
sprintfUsage ( " void foo() \n "
" { \n "
" char buf[100]; \n "
" sprintf(buf, \" %i \" ,sizeof(buf)); \n "
2009-01-10 15:29:59 +01:00
" if (buf[0]); \n "
2009-01-10 15:27:31 +01:00
" } \n " ) ;
2009-06-05 02:39:36 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2009-01-10 15:29:59 +01:00
}
2009-01-10 15:27:31 +01:00
2011-10-13 20:53:06 +02:00
void sprintf4 ( ) {
2009-01-11 11:03:21 +01:00
sprintfUsage ( " struct A \n "
" { \n "
" char filename[128]; \n "
" }; \n "
" \n "
" void foo() \n "
" { \n "
" const char* filename = \" hello \" ; \n "
" struct A a; \n "
" snprintf(a.filename, 128, \" %s \" , filename); \n "
" } \n " ) ;
2009-06-05 02:39:36 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2009-01-11 11:03:21 +01:00
}
2009-01-15 17:57:51 +01:00
2011-10-13 20:53:06 +02:00
void strPlusChar ( const char code [ ] ) {
2010-12-01 18:00:55 +01:00
// Clear the error buffer..
errout . str ( " " ) ;
Settings settings ;
2009-01-15 17:57:51 +01:00
// Tokenize..
2010-12-01 18:00:55 +01:00
Tokenizer tokenizer ( & settings , this ) ;
2009-01-15 17:57:51 +01:00
std : : istringstream istr ( code ) ;
tokenizer . tokenize ( istr , " test.cpp " ) ;
// Check for redundant code..
2009-03-20 18:16:21 +01:00
CheckOther checkOther ( & tokenizer , & settings , this ) ;
2009-01-15 17:57:51 +01:00
checkOther . strPlusChar ( ) ;
}
2011-10-13 20:53:06 +02:00
void strPlusChar1 ( ) {
2009-01-15 17:57:51 +01:00
// Strange looking pointer arithmetic..
strPlusChar ( " void foo() \n "
" { \n "
" const char *p = \" /usr \" + '/'; \n "
" } \n " ) ;
2009-05-31 21:48:55 +02:00
ASSERT_EQUALS ( " [test.cpp:3]: (error) Unusual pointer arithmetic \n " , errout . str ( ) ) ;
2009-01-15 17:57:51 +01:00
}
2011-10-13 20:53:06 +02:00
void strPlusChar2 ( ) {
2009-01-15 18:12:33 +01:00
// Strange looking pointer arithmetic..
strPlusChar ( " void foo() \n "
" { \n "
2010-02-07 21:44:11 +01:00
" char ch = 1; \n "
" const char *p = ch + \" /usr \" ; \n "
2009-01-15 18:12:33 +01:00
" } \n " ) ;
2010-02-07 21:44:11 +01:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2010-02-08 08:35:53 +01:00
// Strange looking pointer arithmetic..
2010-02-07 21:44:11 +01:00
strPlusChar ( " void foo() \n "
" { \n "
" int i = 1; \n "
2010-02-22 21:30:21 +01:00
" const char* psz = \" Bla \" ; \n "
2010-02-07 21:44:11 +01:00
" const std::string str = i + psz; \n "
" } \n " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2010-02-08 08:35:53 +01:00
}
2009-01-15 18:12:33 +01:00
2011-10-13 20:53:06 +02:00
void strPlusChar3 ( ) {
2009-01-18 18:42:41 +01:00
// Strange looking pointer arithmetic..
strPlusChar ( " void foo() \n "
" { \n "
" std::string temp = \" /tmp \" ; \n "
" std::string path = temp + '/' + \" sub \" + '/'; \n "
" } \n " ) ;
2009-06-05 02:39:36 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2009-01-18 18:42:41 +01:00
}
2009-02-04 19:49:19 +01:00
2011-10-13 20:53:06 +02:00
void varScope ( const char code [ ] ) {
2009-03-24 20:24:03 +01:00
// Clear the error buffer..
errout . str ( " " ) ;
Settings settings ;
2011-10-30 11:21:46 +01:00
settings . addEnabled ( " style " ) ;
2010-12-01 18:00:55 +01:00
// Tokenize..
Tokenizer tokenizer ( & settings , this ) ;
std : : istringstream istr ( code ) ;
tokenizer . tokenize ( istr , " test.cpp " ) ;
// Check for redundant code..
2009-03-24 20:24:03 +01:00
CheckOther checkOther ( & tokenizer , & settings , this ) ;
2009-07-05 22:16:43 +02:00
checkOther . checkVariableScope ( ) ;
2009-03-24 20:24:03 +01:00
}
2011-10-13 20:53:06 +02:00
void varScope1 ( ) {
2009-03-24 20:24:03 +01:00
varScope ( " unsigned short foo() \n "
" { \n "
" test_client CClient; \n "
" try \n "
" { \n "
" if (CClient.Open()) \n "
" { \n "
" return 0; \n "
" } \n "
" } \n "
" catch (...) \n "
" { \n "
" return 2; \n "
" } \n "
" \n "
" try \n "
" { \n "
" CClient.Close(); \n "
" } \n "
" catch (...) \n "
" { \n "
" return 2; \n "
" } \n "
" \n "
" return 1; \n "
" } \n " ) ;
2009-06-05 02:39:36 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2009-03-24 20:24:03 +01:00
}
2009-03-24 20:59:56 +01:00
2011-10-13 20:53:06 +02:00
void varScope2 ( ) {
2009-03-24 20:59:56 +01:00
varScope ( " int foo() \n "
" { \n "
" Error e; \n "
" e.SetValue(12); \n "
" throw e; \n "
" } \n " ) ;
2009-06-05 02:39:36 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2009-03-24 20:59:56 +01:00
}
2009-03-27 17:19:34 +01:00
2011-10-13 20:53:06 +02:00
void varScope3 ( ) {
2009-05-27 19:38:26 +02:00
varScope ( " void foo() \n "
" { \n "
" int i; \n "
" int *p = 0; \n "
" if (abc) \n "
" { \n "
" p = &i; \n "
" } \n "
" *p = 1; \n "
" } \n " ) ;
2009-06-05 02:39:36 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2009-05-27 19:38:26 +02:00
}
2011-10-13 20:53:06 +02:00
void varScope4 ( ) {
2009-06-12 16:17:51 +02:00
varScope ( " void foo() \n "
" { \n "
" int i; \n "
" } \n " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2011-10-13 20:53:06 +02:00
void varScope5 ( ) {
2009-09-29 23:56:43 +02:00
varScope ( " void f(int x) \n "
" { \n "
" int i = 0; \n "
" if (x) { \n "
" for ( ; i < 10; ++i) ; \n "
" } \n "
" } \n " ) ;
2011-10-05 19:44:00 +02:00
ASSERT_EQUALS ( " [test.cpp:3]: (style) The scope of the variable 'i' can be reduced \n " , errout . str ( ) ) ;
2009-09-29 23:56:43 +02:00
2012-05-24 15:34:59 +02:00
varScope ( " void f(int x) { \n "
" const unsigned char i = 0; \n "
" if (x) { \n "
" for ( ; i < 10; ++i) ; \n "
" } \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:2]: (style) The scope of the variable 'i' can be reduced \n " , errout . str ( ) ) ;
2009-09-29 23:56:43 +02:00
varScope ( " void f(int x) \n "
2009-08-16 21:12:57 +02:00
" { \n "
" int i = 0; \n "
2009-09-29 23:56:43 +02:00
" if (x) {b()} \n "
" else { \n "
2009-08-16 21:12:57 +02:00
" for ( ; i < 10; ++i) ; \n "
" } \n "
" } \n " ) ;
2011-10-05 19:44:00 +02:00
ASSERT_EQUALS ( " [test.cpp:3]: (style) The scope of the variable 'i' can be reduced \n " , errout . str ( ) ) ;
2009-08-16 21:12:57 +02:00
}
2009-03-27 17:19:34 +01:00
2011-10-13 20:53:06 +02:00
void varScope6 ( ) {
2009-09-17 21:05:12 +02:00
varScope ( " void f(int x) \n "
" { \n "
" int i = x; \n "
" if (a) { \n "
" x++; \n "
" } \n "
" if (b) { \n "
" c(i); \n "
" } \n "
" } \n " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2009-09-29 23:56:43 +02:00
varScope ( " void f() \n "
" { \n "
" int foo = 0; \n "
" std::vector<int> vec(10); \n "
" BOOST_FOREACH(int& i, vec) \n "
" { \n "
" foo += 1; \n "
" if(foo == 10) \n "
" { \n "
" return 0; \n "
" } \n "
" } \n "
" } \n " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2009-03-27 17:19:34 +01:00
2009-09-29 23:56:43 +02:00
varScope ( " void f(int &x) \n "
" { \n "
" int n = 1; \n "
" do \n "
" { \n "
" ++n; \n "
" ++x; \n "
" } while (x); \n "
" } \n " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2009-03-27 17:19:34 +01:00
2011-10-13 20:53:06 +02:00
void varScope7 ( ) {
2009-10-06 17:45:28 +02:00
varScope ( " void f(int x) \n "
" { \n "
" int y = 0; \n "
" b(y); \n "
" if (x) { \n "
" y++; \n "
" } \n "
" } \n " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2011-10-13 20:53:06 +02:00
void varScope8 ( ) {
2010-01-21 18:50:56 +01:00
varScope ( " void test() { \n "
" float edgeResistance=1; \n "
" std::vector<int> edges; \n "
" BOOST_FOREACH(int edge, edges) { \n "
" edgeResistance = (edge+1) / 2.0; \n "
" } \n "
" } \n " ) ;
2011-10-05 19:44:00 +02:00
ASSERT_EQUALS ( " [test.cpp:2]: (style) The scope of the variable 'edgeResistance' can be reduced \n " , errout . str ( ) ) ;
2010-01-21 18:50:56 +01:00
}
2011-10-13 20:53:06 +02:00
void varScope9 ( ) {
2010-04-09 16:53:27 +02:00
// classes may have extra side effects
varScope ( " class fred { \n "
" public: \n "
" void x(); \n "
" }; \n "
" void test(int a) { \n "
" fred f; \n "
" if (a == 2) { \n "
" f.x(); \n "
" } \n "
" } \n " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2011-10-13 20:53:06 +02:00
void varScope10 ( ) {
2010-08-26 21:57:48 +02:00
// classes may have extra side effects
varScope ( " int f() \n "
" { \n "
" int x = 0; \n "
" FOR { \n "
" foo(x++); \n "
" } \n "
" } \n " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2011-10-13 20:53:06 +02:00
void varScope11 ( ) {
2011-01-17 20:51:15 +01:00
varScope ( " int f() { \n "
" int x = 0; \n "
" AB ab = { x, 0 }; \n "
" } \n " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
varScope ( " int f() { \n "
" int x = 0; \n "
" if (a == 0) { ++x; } \n "
" AB ab = { x, 0 }; \n "
" } \n " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
varScope ( " int f() { \n "
" int x = 0; \n "
" if (a == 0) { ++x; } \n "
" if (a == 1) { AB ab = { x, 0 }; } \n "
" } \n " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2011-10-13 20:53:06 +02:00
void varScope12 ( ) {
2012-05-24 15:34:59 +02:00
varScope ( " void f(int x) { \n "
" int i[5]; \n "
" int* j = y; \n "
" if (x) \n "
" foo(i); \n "
" foo(j); \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:2]: (style) The scope of the variable 'i' can be reduced \n " , errout . str ( ) ) ;
varScope ( " void f(int x) { \n "
" int i[5]; \n "
" int* j; \n "
" if (x) \n "
" j = i; \n "
" foo(j); \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
varScope ( " void f(int x) { \n "
" const bool b = true; \n "
" x++; \n "
" if (x == 5) \n "
" foo(b); \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:2]: (style) The scope of the variable 'b' can be reduced \n " , errout . str ( ) ) ;
varScope ( " void f(int x) { \n "
" const bool b = x; \n "
" x++; \n "
" if (x == 5) \n "
" foo(b); \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
void varScope13 ( ) {
2011-05-06 21:16:01 +02:00
// #2770
varScope ( " void f() { \n "
" int i = 0; \n "
" forever { \n "
" if (i++ == 42) { break; } \n "
" } \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2010-01-21 18:50:56 +01:00
2011-10-13 20:53:06 +02:00
void checkOldStylePointerCast ( const char code [ ] ) {
2010-12-01 18:00:55 +01:00
// Clear the error buffer..
errout . str ( " " ) ;
Settings settings ;
2011-08-07 09:28:08 +02:00
settings . addEnabled ( " style " ) ;
2010-12-01 18:00:55 +01:00
2009-06-18 22:26:21 +02:00
// Tokenize..
2010-12-01 18:00:55 +01:00
Tokenizer tokenizerCpp ( & settings , this ) ;
2009-06-18 22:26:21 +02:00
std : : istringstream istr ( code ) ;
2010-04-24 16:46:09 +02:00
tokenizerCpp . tokenize ( istr , " test.cpp " ) ;
2010-12-01 18:00:55 +01:00
Tokenizer tokenizerC ( & settings , this ) ;
2010-04-24 16:46:09 +02:00
std : : istringstream istr2 ( code ) ;
tokenizerC . tokenize ( istr2 , " test.c " ) ;
2009-06-18 22:26:21 +02:00
2010-04-24 16:46:09 +02:00
CheckOther checkOtherCpp ( & tokenizerCpp , & settings , this ) ;
checkOtherCpp . warningOldStylePointerCast ( ) ;
CheckOther checkOtherC ( & tokenizerC , & settings , this ) ;
checkOtherC . warningOldStylePointerCast ( ) ;
2009-06-18 22:26:21 +02:00
}
2011-10-13 20:53:06 +02:00
void oldStylePointerCast ( ) {
2009-06-19 12:01:27 +02:00
checkOldStylePointerCast ( " class Base; \n "
" void foo() \n "
" { \n "
" Base * b = (Base *) derived; \n "
" } \n " ) ;
ASSERT_EQUALS ( " [test.cpp:4]: (style) C-style pointer casting \n " , errout . str ( ) ) ;
2009-07-20 21:52:27 +02:00
checkOldStylePointerCast ( " class Base; \n "
" void foo() \n "
" { \n "
" Base * b = (const Base *) derived; \n "
" } \n " ) ;
ASSERT_EQUALS ( " [test.cpp:4]: (style) C-style pointer casting \n " , errout . str ( ) ) ;
2009-06-19 12:01:27 +02:00
2009-09-24 22:46:08 +02:00
checkOldStylePointerCast ( " class Base; \n "
" void foo() \n "
" { \n "
" Base * b = (const Base *) ( new Derived() ); \n "
" } \n " ) ;
ASSERT_EQUALS ( " [test.cpp:4]: (style) C-style pointer casting \n " , errout . str ( ) ) ;
checkOldStylePointerCast ( " class Base; \n "
" void foo() \n "
" { \n "
" Base * b = (const Base *) new Derived(); \n "
" } \n " ) ;
ASSERT_EQUALS ( " [test.cpp:4]: (style) C-style pointer casting \n " , errout . str ( ) ) ;
checkOldStylePointerCast ( " class Base; \n "
" void foo() \n "
" { \n "
" Base * b = (const Base *) new short[10]; \n "
" } \n " ) ;
ASSERT_EQUALS ( " [test.cpp:4]: (style) C-style pointer casting \n " , errout . str ( ) ) ;
2009-06-18 22:26:21 +02:00
checkOldStylePointerCast ( " class B; \n "
" class A \n "
" { \n "
" virtual void abc(B *) const = 0; \n "
" } \n " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2009-07-20 21:52:27 +02:00
checkOldStylePointerCast ( " class B; \n "
" class A \n "
" { \n "
" virtual void abc(const B *) const = 0; \n "
" } \n " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2009-06-18 22:26:21 +02:00
}
2012-03-25 12:55:39 +02:00
void checkInvalidPointerCast ( const char code [ ] , bool portability = false , bool inconclusive = false ) {
2012-02-26 11:56:32 +01:00
// Clear the error buffer..
errout . str ( " " ) ;
Settings settings ;
settings . addEnabled ( " style " ) ;
if ( portability )
settings . addEnabled ( " portability " ) ;
2012-03-25 12:55:39 +02:00
settings . inconclusive = inconclusive ;
2012-02-26 11:56:32 +01:00
// Tokenize..
Tokenizer tokenizer ( & settings , this ) ;
std : : istringstream istr ( code ) ;
tokenizer . tokenize ( istr , " test.cpp " ) ;
CheckOther checkOtherCpp ( & tokenizer , & settings , this ) ;
checkOtherCpp . invalidPointerCast ( ) ;
}
void invalidPointerCast ( ) {
checkInvalidPointerCast ( " void test() { \n "
" float *f = new float[10]; \n "
" delete [] (double*)f; \n "
" delete [] (long double const*)(new float[10]); \n "
" } " ) ;
TODO_ASSERT_EQUALS ( " [test.cpp:3]: (warning) Casting between float* and double* which have an incompatible binary data representation \n "
" [test.cpp:4]: (warning) Casting between float* and long double* which have an incompatible binary data representation \n " ,
" [test.cpp:3]: (warning) Casting between float* and double* which have an incompatible binary data representation \n "
" [test.cpp:4]: (warning) Casting between float* and double* which have an incompatible binary data representation \n " , errout . str ( ) ) ;
checkInvalidPointerCast ( " void test(const float* f) { \n "
" double *d = (double*)f; \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:2]: (warning) Casting between float* and double* which have an incompatible binary data representation \n " , errout . str ( ) ) ;
checkInvalidPointerCast ( " void test(double* d1) { \n "
" long double *ld = (long double*)d1; \n "
" double *d2 = (double*)ld; \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:2]: (warning) Casting between double* and long double* which have an incompatible binary data representation \n "
" [test.cpp:3]: (warning) Casting between long double* and double* which have an incompatible binary data representation \n " , errout . str ( ) ) ;
checkInvalidPointerCast ( " char* test(int* i) { \n "
" long double *d = (long double*)(i); \n "
" double *d = (double*)(i); \n "
" float *f = reinterpret_cast<float*>(i); \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:2]: (warning) Casting between integer* and long double* which have an incompatible binary data representation \n "
" [test.cpp:3]: (warning) Casting between integer* and double* which have an incompatible binary data representation \n "
" [test.cpp:4]: (warning) Casting between integer* and float* which have an incompatible binary data representation \n " , errout . str ( ) ) ;
checkInvalidPointerCast ( " float* test(unsigned int* i) { \n "
" return (float*)i; \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:2]: (warning) Casting between integer* and float* which have an incompatible binary data representation \n " , errout . str ( ) ) ;
checkInvalidPointerCast ( " float* test(unsigned int* i) { \n "
" return (float*)i[0]; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
checkInvalidPointerCast ( " float* test(double& d) { \n "
" return (float*)&d; \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:2]: (warning) Casting between double* and float* which have an incompatible binary data representation \n " , errout . str ( ) ) ;
2012-05-06 19:37:41 +02:00
checkInvalidPointerCast ( " void test(float* data) { \n "
2012-03-25 12:55:39 +02:00
" f.write((char*)data,sizeof(float)); \n "
" } " , true , false ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
checkInvalidPointerCast ( " void test(float* data) { \n "
" f.write((char*)data,sizeof(float)); \n "
2012-05-06 19:37:41 +02:00
" } " , true , true ) ; // #3639
ASSERT_EQUALS ( " [test.cpp:2]: (portability, inconclusive) Casting from float* to char* might be not portable due to different binary data representations on different platforms \n " , errout . str ( ) ) ;
2012-03-25 12:55:39 +02:00
2012-02-26 11:56:32 +01:00
checkInvalidPointerCast ( " long long* test(float* f) { \n "
" return (long long*)f; \n "
" } " , false ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
checkInvalidPointerCast ( " long long* test(float* f, char* c) { \n "
" foo((long long*)f); \n "
" return reinterpret_cast<long long*>(c); \n "
" } " , true ) ;
ASSERT_EQUALS ( " [test.cpp:2]: (portability) Casting from float* to integer* is not portable due to different binary data representations on different platforms \n " , errout . str ( ) ) ;
}
2011-10-13 20:53:06 +02:00
void dangerousStrolUsage ( ) {
2009-10-04 10:05:58 +02:00
{
sprintfUsage ( " int f(const char *num) \n "
" { \n "
" return strtol(num, NULL, 1); \n "
" } \n " ) ;
ASSERT_EQUALS ( " [test.cpp:3]: (error) Invalid radix in call to strtol or strtoul. Must be 0 or 2-36 \n " , errout . str ( ) ) ;
}
{
sprintfUsage ( " int f(const char *num) \n "
" { \n "
" return strtol(num, NULL, 10); \n "
" } \n " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
}
2011-10-13 20:53:06 +02:00
void testPassedByValue ( const char code [ ] ) {
2009-10-04 10:05:58 +02:00
// Clear the error buffer..
errout . str ( " " ) ;
Settings settings ;
2011-09-03 15:30:30 +02:00
settings . addEnabled ( " performance " ) ;
2010-12-01 18:00:55 +01:00
Tokenizer tokenizer ( & settings , this ) ;
std : : istringstream istr ( code ) ;
tokenizer . tokenize ( istr , " test.cpp " ) ;
2009-10-04 10:05:58 +02:00
CheckOther checkOther ( & tokenizer , & settings , this ) ;
checkOther . checkConstantFunctionParameter ( ) ;
}
2011-10-13 20:53:06 +02:00
void passedByValue ( ) {
2009-10-06 23:04:54 +02:00
testPassedByValue ( " void f(const std::string str) {} " ) ;
2010-11-27 09:46:34 +01:00
ASSERT_EQUALS ( " [test.cpp:1]: (performance) Function parameter 'str' should be passed by reference. \n " , errout . str ( ) ) ;
2009-10-04 10:05:58 +02:00
2009-10-06 23:04:54 +02:00
testPassedByValue ( " class Foo; \n void f(const Foo foo) {} " ) ;
2010-11-27 09:46:34 +01:00
ASSERT_EQUALS ( " [test.cpp:2]: (performance) Function parameter 'foo' should be passed by reference. \n " , errout . str ( ) ) ;
2009-10-04 10:05:58 +02:00
2009-10-06 23:04:54 +02:00
testPassedByValue ( " void f(const std::string &str) {} " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2009-10-04 10:05:58 +02:00
2009-10-06 23:04:54 +02:00
testPassedByValue ( " void f(const std::vector<int> v) {} " ) ;
2010-11-27 09:46:34 +01:00
ASSERT_EQUALS ( " [test.cpp:1]: (performance) Function parameter 'v' should be passed by reference. \n " , errout . str ( ) ) ;
2009-10-04 10:05:58 +02:00
2009-10-06 23:04:54 +02:00
testPassedByValue ( " void f(const std::vector<std::string> v) {} " ) ;
2010-11-27 09:46:34 +01:00
ASSERT_EQUALS ( " [test.cpp:1]: (performance) Function parameter 'v' should be passed by reference. \n " , errout . str ( ) ) ;
2009-10-05 10:59:28 +02:00
2009-10-06 23:04:54 +02:00
testPassedByValue ( " void f(const std::vector<int> &v) {} " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2009-10-05 10:59:28 +02:00
2009-10-06 23:04:54 +02:00
testPassedByValue ( " void f(const std::map<int,int> &v) {} " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2009-10-05 10:59:28 +02:00
2009-10-06 23:04:54 +02:00
testPassedByValue ( " void f(const std::map<int,int> v) {} " ) ;
2010-11-27 09:46:34 +01:00
ASSERT_EQUALS ( " [test.cpp:1]: (performance) Function parameter 'v' should be passed by reference. \n " , errout . str ( ) ) ;
2009-10-05 10:59:28 +02:00
2009-10-06 23:04:54 +02:00
testPassedByValue ( " void f(const std::map<std::string,std::string> v) {} " ) ;
2010-11-27 09:46:34 +01:00
ASSERT_EQUALS ( " [test.cpp:1]: (performance) Function parameter 'v' should be passed by reference. \n " , errout . str ( ) ) ;
2009-10-05 10:59:28 +02:00
2009-10-06 23:04:54 +02:00
testPassedByValue ( " void f(const std::map<int,std::string> v) {} " ) ;
2010-11-27 09:46:34 +01:00
ASSERT_EQUALS ( " [test.cpp:1]: (performance) Function parameter 'v' should be passed by reference. \n " , errout . str ( ) ) ;
2009-10-05 10:59:28 +02:00
2009-10-06 23:04:54 +02:00
testPassedByValue ( " void f(const std::map<std::string,int> v) {} " ) ;
2010-11-27 09:46:34 +01:00
ASSERT_EQUALS ( " [test.cpp:1]: (performance) Function parameter 'v' should be passed by reference. \n " , errout . str ( ) ) ;
2011-04-19 20:07:54 +02:00
testPassedByValue ( " void f(const std::streamoff pos) {} " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2009-10-04 10:05:58 +02:00
}
2011-10-13 20:53:06 +02:00
void mathfunctionCall1 ( ) {
2010-04-02 20:42:06 +02:00
// log|log10
2010-04-02 02:19:38 +02:00
check ( " void foo() \n "
" { \n "
" std::cout << log(-2) << std::endl; \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:3]: (error) Passing value -2 to log() leads to undefined result \n " , errout . str ( ) ) ;
check ( " void foo() \n "
" { \n "
" std::cout << log(-1.) << std::endl; \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:3]: (error) Passing value -1. to log() leads to undefined result \n " , errout . str ( ) ) ;
check ( " void foo() \n "
" { \n "
" std::cout << log(-1.0) << std::endl; \n "
" } " ) ;
2010-04-02 07:32:03 +02:00
ASSERT_EQUALS ( " [test.cpp:3]: (error) Passing value -1.0 to log() leads to undefined result \n " , errout . str ( ) ) ;
2010-04-02 02:19:38 +02:00
check ( " void foo() \n "
" { \n "
" std::cout << log(-0.1) << std::endl; \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:3]: (error) Passing value -0.1 to log() leads to undefined result \n " , errout . str ( ) ) ;
check ( " void foo() \n "
" { \n "
" std::cout << log(0) << std::endl; \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:3]: (error) Passing value 0 to log() leads to undefined result \n " , errout . str ( ) ) ;
check ( " void foo() \n "
" { \n "
" std::cout << log(0.) << std::endl; \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:3]: (error) Passing value 0. to log() leads to undefined result \n " , errout . str ( ) ) ;
check ( " void foo() \n "
" { \n "
" std::cout << log(0.0) << std::endl; \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:3]: (error) Passing value 0.0 to log() leads to undefined result \n " , errout . str ( ) ) ;
check ( " void foo() \n "
" { \n "
" std::cout << log(1.0E+3) << std::endl; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check ( " void foo() \n "
" { \n "
" std::cout << log(1.0E-3) << std::endl; \n "
" } " ) ;
2010-04-04 08:01:05 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2010-04-02 02:19:38 +02:00
check ( " void foo() \n "
" { \n "
" std::cout << log(1E-3) << std::endl; \n "
" } " ) ;
2010-04-04 08:01:05 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2010-04-02 02:19:38 +02:00
2010-07-07 09:03:40 +02:00
check ( " void foo() \n "
" { \n "
" std::string *log(0); \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2010-11-15 21:03:49 +01:00
check ( " void foo() \n "
" { \n "
" std::cout << log(2.0) << std::endl; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2012-01-08 12:07:25 +01:00
// #3473 - no warning if "log" is a variable
check ( " Fred::Fred() : log(0) { } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2010-07-07 09:03:40 +02:00
2010-04-02 20:42:06 +02:00
// acos
2010-04-02 20:23:37 +02:00
check ( " void foo() \n "
" { \n "
2010-04-04 08:01:05 +02:00
" std::cout << acos(1) << std::endl; \n "
" std::cout << acos(-1) << std::endl; \n "
" std::cout << acos(0.1) << std::endl; \n "
" std::cout << acos(0.0001) << std::endl; \n "
" std::cout << acos(0.01) << std::endl; \n "
" std::cout << acos(1.0E-1) << std::endl; \n "
2010-04-02 20:23:37 +02:00
" std::cout << acos(-1.0E-1) << std::endl; \n "
" std::cout << acos(+1.0E-1) << std::endl; \n "
" std::cout << acos(0.1E-1) << std::endl; \n "
" std::cout << acos(+0.1E-1) << std::endl; \n "
" std::cout << acos(-0.1E-1) << std::endl; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check ( " void foo() \n "
" { \n "
" std::cout << acos(1.1) << std::endl; \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:3]: (error) Passing value 1.1 to acos() leads to undefined result \n " , errout . str ( ) ) ;
2010-04-02 02:19:38 +02:00
2010-04-02 20:23:37 +02:00
check ( " void foo() \n "
" { \n "
" std::cout << acos(-1.1) << std::endl; \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:3]: (error) Passing value -1.1 to acos() leads to undefined result \n " , errout . str ( ) ) ;
check ( " void foo() \n "
" { \n "
" std::cout << acos(-110) << std::endl; \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:3]: (error) Passing value -110 to acos() leads to undefined result \n " , errout . str ( ) ) ;
2010-04-05 19:35:56 +02:00
// atan2
check ( " void foo() \n "
" { \n "
" std::cout << atan2(1,1) << std::endl; \n "
" std::cout << atan2(-1,-1) << std::endl; \n "
" std::cout << atan2(0.1,1) << std::endl; \n "
" std::cout << atan2(0.0001,100) << std::endl; \n "
" std::cout << atan2(0.01m-1) << std::endl; \n "
" std::cout << atan2(1.0E-1,-3) << std::endl; \n "
" std::cout << atan2(-1.0E-1,+2) << std::endl; \n "
" std::cout << atan2(+1.0E-1,0) << std::endl; \n "
" std::cout << atan2(0.1E-1,3) << std::endl; \n "
" std::cout << atan2(+0.1E-1,1) << std::endl; \n "
" std::cout << atan2(-0.1E-1,8) << std::endl; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check ( " void foo() \n "
" { \n "
" std::cout << atan2(0,0) << std::endl; \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:3]: (error) Passing value 0 and 0 to atan2() leads to undefined result \n " , errout . str ( ) ) ;
2010-04-05 20:07:53 +02:00
// fmod
2010-04-05 19:45:33 +02:00
check ( " void foo() \n "
" { \n "
" std::cout << fmod(1.0,0) << std::endl; \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:3]: (error) Passing value 1.0 and 0 to fmod() leads to undefined result \n " , errout . str ( ) ) ;
2010-04-05 20:07:53 +02:00
check ( " void foo() \n "
" { \n "
" std::cout << fmod(1.0,1) << std::endl; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
// pow
check ( " void foo() \n "
" { \n "
" std::cout << pow(0,-10) << std::endl; \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:3]: (error) Passing value 0 and -10 to pow() leads to undefined result \n " , errout . str ( ) ) ;
check ( " void foo() \n "
" { \n "
" std::cout << pow(0,10) << std::endl; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2010-04-05 20:20:20 +02:00
// sqrt
check ( " void foo() \n "
" { \n "
" std::cout << sqrt(-1) << std::endl; \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:3]: (error) Passing value -1 to sqrt() leads to undefined result \n " , errout . str ( ) ) ;
check ( " void foo() \n "
" { \n "
" std::cout << sqrt(1) << std::endl; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2010-04-05 19:35:56 +02:00
2010-04-02 20:23:37 +02:00
}
2010-04-13 19:30:25 +02:00
2011-11-17 16:31:16 +01:00
void cctypefunctionCall ( ) {
// isalnum
check ( " void foo() \n "
" { \n "
" std::cout << isalnum(61) << std::endl; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check ( " void foo() \n "
" { \n "
" std::cout << isalnum(-61) << std::endl; \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:3]: (error) Passing value -61 to isalnum() cause undefined behavior, which may lead to a crash \n " , errout . str ( ) ) ;
check ( " void foo() \n "
" { \n "
" std::cout << isalpha(61) << std::endl; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check ( " void foo() \n "
" { \n "
" std::cout << isalpha(-61) << std::endl; \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:3]: (error) Passing value -61 to isalpha() cause undefined behavior, which may lead to a crash \n " , errout . str ( ) ) ;
check ( " void foo() \n "
" { \n "
" std::cout << iscntrl(61) << std::endl; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check ( " void foo() \n "
" { \n "
" std::cout << iscntrl(-61) << std::endl; \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:3]: (error) Passing value -61 to iscntrl() cause undefined behavior, which may lead to a crash \n " , errout . str ( ) ) ;
check ( " void foo() \n "
" { \n "
" std::cout << isdigit(61) << std::endl; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check ( " void foo() \n "
" { \n "
" std::cout << isdigit(-61) << std::endl; \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:3]: (error) Passing value -61 to isdigit() cause undefined behavior, which may lead to a crash \n " , errout . str ( ) ) ;
check ( " void foo() \n "
" { \n "
" std::cout << isgraph(61) << std::endl; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check ( " void foo() \n "
" { \n "
" std::cout << isgraph(-61) << std::endl; \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:3]: (error) Passing value -61 to isgraph() cause undefined behavior, which may lead to a crash \n " , errout . str ( ) ) ;
check ( " void foo() \n "
" { \n "
" std::cout << islower(61) << std::endl; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check ( " void foo() \n "
" { \n "
" std::cout << islower(-61) << std::endl; \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:3]: (error) Passing value -61 to islower() cause undefined behavior, which may lead to a crash \n " , errout . str ( ) ) ;
check ( " void foo() \n "
" { \n "
" std::cout << isprint(61) << std::endl; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check ( " void foo() \n "
" { \n "
" std::cout << isprint(-61) << std::endl; \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:3]: (error) Passing value -61 to isprint() cause undefined behavior, which may lead to a crash \n " , errout . str ( ) ) ;
check ( " void foo() \n "
" { \n "
" std::cout << ispunct(61) << std::endl; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check ( " void foo() \n "
" { \n "
" std::cout << ispunct(-61) << std::endl; \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:3]: (error) Passing value -61 to ispunct() cause undefined behavior, which may lead to a crash \n " , errout . str ( ) ) ;
check ( " void foo() \n "
" { \n "
" std::cout << isspace(61) << std::endl; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check ( " void foo() \n "
" { \n "
" std::cout << isspace(-61) << std::endl; \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:3]: (error) Passing value -61 to isspace() cause undefined behavior, which may lead to a crash \n " , errout . str ( ) ) ;
check ( " void foo() \n "
" { \n "
" std::cout << isupper(61) << std::endl; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check ( " void foo() \n "
" { \n "
" std::cout << isupper(-61) << std::endl; \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:3]: (error) Passing value -61 to isupper() cause undefined behavior, which may lead to a crash \n " , errout . str ( ) ) ;
check ( " void foo() \n "
" { \n "
" std::cout << isxdigit(61) << std::endl; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check ( " void foo() \n "
" { \n "
" std::cout << isxdigit(-61) << std::endl; \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:3]: (error) Passing value -61 to isxdigit() cause undefined behavior, which may lead to a crash \n " , errout . str ( ) ) ;
2011-12-29 08:08:37 +01:00
check ( " void f() { \n "
" std::isgraph(-10000, loc); \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:2]: (error) Passing value -10000 to isgraph() cause undefined behavior, which may lead to a crash \n " , errout . str ( ) ) ;
2011-11-17 16:31:16 +01:00
}
2010-05-15 14:06:45 +02:00
2011-10-13 20:53:06 +02:00
void sizeofsizeof ( ) {
2010-05-15 14:06:45 +02:00
check ( " void foo() \n "
" { \n "
" int i = sizeof sizeof char; \n "
" } \n " ) ;
2010-11-28 13:20:46 +01:00
ASSERT_EQUALS ( " [test.cpp:3]: (warning) Calling sizeof for 'sizeof'. \n " , errout . str ( ) ) ;
2011-02-02 17:56:02 +01:00
check ( " void foo() \n "
" { \n "
" int i = sizeof (sizeof long); \n "
" } \n " ) ;
ASSERT_EQUALS ( " [test.cpp:3]: (warning) Calling sizeof for 'sizeof'. \n " , errout . str ( ) ) ;
check ( " void foo(long *p) \n "
" { \n "
" int i = sizeof (sizeof (p)); \n "
" } \n " ) ;
ASSERT_EQUALS ( " [test.cpp:3]: (warning) Calling sizeof for 'sizeof'. \n " , errout . str ( ) ) ;
2010-05-15 14:06:45 +02:00
}
2010-06-15 08:45:46 +02:00
2011-10-13 20:53:06 +02:00
void sizeofCalculation ( ) {
2010-08-06 22:57:10 +02:00
check ( " sizeof(a+b) " ) ;
2010-10-17 14:41:00 +02:00
ASSERT_EQUALS ( " [test.cpp:1]: (warning) Found calculation inside sizeof() \n " , errout . str ( ) ) ;
2010-08-07 10:12:39 +02:00
check ( " sizeof(-a) " ) ;
2012-03-25 11:32:00 +02:00
ASSERT_EQUALS ( " [test.cpp:1]: (warning) Found calculation inside sizeof() \n " , errout . str ( ) ) ;
2010-08-07 10:12:39 +02:00
check ( " sizeof(void * const) " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2010-08-06 22:57:10 +02:00
}
2011-10-13 20:53:06 +02:00
void switchRedundantAssignmentTest ( ) {
2012-05-30 01:30:37 +02:00
2010-06-30 09:10:30 +02:00
check ( " void foo() \n "
" { \n "
2012-05-29 06:19:22 +02:00
" int y = 1; \n "
" switch (a) \n "
" { \n "
" case 2: \n "
" y = 2; \n "
" case 3: \n "
" y = 3; \n "
" } \n "
" bar(y); \n "
2010-06-30 09:10:30 +02:00
" } \n " ) ;
2010-10-17 14:41:00 +02:00
ASSERT_EQUALS ( " [test.cpp:7]: (warning) Redundant assignment of \" y \" in switch \n " , errout . str ( ) ) ;
2010-06-30 09:10:30 +02:00
check ( " void foo() \n "
" { \n "
2012-05-29 06:19:22 +02:00
" int y = 1; \n "
" switch (a) \n "
" { \n "
" case 2: \n "
" { \n "
" y = 2; \n "
" } \n "
" case 3: \n "
" y = 3; \n "
" } \n "
" bar(y); \n "
2010-06-30 09:10:30 +02:00
" } \n " ) ;
2010-10-17 14:41:00 +02:00
ASSERT_EQUALS ( " [test.cpp:8]: (warning) Redundant assignment of \" y \" in switch \n " , errout . str ( ) ) ;
2010-06-30 09:10:30 +02:00
check ( " void foo() \n "
" { \n "
2012-05-29 06:19:22 +02:00
" int y = 1; \n "
" switch (a) \n "
" { \n "
" case 2: \n "
" y = 2; \n "
" case 3: \n "
" if (x) \n "
2010-06-30 09:10:30 +02:00
" { \n "
2012-05-29 06:19:22 +02:00
" y = 3; \n "
2010-06-30 09:10:30 +02:00
" } \n "
2012-05-29 06:19:22 +02:00
" } \n "
" bar(y); \n "
2010-06-30 09:10:30 +02:00
" } \n " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check ( " void foo() \n "
" { \n "
2012-05-29 06:19:22 +02:00
" int y = 1; \n "
" switch (a) \n "
" { \n "
" case 2: \n "
" { \n "
" y = 2; \n "
" if (y) \n "
" printf( \" %d \" , y); \n "
" } \n "
" case 3: \n "
" y = 3; \n "
" } \n "
" bar(y); \n "
2010-06-30 09:10:30 +02:00
" } \n " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check ( " void foo() \n "
" { \n "
2012-05-29 06:19:22 +02:00
" int x = a; \n "
" int y = 1; \n "
" switch (x) \n "
" { \n "
" case 2: \n "
" x = 2; \n "
" case 3: \n "
" y = 3; \n "
" } \n "
" bar(y); \n "
2010-06-30 09:10:30 +02:00
" } \n " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check ( " void foo() \n "
" { \n "
2012-05-29 06:19:22 +02:00
" int y = 1; \n "
" switch (x) \n "
" { \n "
" case 2: \n "
" { \n "
" int y = 2; \n "
" } \n "
" case 3: \n "
" y = 3; \n "
" } \n "
" bar(y); \n "
2010-06-30 09:10:30 +02:00
" } \n " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check ( " void foo() \n "
" { \n "
2012-05-29 06:19:22 +02:00
" int y = 1; \n "
" switch (x) \n "
" { \n "
" case 2: \n "
" y = 2; \n "
" break; \n "
" case 3: \n "
" y = 3; \n "
" } \n "
" bar(y); \n "
2010-06-30 09:10:30 +02:00
" } \n " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2010-09-04 14:24:45 +02:00
check ( " void foo() \n "
" { \n "
" int y = 1; \n "
" while(xyz()) { \n "
" switch (x) \n "
" { \n "
" case 2: \n "
" y = 2; \n "
" continue; \n "
" case 3: \n "
" y = 3; \n "
" } \n "
2011-10-30 11:27:27 +01:00
" bar(y); \n "
2010-09-04 14:24:45 +02:00
" } \n "
" } \n " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2011-03-11 19:27:31 +01:00
check ( " void foo() \n "
" { \n "
" int y = 1; \n "
" while(xyz()) { \n "
" switch (x) \n "
" { \n "
" case 2: \n "
" y = 2; \n "
" throw e; \n "
" case 3: \n "
" y = 3; \n "
" } \n "
2011-10-30 11:27:27 +01:00
" bar(y); \n "
2011-03-11 19:27:31 +01:00
" } \n "
" } \n " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2010-06-30 09:10:30 +02:00
check ( " void foo() \n "
" { \n "
2012-05-29 06:19:22 +02:00
" int y = 1; \n "
" switch (x) \n "
" { \n "
" case 2: \n "
" y = 2; \n "
" printf( \" %d \" , y); \n "
" case 3: \n "
" y = 3; \n "
" } \n "
" bar(y); \n "
2010-06-30 09:10:30 +02:00
" } \n " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check ( " void foo() \n "
" { \n "
2012-05-29 06:19:22 +02:00
" int y = 1; \n "
" switch (x) \n "
" { \n "
" case 2: \n "
" y = 2; \n "
" bar(); \n "
" case 3: \n "
" y = 3; \n "
" } \n "
" bar(y); \n "
2010-06-30 09:10:30 +02:00
" } \n " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2011-10-13 10:27:22 +02:00
check ( " void foo(char *str, int a) \n "
" { \n "
2012-05-29 06:19:22 +02:00
" switch (a) \n "
" { \n "
" case 2: \n "
" strcpy(str, \" a' \" ); \n "
" case 3: \n "
" strcpy(str, \" b' \" ); \n "
" } \n "
2011-10-13 10:27:22 +02:00
" } \n " ) ;
ASSERT_EQUALS ( " [test.cpp:6]: (warning) Switch case fall-through. Redundant strcpy of \" str \" . \n " , errout . str ( ) ) ;
check ( " void foo(char *str, int a) \n "
" { \n "
2012-05-29 06:19:22 +02:00
" switch (a) \n "
" { \n "
" case 2: \n "
" strncpy(str, \" a' \" ); \n "
" case 3: \n "
" strncpy(str, \" b' \" ); \n "
" } \n "
2011-10-13 10:27:22 +02:00
" } \n " ) ;
ASSERT_EQUALS ( " [test.cpp:6]: (warning) Switch case fall-through. Redundant strcpy of \" str \" . \n " , errout . str ( ) ) ;
check ( " void foo(char *str, int a) \n "
" { \n "
2012-05-29 06:19:22 +02:00
" int z = 0; \n "
" switch (a) \n "
" { \n "
" case 2: \n "
" strcpy(str, \" a' \" ); \n "
" z++; \n "
" case 3: \n "
" strcpy(str, \" b' \" ); \n "
" z++; \n "
" } \n "
2011-10-13 10:27:22 +02:00
" } \n " ) ;
ASSERT_EQUALS ( " [test.cpp:7]: (warning) Switch case fall-through. Redundant strcpy of \" str \" . \n " , errout . str ( ) ) ;
check ( " void foo(char *str, int a) \n "
" { \n "
2012-05-29 06:19:22 +02:00
" switch (a) \n "
" { \n "
" case 2: \n "
" strcpy(str, \" a' \" ); \n "
" break; \n "
" case 3: \n "
" strcpy(str, \" b' \" ); \n "
" break; \n "
" } \n "
2011-10-13 10:27:22 +02:00
" } \n " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check ( " void foo(char *str, int a) \n "
" { \n "
2012-05-29 06:19:22 +02:00
" switch (a) \n "
" { \n "
" case 2: \n "
" strcpy(str, \" a' \" ); \n "
" printf(str); \n "
" case 3: \n "
" strcpy(str, \" b' \" ); \n "
" } \n "
" } \n " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
void switchRedundantBitwiseOperationTest ( ) {
check ( " void foo(int a) \n "
" { \n "
" int y = 1; \n "
" switch (a) \n "
" { \n "
" case 2: \n "
" y |= 3; \n "
" case 3: \n "
" y |= 3; \n "
" break; \n "
" } \n "
" } \n " ) ;
ASSERT_EQUALS ( " [test.cpp:7]: (warning) Redundant bitwise operation on \" y \" in switch \n " , errout . str ( ) ) ;
check ( " void foo(int a) \n "
" { \n "
" int y = 1; \n "
" switch (a) \n "
" { \n "
" case 2: \n "
" y |= 3; \n "
" default: \n "
" y |= 3; \n "
" break; \n "
" } \n "
" } \n " ) ;
ASSERT_EQUALS ( " [test.cpp:7]: (warning) Redundant bitwise operation on \" y \" in switch \n " , errout . str ( ) ) ;
check ( " void foo(int a) \n "
" { \n "
" int y = 1; \n "
" switch (a) \n "
" { \n "
" case 2: \n "
" y |= 3; \n "
" default: \n "
" if (z) \n "
" y |= 3; \n "
" break; \n "
" } \n "
" } \n " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check ( " void foo(int a) \n "
" { \n "
" int y = 1; \n "
" switch (a) \n "
" { \n "
" case 2: \n "
" y |= z; \n "
" z++ \n "
" default: \n "
" y |= z; \n "
" break; \n "
" } \n "
" } \n " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check ( " void foo(int a) \n "
" { \n "
" int y = 1; \n "
" switch (a) \n "
" { \n "
" case 2: \n "
" y |= 3; \n "
" bar(y); \n "
" case 3: \n "
" y |= 3; \n "
" break; \n "
" } \n "
" } \n " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check ( " void foo(int a) \n "
" { \n "
" int y = 1; \n "
" switch (a) \n "
" { \n "
" case 2: \n "
" y |= 3; \n "
" y = 4; \n "
" case 3: \n "
" y |= 3; \n "
" break; \n "
" } \n "
" } \n " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check ( " void foo(int a) \n "
" { \n "
" int y = 1; \n "
" switch (a) \n "
" { \n "
" case 2: \n "
" y &= 3; \n "
" case 3: \n "
" y &= 3; \n "
" break; \n "
" } \n "
" } \n " ) ;
ASSERT_EQUALS ( " [test.cpp:7]: (warning) Redundant bitwise operation on \" y \" in switch \n " , errout . str ( ) ) ;
check ( " void foo(int a) \n "
" { \n "
" int y = 1; \n "
" switch (a) \n "
" { \n "
" case 2: \n "
" y |= 3; \n "
" break; \n "
" case 3: \n "
" y |= 3; \n "
" break; \n "
" } \n "
" } \n " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check ( " void foo(int a) \n "
" { \n "
" int y = 1; \n "
" switch (a) \n "
" { \n "
" case 2: \n "
" y ^= 3; \n "
" case 3: \n "
" y ^= 3; \n "
" break; \n "
" } \n "
" } \n " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check ( " void foo(int a) \n "
" { \n "
" int y = 1; \n "
" switch (a) \n "
" { \n "
" case 2: \n "
" y |= 2; \n "
" case 3: \n "
" y |= 3; \n "
" break; \n "
" } \n "
" } \n " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check ( " void foo(int a) \n "
" { \n "
" int y = 1; \n "
" switch (a) \n "
" { \n "
" case 2: \n "
" y &= 2; \n "
" case 3: \n "
" y &= 3; \n "
" break; \n "
" } \n "
" } \n " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check ( " void foo(int a) \n "
" { \n "
" int y = 1; \n "
" switch (a) \n "
" { \n "
" case 2: \n "
" y |= 2; \n "
" case 3: \n "
" y &= 2; \n "
" break; \n "
" } \n "
2011-10-13 10:27:22 +02:00
" } \n " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2010-06-30 09:10:30 +02:00
}
2010-08-14 15:15:12 +02:00
2011-10-13 20:53:06 +02:00
void switchFallThroughCase ( ) {
2011-02-19 09:33:29 +01:00
check_preprocess_suppress (
" void foo() { \n "
" switch (a) { \n "
" case 1: \n "
" break; \n "
" case 2: \n "
" break; \n "
" } \n "
" } \n " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2011-02-19 20:02:28 +01:00
check_preprocess_suppress (
2011-03-11 19:27:31 +01:00
" void foo() { \n "
" switch (a) { \n "
" case 1: \n "
" break; \n "
" case 2: \n "
" continue; \n "
" case 3: \n "
" return; \n "
" case 4: \n "
" exit(1); \n "
" case 5: \n "
" goto end; \n "
" case 6: \n "
" throw e; \n "
" case 7: \n "
" break; \n "
" } \n "
" } \n " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check_preprocess_suppress (
2011-02-19 20:02:28 +01:00
" void foo() { \n "
" switch (a) { \n "
" case 0: \n "
" case 1: \n "
" break; \n "
" case 2: \n "
" break; \n "
" } \n "
" } \n " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2011-02-19 09:33:29 +01:00
check_preprocess_suppress (
" void foo() { \n "
" switch (a) { \n "
" case 1: \n "
" g(); \n "
" case 2: \n "
" break; \n "
" } \n "
" } \n " ) ;
2011-03-05 21:42:15 +01:00
ASSERT_EQUALS ( " [test.cpp:5]: (style) Switch falls through case without comment \n " , errout . str ( ) ) ;
2011-02-19 09:33:29 +01:00
2011-02-19 20:02:28 +01:00
check_preprocess_suppress (
" void foo() { \n "
" switch (a) { \n "
" case 1: \n "
" g(); \n "
" default: \n "
" break; \n "
" } \n "
" } \n " ) ;
2011-03-05 21:42:15 +01:00
ASSERT_EQUALS ( " [test.cpp:5]: (style) Switch falls through case without comment \n " , errout . str ( ) ) ;
2011-02-19 20:02:28 +01:00
2011-02-19 09:33:29 +01:00
check_preprocess_suppress (
" void foo() { \n "
" switch (a) { \n "
" case 1: \n "
" g(); \n "
" // fall through \n "
" case 2: \n "
" break; \n "
" } \n "
" } \n " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2011-02-19 21:54:01 +01:00
check_preprocess_suppress (
" void foo() { \n "
" switch (a) { \n "
" case 1: \n "
" g(); \n "
" /* FALLTHRU */ \n "
" case 2: \n "
" break; \n "
" } \n "
" } \n " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2011-02-19 09:33:29 +01:00
check_preprocess_suppress (
" void foo() { \n "
" switch (a) { \n "
" case 1: \n "
" g(); \n "
" break; \n "
" // fall through \n "
" case 2: \n "
" break; \n "
" } \n "
" } \n " ) ;
2011-02-19 20:02:28 +01:00
ASSERT_EQUALS ( " [test.cpp:7]: (information) Unmatched suppression: switchCaseFallThrough \n " , errout . str ( ) ) ;
check_preprocess_suppress (
" void foo() { \n "
" switch (a) { \n "
" case 1: \n "
" { \n "
" break; \n "
" } \n "
" case 2: \n "
" break; \n "
" } \n "
" } \n " ) ;
2011-02-19 09:33:29 +01:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2011-02-19 20:02:28 +01:00
check_preprocess_suppress (
" void foo() { \n "
" switch (a) { \n "
" case 1: \n "
" for (;;) { \n "
" break; \n "
" } \n "
" case 2: \n "
" break; \n "
" } \n "
" } \n " ) ;
2011-03-05 21:42:15 +01:00
ASSERT_EQUALS ( " [test.cpp:7]: (style) Switch falls through case without comment \n " , errout . str ( ) ) ;
2011-02-19 20:02:28 +01:00
check_preprocess_suppress (
" void foo() { \n "
" switch (a) { \n "
" case 1: \n "
" if (b) { \n "
" break; \n "
" } else { \n "
" break; \n "
" } \n "
" case 2: \n "
" break; \n "
" } \n "
" } \n " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check_preprocess_suppress (
" void foo() { \n "
" switch (a) { \n "
" case 1: \n "
" if (b) { \n "
" break; \n "
" } else { \n "
" } \n "
" case 2: \n "
" break; \n "
" } \n "
" } \n " ) ;
2011-03-05 21:42:15 +01:00
ASSERT_EQUALS ( " [test.cpp:8]: (style) Switch falls through case without comment \n " , errout . str ( ) ) ;
2011-02-19 20:02:28 +01:00
check_preprocess_suppress (
" void foo() { \n "
" switch (a) { \n "
" case 1: \n "
" if (b) { \n "
" break; \n "
" } \n "
" case 2: \n "
" break; \n "
" } \n "
" } \n " ) ;
2011-03-05 21:42:15 +01:00
ASSERT_EQUALS ( " [test.cpp:7]: (style) Switch falls through case without comment \n " , errout . str ( ) ) ;
2011-02-19 20:02:28 +01:00
check_preprocess_suppress (
" void foo() { \n "
" switch (a) { \n "
" case 1: \n "
" if (b) { \n "
" } else { \n "
" break; \n "
" } \n "
" case 2: \n "
" break; \n "
" } \n "
" } \n " ) ;
2011-03-05 21:42:15 +01:00
ASSERT_EQUALS ( " [test.cpp:8]: (style) Switch falls through case without comment \n " , errout . str ( ) ) ;
2011-02-19 20:02:28 +01:00
check_preprocess_suppress (
" void foo() { \n "
" switch (a) { \n "
" case 1: \n "
" if (b) { \n "
" case 2: \n "
" } else { \n "
" break; \n "
" } \n "
" break; \n "
" } \n "
" } \n " ) ;
2011-03-05 21:42:15 +01:00
ASSERT_EQUALS ( " [test.cpp:5]: (style) Switch falls through case without comment \n " , errout . str ( ) ) ;
2011-02-23 10:45:21 +01:00
check_preprocess_suppress (
" void foo() { \n "
" switch (a) { \n "
" int x; \n "
" case 1: \n "
" break; \n "
" } \n "
" } \n " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2011-03-04 07:22:17 +01:00
check_preprocess_suppress (
" void foo() { \n "
" switch (a) { \n "
" case 1: \n "
" g(); \n "
" switch (b) { \n "
" case 1: \n "
" return; \n "
" default: \n "
" return; \n "
" } \n "
" case 2: \n "
" break; \n "
" } \n "
" } \n " ) ;
// This fails because the switch parsing code currently doesn't understand
// that all paths after g() actually return. It's a pretty unusual case
// (no pun intended).
TODO_ASSERT_EQUALS ( " " ,
2011-03-05 21:42:15 +01:00
" [test.cpp:11]: (style) Switch falls through case without comment \n " , errout . str ( ) ) ;
2011-03-04 07:26:48 +01:00
check_preprocess_suppress (
" void foo() { \n "
" switch (a) { \n "
" case 1: \n "
" #ifndef A \n "
" g(); \n "
" // fall through \n "
" #endif \n "
" case 2: \n "
" break; \n "
" } \n "
" } \n " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2011-03-04 08:26:14 +01:00
check_preprocess_suppress (
" void foo() { \n "
" switch (a) { \n "
" case 1: \n "
" goto leave; \n "
" case 2: \n "
" break; \n "
" } \n "
" leave: \n "
" if (x) { \n "
" g(); \n "
" return; \n "
" } \n "
" } \n " ) ;
// This fails because Tokenizer::simplifyGoto() copies the "leave:" block
// into where the goto is, but because it contains a "return", it omits
// copying a final return after the block.
TODO_ASSERT_EQUALS ( " " ,
2011-03-05 21:42:15 +01:00
" [test.cpp:5]: (style) Switch falls through case without comment \n " , errout . str ( ) ) ;
2011-03-05 06:02:38 +01:00
check_preprocess_suppress (
" void foo() { \n "
" switch (a) { \n "
" case 1: \n "
" g(); \n "
" // fall through \n "
" case 2: \n "
" g(); \n "
" // falls through \n "
" case 3: \n "
" g(); \n "
" // fall-through \n "
" case 4: \n "
" g(); \n "
" // drop through \n "
" case 5: \n "
" g(); \n "
" // pass through \n "
" case 5: \n "
" g(); \n "
" // no break \n "
" case 5: \n "
" g(); \n "
" // fallthru \n "
" case 6: \n "
" g(); \n "
" /* fall */ \n "
" default: \n "
" break; \n "
" } \n "
" } \n " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2011-03-06 00:14:10 +01:00
check_preprocess_suppress (
" void foo() { \n "
" // unrelated comment saying 'fall through' \n "
" } \n " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2011-02-19 09:33:29 +01:00
}
2011-12-07 18:20:52 +01:00
void unreachableCode ( ) {
2011-12-03 11:43:23 +01:00
check ( " void foo(int a) { \n "
" while(1) { \n "
" if (a++ >= 100) { \n "
" break; \n "
" continue; \n "
" } \n "
" } \n "
" } \n " ) ;
2011-12-28 21:05:10 +01:00
ASSERT_EQUALS ( " [test.cpp:5]: (style) Consecutive return, break, continue, goto or throw statements are unnecessary. \n " , errout . str ( ) ) ;
2011-12-03 11:43:23 +01:00
check ( " int foo(int a) { \n "
" return 0; \n "
" return(a-1); \n "
" } \n " ) ;
2011-12-28 21:05:10 +01:00
ASSERT_EQUALS ( " [test.cpp:3]: (style) Consecutive return, break, continue, goto or throw statements are unnecessary. \n " , errout . str ( ) ) ;
2011-12-03 11:43:23 +01:00
check ( " int foo(int a) { \n "
" A: "
" return(0); \n "
" goto A; \n "
" } \n " ) ;
2011-12-28 21:05:10 +01:00
ASSERT_EQUALS ( " [test.cpp:3]: (style) Consecutive return, break, continue, goto or throw statements are unnecessary. \n " , errout . str ( ) ) ;
2011-12-03 11:43:23 +01:00
2011-07-15 02:12:56 +02:00
check ( " void foo(int a) \n "
" { \n "
" switch(a) { \n "
" case 0: \n "
" printf( \" case 0 \" ); \n "
" break; \n "
" break; \n "
" case 1: \n "
" c++; \n "
" break; \n "
" } \n "
" } \n " ) ;
2011-12-28 21:05:10 +01:00
ASSERT_EQUALS ( " [test.cpp:7]: (style) Consecutive return, break, continue, goto or throw statements are unnecessary. \n " , errout . str ( ) ) ;
2011-07-15 02:12:56 +02:00
check ( " void foo(int a) \n "
" { \n "
" switch(a) { \n "
" case 0: \n "
" printf( \" case 0 \" ); \n "
" break; \n "
" case 1: \n "
" c++; \n "
" break; \n "
" } \n "
" } \n " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check ( " void foo(int a) \n "
" { \n "
" while(1) { \n "
" if (a++ >= 100) { \n "
" break; \n "
" break; \n "
" } \n "
" } \n "
" } \n " ) ;
2011-12-28 21:05:10 +01:00
ASSERT_EQUALS ( " [test.cpp:6]: (style) Consecutive return, break, continue, goto or throw statements are unnecessary. \n " , errout . str ( ) ) ;
2011-07-15 02:12:56 +02:00
check ( " void foo(int a) \n "
" { \n "
" while(1) { \n "
" if (a++ >= 100) { \n "
" continue; \n "
" continue; \n "
" } \n "
" a+=2; \n "
" } \n "
" } \n " ) ;
2011-12-28 21:05:10 +01:00
ASSERT_EQUALS ( " [test.cpp:6]: (style) Consecutive return, break, continue, goto or throw statements are unnecessary. \n " , errout . str ( ) ) ;
2011-07-15 02:12:56 +02:00
check ( " void foo(int a) \n "
" { \n "
" while(1) { \n "
" if (a++ >= 100) { \n "
" continue; \n "
" } \n "
" a+=2; \n "
" } \n "
" } \n " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2011-12-03 11:43:23 +01:00
check ( " int foo() { \n "
" throw 0; \n "
" return 1; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check ( " void foo() { \n "
" throw 0; \n "
" return; \n "
" } " ) ;
2011-12-28 21:05:10 +01:00
ASSERT_EQUALS ( " [test.cpp:3]: (style) Consecutive return, break, continue, goto or throw statements are unnecessary. \n " , errout . str ( ) ) ;
2011-12-03 11:43:23 +01:00
check ( " int foo() { \n "
" return 0; \n "
" return 1; \n "
" } " ) ;
2011-12-28 21:05:10 +01:00
ASSERT_EQUALS ( " [test.cpp:3]: (style) Consecutive return, break, continue, goto or throw statements are unnecessary. \n " , errout . str ( ) ) ;
2011-12-03 11:43:23 +01:00
check ( " int foo() { \n "
" return 0; \n "
" foo(); \n "
" } " ) ;
2011-12-28 21:05:10 +01:00
ASSERT_EQUALS ( " [test.cpp:3]: (style) Statements following return, break, continue, goto or throw will never be executed. \n " , errout . str ( ) ) ;
2011-12-03 11:43:23 +01:00
check ( " int foo() { \n "
" if(bar) \n "
" return 0; \n "
" return 124; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check ( " int foo() { \n "
" while(bar) { \n "
" return 0; \n "
" return 0; \n "
" return 0; \n "
" return 0; \n "
" } \n "
" return 124; \n "
" } " ) ;
2011-12-28 21:05:10 +01:00
ASSERT_EQUALS ( " [test.cpp:4]: (style) Consecutive return, break, continue, goto or throw statements are unnecessary. \n " , errout . str ( ) ) ;
2011-12-03 11:43:23 +01:00
check ( " void foo() { \n "
" while(bar) { \n "
" return; \n "
" break; \n "
" } \n "
" } " ) ;
2011-12-28 21:05:10 +01:00
ASSERT_EQUALS ( " [test.cpp:4]: (style) Consecutive return, break, continue, goto or throw statements are unnecessary. \n " , errout . str ( ) ) ;
2011-12-03 11:43:23 +01:00
check ( " int foo() { \n "
" return 0; \n "
" label: \n "
" throw 0; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2011-12-07 18:20:52 +01:00
check ( " void foo() { \n "
" wxCHECK2(state < 3 && state >= 0, return); \n "
" _checkboxState = state; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check ( " struct A { \n "
" virtual void foo (P & Val) throw (); \n "
" virtual void foo1 (P & Val) throw (); \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2011-12-23 12:46:59 +01:00
2011-12-31 23:11:03 +01:00
check ( " int foo() { \n "
" goto label; \n "
" while (true) { \n "
" bar(); \n "
" label: \n "
" } \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ; // #3457
check ( " int foo() { \n "
" goto label; \n "
" do { \n "
" bar(); \n "
" label: \n "
" } while (true); \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ; // #3457
check ( " int foo() { \n "
" goto label; \n "
" for (;;) { \n "
" bar(); \n "
" label: \n "
" } \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ; // #3457
2011-12-23 12:46:59 +01:00
check ( " %: return ; () " ) ; // Don't crash. #3441.
2012-04-05 10:38:29 +02:00
// #3383. TODO: Use preprocessor
check ( " int foo() { \n "
" \n " // #ifdef A
" return 0; \n "
" \n " // #endif
" return 1; \n "
" } " , 0 , false , false ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check ( " int foo() { \n "
" \n " // #ifdef A
" return 0; \n "
" \n " // #endif
" return 1; \n "
" } " ) ;
2012-05-06 19:37:41 +02:00
ASSERT_EQUALS ( " [test.cpp:5]: (style, inconclusive) Consecutive return, break, continue, goto or throw statements are unnecessary. \n " , errout . str ( ) ) ;
2011-07-15 02:12:56 +02:00
}
2011-10-13 20:53:06 +02:00
void selfAssignment ( ) {
2010-08-15 06:28:22 +02:00
check ( " void foo() \n "
" { \n "
" int x = 1; \n "
" x = x; \n "
" return 0; \n "
" } \n " ) ;
2010-10-17 14:41:00 +02:00
ASSERT_EQUALS ( " [test.cpp:4]: (warning) Redundant assignment of \" x \" to itself \n " , errout . str ( ) ) ;
2010-08-15 06:28:22 +02:00
check ( " void foo() \n "
" { \n "
" int x = x; \n "
" } \n " ) ;
2010-10-17 14:41:00 +02:00
ASSERT_EQUALS ( " [test.cpp:3]: (warning) Redundant assignment of \" x \" to itself \n " , errout . str ( ) ) ;
2010-08-15 06:28:22 +02:00
check ( " void foo() \n "
" { \n "
" std::string var = var = \" test \" ; \n "
" } \n " ) ;
2011-02-04 21:08:42 +01:00
TODO_ASSERT_EQUALS ( " [test.cpp:3]: (warning) Redundant assignment of \" var \" to itself \n " , " " , errout . str ( ) ) ;
2010-08-15 06:28:22 +02:00
check ( " void foo() \n "
" { \n "
" int x = 1; \n "
" x = x + 1; \n "
" return 0; \n "
" } \n " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2011-02-04 21:08:42 +01:00
check ( " void foo() \n "
" { \n "
" int *x = getx(); \n "
" *x = x; \n "
" } \n " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2011-02-12 14:27:07 +01:00
2012-05-11 19:38:19 +02:00
check ( " void foo() { \n "
" BAR *x = getx(); \n "
" x = x; \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:3]: (warning) Redundant assignment of \" x \" to itself \n " , errout . str ( ) ) ;
2011-02-12 14:27:07 +01:00
// non-primitive type -> there might be some side effects
check ( " void foo() \n "
" { \n "
" Fred fred; fred = fred; \n "
" } \n " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2011-04-16 12:07:56 +02:00
check ( " void f(int x) { \n "
" x = (x == 0); "
" func(x); \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check ( " void f(int x) { \n "
" x = (x != 0); "
" func(x); \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2011-08-19 07:23:11 +02:00
// ticket #3001 - false positive
check ( " void foo(int x) { \n "
" x = x ? x : 0; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2010-08-15 06:28:22 +02:00
}
2011-10-13 20:53:06 +02:00
void trac1132 ( ) {
2012-05-24 17:40:43 +02:00
check ( " #include <iostream> \n "
" class Lock \n "
" { \n "
" public: \n "
" Lock(int i) \n "
" { \n "
" std::cout << \" Lock \" << i << std::endl; \n "
" } \n "
" ~Lock() \n "
" { \n "
" std::cout << \" ~Lock \" << std::endl; \n "
" } \n "
" }; \n "
" int main() \n "
" { \n "
" Lock(123); \n "
" std::cout << \" hello \" << std::endl; \n "
" return 0; \n "
" } \n "
) ;
ASSERT_EQUALS ( " [test.cpp:16]: (error) Instance of \" Lock \" object destroyed immediately. \n " , errout . str ( ) ) ;
2010-10-01 17:23:22 +02:00
}
2012-04-12 14:02:09 +02:00
void trac3693 ( ) {
check ( " struct A{ \n "
" enum { \n "
" b = 300 \n "
" }; \n "
" }; \n "
" const int DFLT_TIMEOUT = A::b % 1000000 ; \n " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2011-10-13 20:53:06 +02:00
void testMisusedScopeObjectDoesNotPickFunction1 ( ) {
2010-10-01 17:23:22 +02:00
check ( " int main ( ) \n "
" { \n "
" CouldBeFunction ( 123 ) ; \n "
" return 0 ; \n "
" } \n "
) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2011-10-13 20:53:06 +02:00
void testMisusedScopeObjectDoesNotPickFunction2 ( ) {
2011-03-20 09:55:26 +01:00
check ( " struct error { \n "
" error() {} \n "
" }; \n "
" \n "
" class parser { \n "
" public: \n "
" void error() const {} \n "
" \n "
" void foo() const { \n "
" error(); \n "
" } \n "
" }; \n "
) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2011-10-13 20:53:06 +02:00
void testMisusedScopeObjectPicksClass ( ) {
2010-10-01 17:23:22 +02:00
check ( " class NotAFunction ; \n "
" int function ( ) \n "
" { \n "
" NotAFunction ( 123 ); \n "
" return 0 ; \n "
" } \n "
) ;
2012-04-17 12:54:01 +02:00
ASSERT_EQUALS ( " [test.cpp:4]: (error) Instance of \" NotAFunction \" object destroyed immediately. \n " , errout . str ( ) ) ;
2010-10-01 17:23:22 +02:00
}
2011-10-13 20:53:06 +02:00
void testMisusedScopeObjectPicksStruct ( ) {
2010-10-01 17:23:22 +02:00
check ( " struct NotAClass; \n "
" bool func ( ) \n "
" { \n "
" NotAClass ( 123 ) ; \n "
" return true ; \n "
" } \n "
) ;
2012-04-17 12:54:01 +02:00
ASSERT_EQUALS ( " [test.cpp:4]: (error) Instance of \" NotAClass \" object destroyed immediately. \n " , errout . str ( ) ) ;
2010-10-01 17:23:22 +02:00
}
2011-10-13 20:53:06 +02:00
void testMisusedScopeObjectDoesNotPickIf ( ) {
2010-10-01 17:23:22 +02:00
check ( " bool func( int a , int b , int c ) \n "
" { \n "
" if ( a > b ) return c == a ; \n "
" return b == a ; \n "
" } \n "
) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2011-10-13 20:53:06 +02:00
void testMisusedScopeObjectDoesNotPickConstructorDeclaration ( ) {
2010-10-01 17:23:22 +02:00
check ( " class Something : public SomthingElse \n "
" { \n "
" public: \n "
" ~Something ( ) ; \n "
" Something ( ) ; \n "
" } \n "
) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2010-10-02 10:43:12 +02:00
2011-10-13 20:53:06 +02:00
void testMisusedScopeObjectDoesNotPickFunctor ( ) {
2010-10-02 10:43:12 +02:00
check ( " \n "
" #include <algorithm> \n "
" \n "
" class IncrementFunctor \n "
" { \n "
" public: \n "
" void operator()(int &i) \n "
" { \n "
" ++i; \n "
" } \n "
" }; \n "
" \n "
" int main() \n "
" { \n "
2010-10-02 13:16:50 +02:00
" int a = 1; \n "
" IncrementFunctor()(a); \n "
" return a; \n "
2010-10-02 10:43:12 +02:00
" } \n "
) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2010-10-02 12:12:52 +02:00
2011-10-13 20:53:06 +02:00
void testMisusedScopeObjectDoesNotPickLocalClassConstructors ( ) {
2010-10-02 12:12:52 +02:00
check ( " void f() { \n "
" class Foo { \n "
" Foo() { } \n "
2010-10-02 14:59:04 +02:00
" Foo(int a) { } \n "
" Foo(int a, int b) { } \n "
2010-10-02 12:12:52 +02:00
" }; \n "
2010-10-02 14:59:04 +02:00
" Foo(); \n "
2010-10-02 12:12:52 +02:00
" } \n "
) ;
2012-04-17 12:54:01 +02:00
ASSERT_EQUALS ( " [test.cpp:7]: (error) Instance of \" Foo \" object destroyed immediately. \n " , errout . str ( ) ) ;
2010-10-02 12:12:52 +02:00
}
2010-10-02 12:26:29 +02:00
2011-10-13 20:53:06 +02:00
void testMisusedScopeObjectDoesNotPickUsedObject ( ) {
2010-10-02 12:26:29 +02:00
check ( " struct Foo { \n "
" void bar() { \n "
" } \n "
" }; \n "
" \n "
" void fn() { \n "
" Foo().bar(); \n "
" } \n "
) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2010-12-25 08:43:52 +01:00
}
2011-10-13 20:53:06 +02:00
void testMisusedScopeObjectDoesNotPickPureC ( ) {
2010-12-25 08:43:52 +01:00
// Ticket #2352
const char code [ ] = " struct cb_watch_bool { \n "
" int a; \n "
" }; \n "
" \n "
" void f() \n "
" { \n "
" cb_watch_bool(); \n "
" } \n " ;
check ( code , " test.cpp " ) ;
2012-04-17 12:54:01 +02:00
ASSERT_EQUALS ( " [test.cpp:7]: (error) Instance of \" cb_watch_bool \" object destroyed immediately. \n " , errout . str ( ) ) ;
2010-12-25 08:43:52 +01:00
check ( code , " test.c " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2011-03-13 08:38:40 +01:00
// Ticket #2639
check ( " struct stat { int a; int b; }; \n "
" void stat(const char *fn, struct stat *); \n "
" \n "
" void foo() { \n "
" stat( \" file.txt \" , &st); \n "
" } \n " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2011-01-31 20:07:41 +01:00
}
2011-10-13 20:53:06 +02:00
void testMisusedScopeObjectDoesNotPickNestedClass ( ) {
2011-01-31 20:07:41 +01:00
const char code [ ] = " class ios_base { \n "
" public: \n "
" class Init { \n "
" public: \n "
" }; \n "
" }; \n "
" class foo { \n "
" public: \n "
" foo(); \n "
" void Init(int); \n "
" }; \n "
" foo::foo() { \n "
" Init(0); \n "
" } \n " ;
check ( code , " test.cpp " ) ;
2011-03-20 09:55:26 +01:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2010-10-02 12:26:29 +02:00
}
2010-10-03 23:16:11 +02:00
2011-10-13 20:53:06 +02:00
void trac2084 ( ) {
2010-10-13 11:31:41 +02:00
check ( " #include <signal.h> \n "
" \n "
" void f() \n "
" { \n "
" struct sigaction sa; \n "
" \n "
" { sigaction(SIGHUP, &sa, 0); }; \n "
" { sigaction(SIGINT, &sa, 0); }; \n "
" } \n "
) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2011-10-13 20:53:06 +02:00
void trac2071 ( ) {
2010-10-03 23:16:11 +02:00
check ( " void f() { \n "
2010-10-05 20:54:13 +02:00
" struct AB { \n "
" AB(int a) { } \n "
" }; \n "
" \n "
" const AB ab[3] = { AB(0), AB(1), AB(2) }; \n "
" } \n "
) ;
2010-10-03 23:16:11 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2010-10-10 22:05:06 +02:00
2011-10-13 20:53:06 +02:00
void assignmentInAssert ( ) {
2010-10-10 22:05:06 +02:00
check ( " void f() { \n "
" int a = 0; \n "
" assert(a = 2); \n "
" return a; \n "
" } \n "
) ;
2010-11-29 19:12:21 +01:00
ASSERT_EQUALS ( " [test.cpp:3]: (warning) Assert statement modifies 'a'. \n " , errout . str ( ) ) ;
2010-10-10 22:05:06 +02:00
check ( " void f() { \n "
" int a = 0; \n "
" assert(a == 2); \n "
" return a; \n "
" } \n "
) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check ( " void f() { \n "
" int a = 0; \n "
" int b = 0; \n "
" assert(a == 2 && b = 1); \n "
" return a; \n "
" } \n "
) ;
2010-11-29 19:12:21 +01:00
ASSERT_EQUALS ( " [test.cpp:4]: (warning) Assert statement modifies 'b'. \n " , errout . str ( ) ) ;
2010-10-10 22:05:06 +02:00
check ( " void f() { \n "
" int a = 0; \n "
" assert(a += 2); \n "
" return a; \n "
" } \n "
) ;
2010-11-29 19:12:21 +01:00
ASSERT_EQUALS ( " [test.cpp:3]: (warning) Assert statement modifies 'a'. \n " , errout . str ( ) ) ;
2010-10-10 22:05:06 +02:00
check ( " void f() { \n "
" int a = 0; \n "
" assert(a *= 2); \n "
" return a; \n "
" } \n "
) ;
2010-11-29 19:12:21 +01:00
ASSERT_EQUALS ( " [test.cpp:3]: (warning) Assert statement modifies 'a'. \n " , errout . str ( ) ) ;
2010-10-10 22:05:06 +02:00
check ( " void f() { \n "
" int a = 0; \n "
" assert(a -= 2); \n "
" return a; \n "
" } \n "
) ;
2010-11-29 19:12:21 +01:00
ASSERT_EQUALS ( " [test.cpp:3]: (warning) Assert statement modifies 'a'. \n " , errout . str ( ) ) ;
2010-10-10 22:05:06 +02:00
check ( " void f() { \n "
" int a = 0; \n "
" assert(a --); \n "
" return a; \n "
" } \n "
) ;
2010-11-29 19:12:21 +01:00
ASSERT_EQUALS ( " [test.cpp:3]: (warning) Assert statement modifies 'a'. \n " , errout . str ( ) ) ;
2010-10-10 22:05:06 +02:00
}
2010-10-25 03:14:21 +02:00
2012-04-26 15:23:47 +02:00
void modulo ( ) {
check ( " bool f(bool& b1, bool& b2, bool& b3) { \n "
" b1 = a % 5 == 4; \n "
" b2 = a % c == 100000; \n "
" b3 = a % 5 == c; \n "
" return a % 5 == 5-p; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check ( " bool f(bool& b1, bool& b2, bool& b3, bool& b4, bool& b5) { \n "
" b1 = a % 5 < 5; \n "
" b2 = a % 5 <= 5; \n "
" b3 = a % 5 == 5; \n "
" b4 = a % 5 != 5; \n "
" b5 = a % 5 >= 5; \n "
" return a % 5 > 5; \n "
" } " ) ;
2012-04-26 23:04:55 +02:00
ASSERT_EQUALS ( " [test.cpp:2]: (warning) Comparison of modulo result is predetermined, because it is always less than 5. \n "
" [test.cpp:3]: (warning) Comparison of modulo result is predetermined, because it is always less than 5. \n "
" [test.cpp:4]: (warning) Comparison of modulo result is predetermined, because it is always less than 5. \n "
" [test.cpp:5]: (warning) Comparison of modulo result is predetermined, because it is always less than 5. \n "
" [test.cpp:6]: (warning) Comparison of modulo result is predetermined, because it is always less than 5. \n "
" [test.cpp:7]: (warning) Comparison of modulo result is predetermined, because it is always less than 5. \n " , errout . str ( ) ) ;
2012-04-26 15:23:47 +02:00
check ( " void f(bool& b1, bool& b2) { \n "
" b1 = bar() % 5 < 889; \n "
" if(x[593] % 5 <= 5) \n "
" b2 = x.a % 5 == 5; \n "
" } " ) ;
2012-04-26 23:04:55 +02:00
ASSERT_EQUALS ( " [test.cpp:2]: (warning) Comparison of modulo result is predetermined, because it is always less than 5. \n "
" [test.cpp:3]: (warning) Comparison of modulo result is predetermined, because it is always less than 5. \n "
" [test.cpp:4]: (warning) Comparison of modulo result is predetermined, because it is always less than 5. \n " , errout . str ( ) ) ;
2012-04-26 15:23:47 +02:00
}
2011-10-13 20:53:06 +02:00
void incorrectLogicOperator1 ( ) {
2010-11-04 08:10:25 +01:00
check ( " void f(int x) { \n "
2010-10-25 03:14:21 +02:00
" if ((x != 1) || (x != 3)) \n "
" a++; \n "
" } \n "
) ;
2012-03-15 20:38:28 +01:00
ASSERT_EQUALS ( " [test.cpp:2]: (warning) Logical disjunction always evaluates to true: x != 1 || x != 3. \n " , errout . str ( ) ) ;
2010-10-25 03:14:21 +02:00
2010-11-04 08:10:25 +01:00
check ( " void f(int x) { \n "
2010-10-25 03:14:21 +02:00
" if (1 != x || 3 != x) \n "
" a++; \n "
" } \n "
) ;
2012-03-15 20:38:28 +01:00
ASSERT_EQUALS ( " [test.cpp:2]: (warning) Logical disjunction always evaluates to true: x != 1 || x != 3. \n " , errout . str ( ) ) ;
2010-10-25 03:14:21 +02:00
2010-11-04 08:10:25 +01:00
check ( " void f(int x, int y) { \n "
2010-10-25 03:14:21 +02:00
" if (x != 1 || y != 1) \n "
" a++; \n "
" } \n "
) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2010-11-04 08:10:25 +01:00
check ( " void f(int x, int y) { \n "
2010-10-25 03:14:21 +02:00
" if ((y == 1) && (x != 1) || (x != 3)) \n "
" a++; \n "
" } \n "
) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2010-11-04 08:10:25 +01:00
check ( " void f(int x, int y) { \n "
2010-10-25 03:14:21 +02:00
" if ((x != 1) || (x != 3) && (y == 1)) \n "
" a++; \n "
" } \n "
) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2010-11-04 08:10:25 +01:00
check ( " void f(int x) { \n "
2010-10-25 03:14:21 +02:00
" if ((x != 1) && (x != 3)) \n "
" a++; \n "
" } \n "
) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2010-11-04 08:10:25 +01:00
check ( " void f(int x) { \n "
2010-10-25 03:14:21 +02:00
" if ((x == 1) || (x == 3)) \n "
" a++; \n "
" } \n "
) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2010-11-04 08:10:25 +01:00
check ( " void f(int x, int y) { \n "
2010-10-25 03:14:21 +02:00
" if ((x != 1) || (y != 3)) \n "
" a++; \n "
" } \n "
) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2010-11-04 08:10:25 +01:00
check ( " void f(int x, int y) { \n "
" if ((x != hotdog) || (y != hotdog)) \n "
" a++; \n "
" } \n "
) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check ( " void f(int x, int y) { \n "
" if ((x != 5) || (y != 5)) \n "
" a++; \n "
" } \n "
) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check ( " void f(int x) { \n "
" const int ERR1 = 5; \n "
" const int ERR2 = 6; \n "
" if ((x != ERR1) || (x != ERR2)) \n "
" a++; \n "
" } \n "
) ;
2012-03-15 20:38:28 +01:00
ASSERT_EQUALS ( " [test.cpp:4]: (warning) Logical disjunction always evaluates to true: x != 5 || x != 6. \n " , errout . str ( ) ) ;
2010-11-04 08:10:25 +01:00
check ( " void f(int x, int y) { \n "
" const int ERR1 = 5; \n "
" if ((x != ERR1) || (y != ERR1)) \n "
" a++; \n "
" } \n "
) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2010-11-21 09:06:43 +01:00
check ( " void f(unsigned int a, unsigned int b, unsigned int c) { \n "
" if((a != b) || (c != b) || (c != a)) \n "
" { \n "
" return true; \n "
" } \n "
" return false; \n "
" } \n "
) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2011-07-17 04:06:23 +02:00
}
2011-10-13 20:53:06 +02:00
void incorrectLogicOperator2 ( ) {
2011-07-17 05:05:35 +02:00
check ( " void f(float x) { \n "
" if ((x == 1) && (x == 1.0)) \n "
" a++; \n "
" } \n "
) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check ( " void f(int x) { \n "
" if ((x == 1) && (x == 0x00000001)) \n "
" a++; \n "
" } \n "
) ;
2011-11-08 21:22:31 +01:00
ASSERT_EQUALS ( " [test.cpp:2] -> [test.cpp:2]: (style) Same expression on both sides of '&&'. \n " , errout . str ( ) ) ;
2011-07-17 05:05:35 +02:00
2011-07-17 04:06:23 +02:00
check ( " void f(int x) { \n "
" if (x == 1 && x == 3) \n "
" a++; \n "
" } \n "
) ;
2012-03-15 20:38:28 +01:00
ASSERT_EQUALS ( " [test.cpp:2]: (warning) Logical conjunction always evaluates to false: x == 1 && x == 3. \n " , errout . str ( ) ) ;
2011-07-17 04:06:23 +02:00
2011-07-17 05:05:35 +02:00
check ( " void f(int x) { \n "
" if (x == 1.0 && x == 3.0) \n "
" a++; \n "
" } \n "
) ;
2012-03-15 20:38:28 +01:00
ASSERT_EQUALS ( " [test.cpp:2]: (warning) Logical conjunction always evaluates to false: x == 1.0 && x == 3.0. \n " , errout . str ( ) ) ;
2011-07-17 05:05:35 +02:00
check ( " void f(float x) { \n "
" if (x == 1 && x == 1.0) \n "
" a++; \n "
" } \n "
) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check ( " void f(int x) { \n "
" if (x < 1 && x > 1) \n "
" a++; \n "
" } \n "
) ;
2012-03-15 20:38:28 +01:00
ASSERT_EQUALS ( " [test.cpp:2]: (warning) Logical conjunction always evaluates to false: x < 1 && x > 1. \n " , errout . str ( ) ) ;
2011-07-17 05:05:35 +02:00
check ( " void f(int x) { \n "
" if (x < 1.0 && x > 1.0) \n "
" a++; \n "
" } \n "
) ;
2012-03-15 20:38:28 +01:00
ASSERT_EQUALS ( " [test.cpp:2]: (warning) Logical conjunction always evaluates to false: x < 1.0 && x > 1.0. \n " , errout . str ( ) ) ;
2011-07-17 05:05:35 +02:00
check ( " void f(int x) { \n "
" if (x < 1 && x > 1.0) \n "
" a++; \n "
" } \n "
) ;
2012-03-15 20:38:28 +01:00
ASSERT_EQUALS ( " [test.cpp:2]: (warning) Logical conjunction always evaluates to false: x < 1 && x > 1.0. \n " , errout . str ( ) ) ;
2011-07-17 05:05:35 +02:00
2011-07-17 04:06:23 +02:00
check ( " void f(int x) { \n "
" if (x < 1 && x > 3) \n "
" a++; \n "
" } \n "
) ;
2012-03-15 20:38:28 +01:00
ASSERT_EQUALS ( " [test.cpp:2]: (warning) Logical conjunction always evaluates to false: x < 1 && x > 3. \n " , errout . str ( ) ) ;
2011-07-17 04:06:23 +02:00
2011-07-17 05:05:35 +02:00
check ( " void f(float x) { \n "
" if (x < 1.0 && x > 3.0) \n "
" a++; \n "
" } \n "
) ;
2012-03-15 20:38:28 +01:00
ASSERT_EQUALS ( " [test.cpp:2]: (warning) Logical conjunction always evaluates to false: x < 1.0 && x > 3.0. \n " , errout . str ( ) ) ;
2011-07-17 05:05:35 +02:00
2011-07-17 04:06:23 +02:00
check ( " void f(int x) { \n "
" if (1 > x && 3 < x) \n "
" a++; \n "
" } \n "
) ;
2012-03-15 20:38:28 +01:00
ASSERT_EQUALS ( " [test.cpp:2]: (warning) Logical conjunction always evaluates to false: x < 1 && x > 3. \n " , errout . str ( ) ) ;
2011-07-17 04:06:23 +02:00
check ( " void f(int x) { \n "
" if (x < 3 && x > 1) \n "
" a++; \n "
" } \n "
) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check ( " void f(int x) { \n "
" if (x > 3 || x < 10) \n "
" a++; \n "
" } \n "
) ;
2012-03-15 20:38:28 +01:00
ASSERT_EQUALS ( " [test.cpp:2]: (warning) Logical disjunction always evaluates to true: x > 3 || x < 10. \n " , errout . str ( ) ) ;
2011-07-17 04:06:23 +02:00
2011-07-17 22:28:00 +02:00
check ( " void f(int x) { \n "
" if (x >= 3 || x <= 10) \n "
" a++; \n "
" } \n "
) ;
2012-03-15 20:38:28 +01:00
ASSERT_EQUALS ( " [test.cpp:2]: (warning) Logical disjunction always evaluates to true: x >= 3 || x <= 10. \n " , errout . str ( ) ) ;
2011-07-17 22:28:00 +02:00
check ( " void f(int x) { \n "
" if (x >= 3 || x < 10) \n "
" a++; \n "
" } \n "
) ;
2012-03-15 20:38:28 +01:00
ASSERT_EQUALS ( " [test.cpp:2]: (warning) Logical disjunction always evaluates to true: x >= 3 || x < 10. \n " , errout . str ( ) ) ;
2011-07-17 22:28:00 +02:00
check ( " void f(int x) { \n "
" if (x > 3 || x <= 10) \n "
" a++; \n "
" } \n "
) ;
2012-03-15 20:38:28 +01:00
ASSERT_EQUALS ( " [test.cpp:2]: (warning) Logical disjunction always evaluates to true: x > 3 || x <= 10. \n " , errout . str ( ) ) ;
2011-07-17 22:28:00 +02:00
2011-07-17 04:06:23 +02:00
check ( " void f(int x) { \n "
" if (x > 3 || x < 3) \n "
" a++; \n "
" } \n "
) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2011-07-17 22:28:00 +02:00
check ( " void f(int x) { \n "
" if (x >= 3 || x <= 3) \n "
" a++; \n "
2012-03-12 19:06:30 +01:00
" } "
2011-07-17 22:28:00 +02:00
) ;
2012-03-15 20:38:28 +01:00
ASSERT_EQUALS ( " [test.cpp:2]: (warning) Logical disjunction always evaluates to true: x >= 3 || x <= 3. \n " , errout . str ( ) ) ;
2011-07-17 22:28:00 +02:00
check ( " void f(int x) { \n "
" if (x >= 3 || x < 3) \n "
" a++; \n "
2012-03-12 19:06:30 +01:00
" } "
2011-07-17 22:28:00 +02:00
) ;
2012-03-15 20:38:28 +01:00
ASSERT_EQUALS ( " [test.cpp:2]: (warning) Logical disjunction always evaluates to true: x >= 3 || x < 3. \n " , errout . str ( ) ) ;
2011-07-17 22:28:00 +02:00
check ( " void f(int x) { \n "
" if (x > 3 || x <= 3) \n "
" a++; \n "
2012-03-12 19:06:30 +01:00
" } "
2011-07-17 22:28:00 +02:00
) ;
2012-03-15 20:38:28 +01:00
ASSERT_EQUALS ( " [test.cpp:2]: (warning) Logical disjunction always evaluates to true: x > 3 || x <= 3. \n " , errout . str ( ) ) ;
2011-07-17 22:28:00 +02:00
2011-07-17 04:06:23 +02:00
check ( " void f(int x) { \n "
" if (x > 10 || x < 3) \n "
" a++; \n "
" } \n "
) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2011-12-23 16:08:53 +01:00
2011-08-19 19:28:37 +02:00
check ( " void f(int x) { \n "
2012-03-15 20:38:28 +01:00
" if (x > 5 && x == 1) \n "
2011-08-19 19:28:37 +02:00
" a++; \n "
" } \n "
) ;
2012-03-15 20:38:28 +01:00
ASSERT_EQUALS ( " [test.cpp:2]: (warning) Logical conjunction always evaluates to false: x > 5 && x == 1. \n " , errout . str ( ) ) ;
2011-08-19 19:28:37 +02:00
check ( " void f(int x) { \n "
2012-03-15 20:38:28 +01:00
" if (x > 5 && x == 6) \n "
2011-08-19 19:28:37 +02:00
" a++; \n "
" } \n "
) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2012-03-15 20:38:28 +01:00
// #3419
check ( " void f() { \n "
" if ( &q != &a && &q != &b ) { } \n "
" } " ) ;
2011-08-19 19:28:37 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2012-04-02 11:21:04 +02:00
// #3676
check ( " void f(int m_x2, int w, int x) { \n "
" if (x + w - 1 > m_x2 || m_x2 < 0 ) \n "
" m_x2 = x + w - 1; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2012-03-15 20:38:28 +01:00
}
2011-08-19 19:28:37 +02:00
2012-03-15 20:38:28 +01:00
void incorrectLogicOperator3 ( ) {
check ( " void f(int x, bool& b) { \n "
" b = x > 3 || x == 4; \n "
" b = x < 5 || x == 4; \n "
" b = x >= 3 || x == 4; \n "
" b = x <= 5 || x == 4; \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:2]: (warning) Logical disjunction always evaluates to true: x > 3 || x == 4. \n "
" [test.cpp:3]: (warning) Logical disjunction always evaluates to true: x < 5 || x == 4. \n "
" [test.cpp:4]: (warning) Logical disjunction always evaluates to true: x >= 3 || x == 4. \n "
" [test.cpp:5]: (warning) Logical disjunction always evaluates to true: x <= 5 || x == 4. \n " , errout . str ( ) ) ;
check ( " void f(int x, bool& b) { \n "
" b = x > 5 && x == 1; \n "
" b = x < 1 && x == 3; \n "
" b = x >= 5 && x == 1; \n "
" b = x <= 1 && x == 3; \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:2]: (warning) Logical conjunction always evaluates to false: x > 5 && x == 1. \n "
" [test.cpp:3]: (warning) Logical conjunction always evaluates to false: x < 1 && x == 3. \n "
" [test.cpp:4]: (warning) Logical conjunction always evaluates to false: x >= 5 && x == 1. \n "
" [test.cpp:5]: (warning) Logical conjunction always evaluates to false: x <= 1 && x == 3. \n " , errout . str ( ) ) ;
}
2011-08-19 19:28:37 +02:00
2012-03-15 20:38:28 +01:00
void secondAlwaysTrueFalseWhenFirstTrueError ( ) {
2011-08-19 19:28:37 +02:00
check ( " void f(int x) { \n "
2012-03-15 20:38:28 +01:00
" if (x > 5 && x != 1) \n "
2011-08-19 19:28:37 +02:00
" a++; \n "
" } \n "
) ;
2012-03-15 20:38:28 +01:00
ASSERT_EQUALS ( " [test.cpp:2]: (style) Redundant condition: If x > 5, the comparison x != 1 is always true. \n " , errout . str ( ) ) ;
2011-08-19 19:28:37 +02:00
check ( " void f(int x) { \n "
2012-03-15 20:38:28 +01:00
" if (x > 5 && x != 6) \n "
2011-08-19 19:28:37 +02:00
" a++; \n "
" } \n "
) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check ( " void f(int x) { \n "
2012-03-15 20:38:28 +01:00
" if ((x > 5) && (x != 1)) \n "
2011-08-19 19:28:37 +02:00
" a++; \n "
" } \n "
) ;
2012-03-15 20:38:28 +01:00
ASSERT_EQUALS ( " [test.cpp:2]: (style) Redundant condition: If x > 5, the comparison x != 1 is always true. \n " , errout . str ( ) ) ;
2011-08-19 19:28:37 +02:00
check ( " void f(int x) { \n "
2012-03-15 20:38:28 +01:00
" if ((x > 5) && (x != 6)) \n "
2011-08-19 19:28:37 +02:00
" a++; \n "
" } \n "
) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2012-03-15 20:38:28 +01:00
check ( " void f(int x, bool& b) { \n "
" b = x > 5 || x != 1; \n "
" b = x < 1 || x != 3; \n "
" b = x >= 5 || x != 1; \n "
" b = x <= 1 || x != 3; \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:2]: (style) Redundant condition: If x > 5, the comparison x != 1 is always true. \n "
" [test.cpp:3]: (style) Redundant condition: If x < 1, the comparison x != 3 is always true. \n "
" [test.cpp:4]: (style) Redundant condition: If x >= 5, the comparison x != 1 is always true. \n "
" [test.cpp:5]: (style) Redundant condition: If x <= 1, the comparison x != 3 is always true. \n " , errout . str ( ) ) ;
2011-08-19 19:28:37 +02:00
2012-03-15 20:38:28 +01:00
check ( " void f(int x, bool& b) { \n "
" b = x > 6 && x > 5; \n "
" b = x > 5 || x > 6; \n "
" b = x < 6 && x < 5; \n "
" b = x < 5 || x < 6; \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:2]: (style) Redundant condition: If x > 5, the comparison x > 6 is always true. \n "
" [test.cpp:3]: (style) Redundant condition: If x > 5, the comparison x > 6 is always true. \n "
" [test.cpp:4]: (style) Redundant condition: If x < 6, the comparison x < 5 is always true. \n "
" [test.cpp:5]: (style) Redundant condition: If x < 6, the comparison x < 5 is always true. \n " , errout . str ( ) ) ;
2011-08-19 19:28:37 +02:00
}
2012-03-12 19:06:30 +01:00
void incorrectLogicOp_condSwapping ( ) {
check ( " void f(int x) { \n "
" if (x < 1 && x > 3) \n "
" a++; \n "
" } " ) ;
2012-03-15 20:38:28 +01:00
ASSERT_EQUALS ( " [test.cpp:2]: (warning) Logical conjunction always evaluates to false: x < 1 && x > 3. \n " , errout . str ( ) ) ;
2012-03-12 19:06:30 +01:00
check ( " void f(int x) { \n "
" if (1 > x && x > 3) \n "
" a++; \n "
" } " ) ;
2012-03-15 20:38:28 +01:00
ASSERT_EQUALS ( " [test.cpp:2]: (warning) Logical conjunction always evaluates to false: x < 1 && x > 3. \n " , errout . str ( ) ) ;
2012-03-12 19:06:30 +01:00
check ( " void f(int x) { \n "
" if (x < 1 && 3 < x) \n "
" a++; \n "
" } " ) ;
2012-03-15 20:38:28 +01:00
ASSERT_EQUALS ( " [test.cpp:2]: (warning) Logical conjunction always evaluates to false: x < 1 && x > 3. \n " , errout . str ( ) ) ;
2012-03-12 19:06:30 +01:00
check ( " void f(int x) { \n "
" if (1 > x && 3 < x) \n "
" a++; \n "
" } " ) ;
2012-03-15 20:38:28 +01:00
ASSERT_EQUALS ( " [test.cpp:2]: (warning) Logical conjunction always evaluates to false: x < 1 && x > 3. \n " , errout . str ( ) ) ;
2012-03-12 19:06:30 +01:00
check ( " void f(int x) { \n "
" if (x > 3 && x < 1) \n "
" a++; \n "
" } " ) ;
2012-03-15 20:38:28 +01:00
ASSERT_EQUALS ( " [test.cpp:2]: (warning) Logical conjunction always evaluates to false: x < 1 && x > 3. \n " , errout . str ( ) ) ;
2012-03-12 19:06:30 +01:00
check ( " void f(int x) { \n "
" if (3 < x && x < 1) \n "
" a++; \n "
" } " ) ;
2012-03-15 20:38:28 +01:00
ASSERT_EQUALS ( " [test.cpp:2]: (warning) Logical conjunction always evaluates to false: x < 1 && x > 3. \n " , errout . str ( ) ) ;
2012-03-12 19:06:30 +01:00
check ( " void f(int x) { \n "
" if (x > 3 && 1 > x) \n "
" a++; \n "
" } " ) ;
2012-03-15 20:38:28 +01:00
ASSERT_EQUALS ( " [test.cpp:2]: (warning) Logical conjunction always evaluates to false: x < 1 && x > 3. \n " , errout . str ( ) ) ;
2012-03-12 19:06:30 +01:00
check ( " void f(int x) { \n "
" if (3 < x && 1 > x) \n "
" a++; \n "
" } " ) ;
2012-03-15 20:38:28 +01:00
ASSERT_EQUALS ( " [test.cpp:2]: (warning) Logical conjunction always evaluates to false: x < 1 && x > 3. \n " , errout . str ( ) ) ;
2012-03-12 19:06:30 +01:00
}
2011-10-10 19:11:17 +02:00
2012-04-02 15:45:51 +02:00
void comparisonOfBoolExpressionWithInt1 ( ) {
2011-10-10 19:11:17 +02:00
check ( " void f(int x) { \n "
" if ((x && 0x0f)==6) \n "
" a++; \n "
" } \n "
) ;
ASSERT_EQUALS ( " [test.cpp:2]: (warning) Comparison of a boolean expression with an integer other than 0 or 1. \n " , errout . str ( ) ) ;
check ( " void f(int x) { \n "
" if ((x && 0x0f)==0) \n "
" a++; \n "
" } \n "
) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check ( " void f(int x) { \n "
" if ((x || 0x0f)==6) \n "
" a++; \n "
" } \n "
) ;
2012-04-02 15:45:51 +02:00
ASSERT_EQUALS ( " [test.cpp:2]: (warning) Comparison of a boolean expression with an integer other than 0 or 1. \n "
" [test.cpp:2]: (warning) Comparison of a boolean with an integer \n " , errout . str ( ) ) ; // The second message appears because the code is simplified to "true == 6". Its neither wrong nor necessary.
2011-10-10 19:11:17 +02:00
check ( " void f(int x) { \n "
" if ((x || 0x0f)==0) \n "
" a++; \n "
" } \n "
) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check ( " void f(int x) { \n "
" if ((x & 0x0f)==6) \n "
" a++; \n "
" } \n "
) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check ( " void f(int x) { \n "
" if ((x | 0x0f)==6) \n "
" a++; \n "
" } \n "
) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check ( " void f(int x) { \n "
" if ((5 && x)==3) \n "
" a++; \n "
" } \n "
) ;
ASSERT_EQUALS ( " [test.cpp:2]: (warning) Comparison of a boolean expression with an integer other than 0 or 1. \n " , errout . str ( ) ) ;
check ( " void f(int x) { \n "
" if ((5 && x)==3 || (8 && x)==9) \n "
" a++; \n "
" } \n "
) ;
ASSERT_EQUALS ( " [test.cpp:2]: (warning) Comparison of a boolean expression with an integer other than 0 or 1. \n " , errout . str ( ) ) ;
check ( " void f(int x) { \n "
" if ((5 && x)!=3) \n "
" a++; \n "
" } \n "
) ;
ASSERT_EQUALS ( " [test.cpp:2]: (warning) Comparison of a boolean expression with an integer other than 0 or 1. \n " , errout . str ( ) ) ;
check ( " void f(int x) { \n "
" if ((5 && x) > 3) \n "
" a++; \n "
" } \n "
) ;
ASSERT_EQUALS ( " [test.cpp:2]: (warning) Comparison of a boolean expression with an integer other than 0 or 1. \n " , errout . str ( ) ) ;
check ( " void f(int x) { \n "
" if ((5 && x) > 0) \n "
" a++; \n "
" } \n "
) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check ( " void f(int x) { \n "
" if ((5 && x) < 0) \n "
" a++; \n "
" } \n "
) ;
ASSERT_EQUALS ( " [test.cpp:2]: (warning) Comparison of a boolean expression with an integer other than 0 or 1. \n " , errout . str ( ) ) ;
check ( " void f(int x) { \n "
" if ((5 && x) < 1) \n "
" a++; \n "
" } \n "
) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check ( " void f(int x) { \n "
" if ((5 && x) > 1) \n "
" a++; \n "
" } \n "
) ;
ASSERT_EQUALS ( " [test.cpp:2]: (warning) Comparison of a boolean expression with an integer other than 0 or 1. \n " , errout . str ( ) ) ;
check ( " void f(int x) { \n "
" if (0 < (5 && x)) \n "
" a++; \n "
" } \n "
) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check ( " void f(int x) { \n "
" if (0 > (5 && x)) \n "
" a++; \n "
" } \n "
) ;
ASSERT_EQUALS ( " [test.cpp:2]: (warning) Comparison of a boolean expression with an integer other than 0 or 1. \n " , errout . str ( ) ) ;
check ( " void f(int x) { \n "
" if (1 > (5 && x)) \n "
" a++; \n "
" } \n "
) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check ( " void f(int x) { \n "
" if (1 < (5 && x)) \n "
" a++; \n "
" } \n "
) ;
ASSERT_EQUALS ( " [test.cpp:2]: (warning) Comparison of a boolean expression with an integer other than 0 or 1. \n " , errout . str ( ) ) ;
2011-12-23 19:11:51 +01:00
check ( " typedef int (*func)(bool invert); \n "
" void x(int, func f); \n "
" void foo(int error) { \n "
" if (error == ABC) { } \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2011-10-10 19:11:17 +02:00
}
2012-04-02 15:45:51 +02:00
void comparisonOfBoolExpressionWithInt2 ( ) {
check ( " void f(int x) { \n "
" if (!x == 10) { \n "
" printf( \" x not equal to 10 \" ); \n "
" } \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:2]: (warning) Comparison of a boolean expression with an integer other than 0 or 1. \n " , errout . str ( ) ) ;
check ( " void f(int x) { \n "
" if (!x != 10) { \n "
" printf( \" x not equal to 10 \" ); \n "
" } \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:2]: (warning) Comparison of a boolean expression with an integer other than 0 or 1. \n " , errout . str ( ) ) ;
check ( " void f(int x) { \n "
" if (x != 10) { \n "
" printf( \" x not equal to 10 \" ); \n "
" } \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check ( " void f(int x) { \n "
" if (10 == !x) { \n "
" printf( \" x not equal to 10 \" ); \n "
" } \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:2]: (warning) Comparison of a boolean expression with an integer other than 0 or 1. \n " , errout . str ( ) ) ;
check ( " void f(int x) { \n "
" if (10 != !x) { \n "
" printf( \" x not equal to 10 \" ); \n "
" } \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:2]: (warning) Comparison of a boolean expression with an integer other than 0 or 1. \n " , errout . str ( ) ) ;
check ( " void f(int x, int y) { \n "
" if (y != !x) { \n "
" printf( \" x not equal to 10 \" ); \n "
" } \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:2]: (warning) Comparison of a boolean expression with an integer. \n " , errout . str ( ) ) ;
check ( " void f(int x, bool y) { \n "
" if (y != !x) { \n "
" printf( \" x not equal to 10 \" ); \n "
" } \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check ( " void f(int x) { \n "
" if (10 != x) { \n "
" printf( \" x not equal to 10 \" ); \n "
" } \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2012-05-22 19:01:21 +02:00
void comparisonOfBoolExpressionWithInt3 ( ) {
check ( " int f(int x) { \n "
" return t<0>() && x; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2011-10-10 19:11:17 +02:00
2011-10-13 20:53:06 +02:00
void memsetZeroBytes ( ) {
2011-01-06 11:31:58 +01:00
check ( " void f() { \n "
2011-10-22 22:34:10 +02:00
" memset(p, 10, 0x0); \n "
2011-01-06 11:31:58 +01:00
" } \n "
) ;
ASSERT_EQUALS ( " [test.cpp:2]: (warning) memset() called to fill 0 "
2011-01-06 16:27:22 +01:00
" bytes of \' p \' \n " , errout . str ( ) ) ;
2011-01-06 11:31:58 +01:00
check ( " void f() { \n "
2011-10-20 21:46:34 +02:00
" memset(p, sizeof(p), 0); \n "
2011-01-06 11:31:58 +01:00
" } \n "
) ;
2011-10-22 22:34:10 +02:00
ASSERT_EQUALS ( " [test.cpp:2]: (warning) memset() called to fill 0 "
" bytes of \' p \' \n " , errout . str ( ) ) ;
2011-01-30 12:54:19 +01:00
2011-10-22 22:34:10 +02:00
check ( " void f() { \n "
" memset(p, sizeof(p), i+0); \n "
" } \n "
) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2011-01-06 11:31:58 +01:00
}
2011-01-22 19:21:56 +01:00
2011-10-13 20:53:06 +02:00
void sizeofForArrayParameter ( ) {
2011-01-22 19:21:56 +01:00
check ( " void f() { \n "
" int a[10]; \n "
" std::cout << sizeof(a) / sizeof(int) << std::endl; \n "
" } \n "
) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check ( " void f() { \n "
" unsigned int a = 2; \n "
" unsigned int b = 2; \n "
" int c[(a+b)]; \n "
" std::cout << sizeof(c) / sizeof(int) << std::endl; \n "
" } \n "
) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check ( " void f() { \n "
" unsigned int a = { 2 }; \n "
" unsigned int b[] = { 0 }; \n "
" int c[a[b[0]]]; \n "
" std::cout << sizeof(c) / sizeof(int) << std::endl; \n "
" } \n "
) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check ( " void f() { \n "
" unsigned int a[] = { 1 }; \n "
" unsigned int b = 2; \n "
" int c[(a[0]+b)]; \n "
" std::cout << sizeof(c) / sizeof(int) << std::endl; \n "
" } \n "
) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check ( " void f() { \n "
" int a[] = { 1, 2, 3 }; \n "
" std::cout << sizeof(a) / sizeof(int) << std::endl; \n "
" } \n "
) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check ( " void f() { \n "
" int a[3] = { 1, 2, 3 }; \n "
" std::cout << sizeof(a) / sizeof(int) << std::endl; \n "
" } \n "
) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check ( " void f( int a[]) { \n "
" std::cout << sizeof(a) / sizeof(int) << std::endl; \n "
" } \n "
) ;
ASSERT_EQUALS ( " [test.cpp:2]: (error) Using sizeof for array given as "
" function argument returns the size of pointer. \n " , errout . str ( ) ) ;
check ( " void f( int a[]) { \n "
" std::cout << sizeof a / sizeof(int) << std::endl; \n "
" } \n "
) ;
ASSERT_EQUALS ( " [test.cpp:2]: (error) Using sizeof for array given as "
" function argument returns the size of pointer. \n " , errout . str ( ) ) ;
check ( " void f( int a[3] ) { \n "
" std::cout << sizeof(a) / sizeof(int) << std::endl; \n "
" } \n "
) ;
ASSERT_EQUALS ( " [test.cpp:2]: (error) Using sizeof for array given as "
" function argument returns the size of pointer. \n " , errout . str ( ) ) ;
check ( " void f(int *p) { \n "
" p[0] = 0; \n "
2011-10-23 12:20:43 +02:00
" int unused = sizeof(p); \n "
2011-01-22 19:21:56 +01:00
" } \n "
) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2011-01-24 19:04:56 +01:00
check ( " void f() { \n "
" char p[] = \" test \" ; \n "
2011-10-23 12:20:43 +02:00
" int unused = sizeof(p); \n "
2011-01-24 19:04:56 +01:00
" } \n "
) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2011-09-06 22:37:19 +02:00
// ticket #2495
2011-01-25 09:57:58 +01:00
check ( " void f() { \n "
" static float col[][3]={ \n "
" {1,0,0}, \n "
" {0,0,1}, \n "
" {0,1,0}, \n "
" {1,0,1}, \n "
" {1,0,1}, \n "
" {1,0,1}, \n "
" }; \n "
" const int COL_MAX=sizeof(col)/sizeof(col[0]); \n "
" } \n "
) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2011-09-06 22:37:19 +02:00
// ticket #155
2011-01-25 10:05:03 +01:00
check ( " void f() { \n "
" char buff1[1024*64],buff2[sizeof(buff1)*2]; \n "
" } \n "
) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2011-09-06 22:37:19 +02:00
// ticket #2510
2011-01-26 20:08:06 +01:00
check ( " void f( int a[], int b) { \n "
" std::cout << sizeof(a) / sizeof(int) << std::endl; \n "
" } \n "
) ;
ASSERT_EQUALS ( " [test.cpp:2]: (error) Using sizeof for array given as "
" function argument returns the size of pointer. \n " , errout . str ( ) ) ;
2011-09-06 22:37:19 +02:00
// ticket #2510
2011-01-26 20:08:06 +01:00
check ( " void f( int a[3] , int b[2] ) { \n "
" std::cout << sizeof(a) / sizeof(int) << std::endl; \n "
" } \n "
) ;
ASSERT_EQUALS ( " [test.cpp:2]: (error) Using sizeof for array given as "
" function argument returns the size of pointer. \n " , errout . str ( ) ) ;
2011-09-06 22:37:19 +02:00
// ticket #2510
2011-01-26 20:08:06 +01:00
check ( " void f() { \n "
" char buff1[1024*64],buff2[sizeof(buff1)*(2+1)]; \n "
" } \n "
) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2011-05-16 21:16:25 +02:00
}
2011-01-26 20:08:06 +01:00
2011-10-13 20:53:06 +02:00
void sizeofForNumericParameter ( ) {
2011-05-16 21:16:25 +02:00
check ( " void f() { \n "
" std::cout << sizeof(10) << std::endl; \n "
2011-11-27 18:50:21 +01:00
" } \n " ,
NULL , true
2011-05-16 21:16:25 +02:00
) ;
2011-12-16 19:21:14 +01:00
ASSERT_EQUALS ( " [test.cpp:2]: (warning) Using sizeof with a numeric constant as function argument might not be what you intended. \n " , errout . str ( ) ) ;
2011-05-16 21:16:25 +02:00
2011-05-26 20:04:47 +02:00
check ( " void f() { \n "
" std::cout << sizeof(-10) << std::endl; \n "
2011-11-27 18:50:21 +01:00
" } \n " ,
NULL , true
2011-05-26 20:04:47 +02:00
) ;
2011-12-16 19:21:14 +01:00
ASSERT_EQUALS ( " [test.cpp:2]: (warning) Using sizeof with a numeric constant as function argument might not be what you intended. \n " , errout . str ( ) ) ;
2011-05-26 20:04:47 +02:00
2011-05-16 21:16:25 +02:00
check ( " void f() { \n "
" std::cout << sizeof 10 << std::endl; \n "
2011-11-27 18:50:21 +01:00
" } \n " ,
NULL , true
2011-05-16 21:16:25 +02:00
) ;
2011-12-16 19:21:14 +01:00
ASSERT_EQUALS ( " [test.cpp:2]: (warning) Using sizeof with a numeric constant as function argument might not be what you intended. \n " , errout . str ( ) ) ;
2011-01-26 20:08:06 +01:00
2011-05-26 20:04:47 +02:00
check ( " void f() { \n "
" std::cout << sizeof -10 << std::endl; \n "
2011-11-27 18:50:21 +01:00
" } \n " ,
NULL , true
2011-05-26 20:04:47 +02:00
) ;
2011-12-16 19:21:14 +01:00
ASSERT_EQUALS ( " [test.cpp:2]: (warning) Using sizeof with a numeric constant as function argument might not be what you intended. \n " , errout . str ( ) ) ;
2011-05-26 20:04:47 +02:00
2011-01-24 21:40:49 +01:00
}
2011-01-25 09:57:58 +01:00
2011-10-13 20:53:06 +02:00
void clarifyCalculation ( ) {
2011-01-24 21:40:49 +01:00
check ( " int f(char c) { \n "
" return 10 * (c == 0) ? 1 : 2; \n "
" } " ) ;
2011-04-02 17:27:36 +02:00
ASSERT_EQUALS ( " [test.cpp:2]: (style) Clarify calculation precedence for * and ? \n " , errout . str ( ) ) ;
2011-01-24 19:04:56 +01:00
2011-01-24 21:40:49 +01:00
check ( " void f(char c) { \n "
" printf( \" %i \" , 10 * (c == 0) ? 1 : 2); \n "
" } " ) ;
2011-04-02 17:27:36 +02:00
ASSERT_EQUALS ( " [test.cpp:2]: (style) Clarify calculation precedence for * and ? \n " , errout . str ( ) ) ;
2011-02-17 21:30:59 +01:00
// Ticket #2585 - segmentation fault for invalid code
check ( " abcdef? " " ?< "
" 123456? " " ?> "
" +? " " ?= " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2011-04-02 11:43:20 +02:00
check ( " void f(char c) { \n "
2012-03-27 21:29:50 +02:00
" printf( \" %i \" , 1 + 1 ? 1 : 2); \n " // "1+1" is simplified away
2011-04-02 11:43:20 +02:00
" } " ) ;
2012-03-27 21:29:50 +02:00
TODO_ASSERT_EQUALS ( " [test.cpp:2]: (style) Clarify calculation precedence for + and ? \n " , " " , errout . str ( ) ) ; // TODO: Is that really necessary, or is this pattern too unlikely?
2011-04-03 22:12:22 +02:00
check ( " void f() { \n "
" std::cout << x << 1 ? 2 : 3; \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:2]: (style) Clarify calculation precedence for << and ? \n " , errout . str ( ) ) ;
2011-04-04 21:33:16 +02:00
check ( " void f() { \n "
" int ab = a - b ? 2 : 3; \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:2]: (style) Clarify calculation precedence for - and ? \n " , errout . str ( ) ) ;
2011-09-06 22:37:19 +02:00
// ticket #195
check ( " int f(int x, int y) { \n "
" return x >> ! y ? 8 : 2; \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:2]: (style) Clarify calculation precedence for >> and ? \n " , errout . str ( ) ) ;
2011-12-23 12:13:39 +01:00
check ( " int f() { \n "
" return (shift < sizeof(int64_t)*8 ? 1 : 2); \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2011-01-22 19:21:56 +01:00
}
2011-03-09 22:20:14 +01:00
// clarify conditions with = and comparison
2011-10-13 20:53:06 +02:00
void clarifyCondition1 ( ) {
2011-03-09 22:20:14 +01:00
check ( " void f() { \n "
" if (x = b() < 0) {} \n "
" } " ) ;
2011-03-30 16:44:16 +02:00
ASSERT_EQUALS ( " [test.cpp:2]: (style) Suspicious condition (assignment+comparison), it can be clarified with parentheses \n " , errout . str ( ) ) ;
2011-08-19 13:54:06 +02:00
check ( " void f(int i) { \n "
" for (i = 0; i < 10; i++) {} \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2011-08-19 18:06:28 +02:00
check ( " void f() { \n "
" if (x = a<int>()) {} \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2011-03-09 22:20:14 +01:00
}
2011-08-19 00:14:15 +02:00
// clarify conditions with bitwise operator and comparison
2011-10-13 20:53:06 +02:00
void clarifyCondition2 ( ) {
2011-08-19 00:14:15 +02:00
check ( " void f() { \n "
" if (x & 2 == 2) {} \n "
" } " ) ;
2011-08-19 00:56:15 +02:00
ASSERT_EQUALS ( " [test.cpp:2]: (style) Suspicious condition (bitwise operator + comparison), it can be clarified with parentheses \n " , errout . str ( ) ) ;
check ( " void f() { \n "
" if (a & fred1.x == fred2.y) {} \n "
" } " ) ;
2011-08-19 00:14:15 +02:00
ASSERT_EQUALS ( " [test.cpp:2]: (style) Suspicious condition (bitwise operator + comparison), it can be clarified with parentheses \n " , errout . str ( ) ) ;
}
2011-08-19 13:40:54 +02:00
// clarify condition that uses ! operator and then bitwise operator
2011-10-13 20:53:06 +02:00
void clarifyCondition3 ( ) {
2011-08-19 13:40:54 +02:00
check ( " void f(int w) { \n "
" if(!w & 0x8000) {} \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:2]: (style) Boolean result is used in bitwise operation. Clarify expression with parentheses \n " , errout . str ( ) ) ;
check ( " void f() { \n "
" if (x == foo() & 2) {} \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:2]: (style) Boolean result is used in bitwise operation. Clarify expression with parentheses \n " , errout . str ( ) ) ;
2011-08-19 17:07:26 +02:00
check ( " void f(std::list<int> &ints) { } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2011-08-19 18:06:28 +02:00
check ( " void f() { A<x &> a; } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2011-08-19 18:55:20 +02:00
2011-09-11 09:46:01 +02:00
check ( " class A<B&,C>; " , " test.C " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2011-08-19 18:55:20 +02:00
check ( " void f() { \n "
" if (result != (char *)&inline_result) { } \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2011-08-19 13:40:54 +02:00
}
2011-10-13 20:53:06 +02:00
void clarifyCondition4 ( ) { // ticket #3110
2011-09-13 02:46:00 +02:00
check ( " typedef double SomeType; \n "
" typedef std::pair<std::string,SomeType> PairType; \n "
" struct S \n "
" { \n "
" bool operator() \n "
" ( PairType const & left \n "
" , PairType const & right) const \n "
" { \n "
" return (left.first < right.first); \n "
" } \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2012-04-08 18:07:11 +02:00
void clarifyCondition5 ( ) { // ticket #3609 (using | in template instantiation)
check ( " CWinTraits<WS_CHILD|WS_VISIBLE>::GetWndStyle(0); " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2011-10-13 20:53:06 +02:00
void bitwiseOnBoolean ( ) { // 3062
2011-10-06 22:01:48 +02:00
check ( " void f(_Bool a, _Bool b) { \n "
" if(a & b) {} \n "
" } " ) ;
2012-05-06 19:37:41 +02:00
ASSERT_EQUALS ( " [test.cpp:2]: (style, inconclusive) Boolean variable 'a' is used in bitwise operation. Did you mean && ? \n " , errout . str ( ) ) ;
2011-10-06 22:01:48 +02:00
check ( " void f(_Bool a, _Bool b) { \n "
" if(a | b) {} \n "
" } " ) ;
2012-05-06 19:37:41 +02:00
ASSERT_EQUALS ( " [test.cpp:2]: (style, inconclusive) Boolean variable 'a' is used in bitwise operation. Did you mean || ? \n " , errout . str ( ) ) ;
2011-10-06 22:01:48 +02:00
check ( " void f(bool a, bool b) { \n "
" if(a & b) {} \n "
" } " ) ;
2012-05-06 19:37:41 +02:00
ASSERT_EQUALS ( " [test.cpp:2]: (style, inconclusive) Boolean variable 'a' is used in bitwise operation. Did you mean && ? \n " , errout . str ( ) ) ;
2011-10-06 22:01:48 +02:00
check ( " void f(bool a, bool b) { \n "
" if(a & !b) {} \n "
" } " ) ;
2012-05-06 19:37:41 +02:00
ASSERT_EQUALS ( " [test.cpp:2]: (style, inconclusive) Boolean variable 'a' is used in bitwise operation. Did you mean && ? \n " , errout . str ( ) ) ;
2011-10-06 22:01:48 +02:00
check ( " void f(bool a, bool b) { \n "
" if(a | b) {} \n "
" } " ) ;
2012-05-06 19:37:41 +02:00
ASSERT_EQUALS ( " [test.cpp:2]: (style, inconclusive) Boolean variable 'a' is used in bitwise operation. Did you mean || ? \n " , errout . str ( ) ) ;
2011-10-06 22:01:48 +02:00
check ( " void f(bool a, bool b) { \n "
" if(a | !b) {} \n "
" } " ) ;
2012-05-06 19:37:41 +02:00
ASSERT_EQUALS ( " [test.cpp:2]: (style, inconclusive) Boolean variable 'a' is used in bitwise operation. Did you mean || ? \n " , errout . str ( ) ) ;
2011-10-06 22:01:48 +02:00
check ( " bool a, b; \n "
" void f() { \n "
" if(a & b) {} \n "
" } " ) ;
2012-05-06 19:37:41 +02:00
ASSERT_EQUALS ( " [test.cpp:3]: (style, inconclusive) Boolean variable 'a' is used in bitwise operation. Did you mean && ? \n " , errout . str ( ) ) ;
2011-10-06 22:01:48 +02:00
check ( " bool a, b; \n "
" void f() { \n "
" if(a & !b) {} \n "
" } " ) ;
2012-05-06 19:37:41 +02:00
ASSERT_EQUALS ( " [test.cpp:3]: (style, inconclusive) Boolean variable 'a' is used in bitwise operation. Did you mean && ? \n " , errout . str ( ) ) ;
2011-10-06 22:01:48 +02:00
check ( " bool a, b; \n "
" void f() { \n "
" if(a | b) {} \n "
" } " ) ;
2012-05-06 19:37:41 +02:00
ASSERT_EQUALS ( " [test.cpp:3]: (style, inconclusive) Boolean variable 'a' is used in bitwise operation. Did you mean || ? \n " , errout . str ( ) ) ;
2011-10-06 22:01:48 +02:00
check ( " bool a, b; \n "
" void f() { \n "
" if(a | !b) {} \n "
" } " ) ;
2012-05-06 19:37:41 +02:00
ASSERT_EQUALS ( " [test.cpp:3]: (style, inconclusive) Boolean variable 'a' is used in bitwise operation. Did you mean || ? \n " , errout . str ( ) ) ;
2012-03-03 21:14:20 +01:00
check ( " void f(bool a, int b) { \n "
" if(a & b) {} \n "
" } " ) ;
2012-05-06 19:37:41 +02:00
ASSERT_EQUALS ( " [test.cpp:2]: (style, inconclusive) Boolean variable 'a' is used in bitwise operation. Did you mean && ? \n " , errout . str ( ) ) ;
2012-03-03 21:14:20 +01:00
check ( " void f(int a, bool b) { \n "
" if(a & b) {} \n "
" } " ) ;
2012-05-06 19:37:41 +02:00
ASSERT_EQUALS ( " [test.cpp:2]: (style, inconclusive) Boolean variable 'b' is used in bitwise operation. Did you mean && ? \n " , errout . str ( ) ) ;
2012-03-03 21:14:20 +01:00
check ( " void f(bool a, bool b) { \n "
" if(a & b) {} \n "
" } " ) ;
2012-05-06 19:37:41 +02:00
ASSERT_EQUALS ( " [test.cpp:2]: (style, inconclusive) Boolean variable 'a' is used in bitwise operation. Did you mean && ? \n " , errout . str ( ) ) ;
2012-03-03 21:14:20 +01:00
check ( " void f(int a, int b) { \n "
" if(a & b) {} \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check ( " void f(bool b) { \n "
" foo(bar, &b); \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2011-10-06 22:01:48 +02:00
}
2011-10-13 20:53:06 +02:00
void incorrectStringCompare ( ) {
2011-02-08 19:49:29 +01:00
check ( " int f() { \n "
" return test.substr( 0 , 4 ) == \" Hello \" ? : 0 : 1 ; \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:2]: (warning) String literal \" Hello \" doesn't match length argument for substr(4). \n " , errout . str ( ) ) ;
check ( " int f() { \n "
" return test.substr( 0 , 5 ) == \" Hello \" ? : 0 : 1 ; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check ( " int f() { \n "
" return \" Hello \" == test.substr( 0 , 4 ) ? : 0 : 1 ; \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:2]: (warning) String literal \" Hello \" doesn't match length argument for substr(4). \n " , errout . str ( ) ) ;
check ( " int f() { \n "
" return \" Hello \" == test.substr( 0 , 5 ) ? : 0 : 1 ; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2011-10-18 21:37:03 +02:00
check ( " int f() { \n "
" if ( \" Hello \" ) { } \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:2]: (warning) A boolean comparison with the string literal \" Hello \" is always true. \n " , errout . str ( ) ) ;
check ( " int f() { \n "
" if ( \" Hello \" && 1) { } \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:2]: (warning) A boolean comparison with the string literal \" Hello \" is always true. \n " , errout . str ( ) ) ;
check ( " int f() { \n "
" if (1 && \" Hello \" ) { } \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:2]: (warning) A boolean comparison with the string literal \" Hello \" is always true. \n " , errout . str ( ) ) ;
check ( " int f() { \n "
" while ( \" Hello \" ) { } \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:2]: (warning) A boolean comparison with the string literal \" Hello \" is always true. \n " , errout . str ( ) ) ;
check ( " int f() { \n "
" assert (test || \" Hello \" ); \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:2]: (warning) A boolean comparison with the string literal \" Hello \" is always true. \n " , errout . str ( ) ) ;
check ( " int f() { \n "
" assert (test && \" Hello \" ); \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check ( " int f() { \n "
" assert ( \" Hello \" || test); \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:2]: (warning) A boolean comparison with the string literal \" Hello \" is always true. \n " , errout . str ( ) ) ;
check ( " int f() { \n "
" assert ( \" Hello \" && test); \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check ( " int f() { \n "
" return f2( \" Hello \" ); \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2011-02-08 19:49:29 +01:00
}
2011-02-11 23:38:23 +01:00
2011-10-13 20:53:06 +02:00
void incrementBoolean ( ) {
2011-02-11 23:38:23 +01:00
check ( " bool bValue = true; \n "
" bValue++; \n " ) ;
ASSERT_EQUALS ( " [test.cpp:2]: (style) The use of a variable of type bool with the ++ postfix operator is always true and deprecated by the C++ Standard. \n " , errout . str ( ) ) ;
2011-09-03 23:10:16 +02:00
check ( " _Bool bValue = true; \n "
" bValue++; \n " ) ;
ASSERT_EQUALS ( " [test.cpp:2]: (style) The use of a variable of type bool with the ++ postfix operator is always true and deprecated by the C++ Standard. \n " , errout . str ( ) ) ;
2011-02-11 23:38:23 +01:00
check ( " void f(bool test){ \n "
" test++; \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:2]: (style) The use of a variable of type bool with the ++ postfix operator is always true and deprecated by the C++ Standard. \n " , errout . str ( ) ) ;
check ( " void f(int test){ \n "
" test++; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2011-02-27 21:30:22 +01:00
2011-10-13 20:53:06 +02:00
void comparisonOfBoolWithInt1 ( ) {
2011-10-05 20:30:36 +02:00
check ( " void f(bool x) { \n "
" if (x < 10) { \n "
" printf( \" foo \" ); \n "
" } \n "
" } " ) ;
2012-04-02 15:45:51 +02:00
ASSERT_EQUALS ( " [test.cpp:2]: (warning) Comparison of a boolean with an integer \n " , errout . str ( ) ) ;
2011-10-05 20:30:36 +02:00
check ( " void f(bool x) { \n "
" if (10 >= x) { \n "
" printf( \" foo \" ); \n "
" } \n "
" } " ) ;
2012-04-02 15:45:51 +02:00
ASSERT_EQUALS ( " [test.cpp:2]: (warning) Comparison of a boolean with an integer \n " , errout . str ( ) ) ;
2011-10-05 20:30:36 +02:00
check ( " void f(bool x) { \n "
" if (x != 0) { \n "
" printf( \" foo \" ); \n "
" } \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2011-11-29 18:14:57 +01:00
check ( " void f(bool x) { \n " // #3356
" if (x == 1) { \n "
" } \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2011-10-05 20:30:36 +02:00
check ( " void f(bool x) { \n "
" if (x != 10) { \n "
" printf( \" foo \" ); \n "
" } \n "
" } " ) ;
2012-04-02 15:45:51 +02:00
ASSERT_EQUALS ( " [test.cpp:2]: (warning) Comparison of a boolean with an integer that is neither 1 nor 0 \n " , errout . str ( ) ) ;
2011-10-05 20:30:36 +02:00
check ( " void f(bool x) { \n "
" if (x == 10) { \n "
" printf( \" foo \" ); \n "
" } \n "
" } " ) ;
2012-04-02 15:45:51 +02:00
ASSERT_EQUALS ( " [test.cpp:2]: (warning) Comparison of a boolean with an integer that is neither 1 nor 0 \n " , errout . str ( ) ) ;
2011-10-05 20:30:36 +02:00
check ( " void f(bool x) { \n "
" if (x == 0) { \n "
" printf( \" foo \" ); \n "
" } \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2011-10-13 20:53:06 +02:00
void comparisonOfBoolWithInt2 ( ) {
2011-10-05 20:30:36 +02:00
check ( " void f(bool x, int y) { \n "
" if (x == y) { \n "
" printf( \" foo \" ); \n "
" } \n "
" } " ) ;
2012-04-02 15:45:51 +02:00
ASSERT_EQUALS ( " [test.cpp:2]: (warning) Comparison of a boolean with an integer \n " , errout . str ( ) ) ;
2011-10-05 20:30:36 +02:00
check ( " void f(int x, bool y) { \n "
" if (x == y) { \n "
" printf( \" foo \" ); \n "
" } \n "
" } " ) ;
2012-04-02 15:45:51 +02:00
ASSERT_EQUALS ( " [test.cpp:2]: (warning) Comparison of a boolean with an integer \n " , errout . str ( ) ) ;
2011-10-05 20:30:36 +02:00
check ( " void f(bool x, bool y) { \n "
" if (x == y) { \n "
" printf( \" foo \" ); \n "
" } \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check ( " void f(bool x, fooClass y) { \n "
" if (x == y) { \n "
" printf( \" foo \" ); \n "
" } \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2011-10-13 20:53:06 +02:00
void comparisonOfBoolWithInt3 ( ) {
2011-10-05 20:30:36 +02:00
check ( " void f(int y) { \n "
" if (y > false) { \n "
" printf( \" foo \" ); \n "
" } \n "
" } " ) ;
2012-04-02 15:45:51 +02:00
ASSERT_EQUALS ( " [test.cpp:2]: (warning) Comparison of a boolean with an integer \n " , errout . str ( ) ) ;
2011-10-05 20:30:36 +02:00
check ( " void f(int y) { \n "
" if (true == y) { \n "
" printf( \" foo \" ); \n "
" } \n "
" } " ) ;
2012-04-02 15:45:51 +02:00
ASSERT_EQUALS ( " [test.cpp:2]: (warning) Comparison of a boolean with an integer \n " , errout . str ( ) ) ;
2011-10-05 20:30:36 +02:00
check ( " void f(bool y) { \n "
" if (y == true) { \n "
" printf( \" foo \" ); \n "
" } \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2011-02-27 21:30:22 +01:00
2012-04-02 15:45:51 +02:00
check ( " void f(bool y) { \n "
" if (false < 5) { \n "
" printf( \" foo \" ); \n "
2011-02-27 21:30:22 +01:00
" } \n "
" } " ) ;
2012-04-02 15:45:51 +02:00
ASSERT_EQUALS ( " [test.cpp:2]: (warning) Comparison of a boolean with an integer \n " , errout . str ( ) ) ;
2011-02-27 21:30:22 +01:00
}
2011-04-09 21:14:01 +02:00
2012-04-02 15:45:51 +02:00
void comparisonOfBoolWithInt4 ( ) {
2011-11-06 08:21:34 +01:00
check ( " void f(int x) { \n "
" if (!x == 1) { } \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2012-04-02 15:45:51 +02:00
void comparisonOfBoolWithInt5 ( ) {
2011-12-20 06:38:05 +01:00
check ( " void SetVisible(int index, bool visible) { \n "
" bool (SciTEBase::*ischarforsel)(char ch); \n "
" if (visible != GetVisible(index)) { } \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2011-10-13 20:53:06 +02:00
void duplicateIf ( ) {
2011-04-09 22:34:16 +02:00
check ( " void f(int a, int &b) { \n "
" if (a) { b = 1; } \n "
" else if (a) { b = 2; } \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:3] -> [test.cpp:2]: (style) Found duplicate if expressions. \n " , errout . str ( ) ) ;
2011-04-09 21:14:01 +02:00
check ( " void f(int a, int &b) { \n "
" if (a == 1) { b = 1; } \n "
" else if (a == 2) { b = 2; } \n "
" else if (a == 1) { b = 3; } \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:4] -> [test.cpp:2]: (style) Found duplicate if expressions. \n " , errout . str ( ) ) ;
check ( " void f(int a, int &b) { \n "
" if (a == 1) { b = 1; } \n "
" else if (a == 2) { b = 2; } \n "
" else if (a == 2) { b = 3; } \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:4] -> [test.cpp:3]: (style) Found duplicate if expressions. \n " , errout . str ( ) ) ;
check ( " void f(int a, int &b) { \n "
" if (a == 1) { \n "
" b = 1; \n "
" if (b == 1) { } \n "
" else if (b == 1) { } \n "
" } else if (a == 2) { b = 2; } \n "
" else if (a == 2) { b = 3; } \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:7] -> [test.cpp:6]: (style) Found duplicate if expressions. \n "
" [test.cpp:5] -> [test.cpp:4]: (style) Found duplicate if expressions. \n " , errout . str ( ) ) ;
check ( " void f(int a, int &b) { \n "
" if (a++) { b = 1; } \n "
" else if (a++) { b = 2; } \n "
" else if (a++) { b = 3; } \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check ( " void f(int a, int &b) { \n "
" if (!strtok(NULL, " " )) { b = 1; } \n "
" else if (!strtok(NULL, " " )) { b = 2; } \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check ( " void f(int a, int &b) { \n "
" if ((x = x / 2) < 100) { b = 1; } \n "
" else if ((x = x / 2) < 100) { b = 2; } \n "
" } " ) ;
2012-02-17 15:47:08 +01:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check ( " void f(int i) { \n "
" if(i == 0x02e2000000 || i == 0xa0c6000000) \n "
" foo(i); \n "
" } " ) ;
2011-04-09 21:14:01 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2012-05-29 09:22:42 +02:00
check ( " void f(const std::string &token) \n "
" { \n "
" if( token == \" C \" ) \n "
" { \n "
" std::cout << \" C \" ; \n "
" } \n "
" else if ( token == \" A \" ) \n "
" { \n "
" std::cout << \" A \" ; \n "
" } \n "
" else if ( token == \" A \" ) \n "
" { \n "
" std::cout << \" A \" ; \n "
" } \n "
" } \n " ) ;
ASSERT_EQUALS ( " [test.cpp:11] -> [test.cpp:7]: (style) Found duplicate if expressions. \n " , errout . str ( ) ) ;
2011-04-09 21:14:01 +02:00
}
2011-04-09 23:05:27 +02:00
2011-10-13 20:53:06 +02:00
void duplicateBranch ( ) {
2011-04-09 23:05:27 +02:00
check ( " void f(int a, int &b) { \n "
" if (a) \n "
" b = 1; \n "
" else \n "
" b = 1; \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:4] -> [test.cpp:2]: (style) Found duplicate branches for if and else. \n " , errout . str ( ) ) ;
check ( " void f(int a, int &b) { \n "
" if (a) { \n "
" if (a == 1) \n "
" b = 2; \n "
" else \n "
" b = 2; \n "
" } else \n "
" b = 1; \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:5] -> [test.cpp:3]: (style) Found duplicate branches for if and else. \n " , errout . str ( ) ) ;
2011-04-10 15:57:09 +02:00
2011-12-13 21:42:38 +01:00
check ( " void f(int a, int &b) { \n "
" if (a == 1) \n "
" b = 1; \n "
" else if (a) \n "
" b = 2; \n "
" else \n "
" b = 2; \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:6] -> [test.cpp:4]: (style) Found duplicate branches for if and else. \n " , errout . str ( ) ) ;
2011-04-10 15:57:09 +02:00
check ( " int f(int signed, unsigned char value) { \n "
" int ret; \n "
" if (signed) \n "
" ret = (signed char)value; \n "
" else \n "
" ret = (unsigned char)value; \n "
" return ret; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2011-12-13 21:42:38 +01:00
check ( " void f() { \n "
" if (b) \n "
" __asm__( \" mov ax, bx \" ); \n "
" else \n "
" __asm__( \" mov bx, bx \" ); \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ; // #3407
check ( " void f() { \n "
" if (b) \n "
" __asm__( \" mov ax, bx \" ); \n "
" else \n "
" __asm__( \" mov ax, bx \" ); \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:4] -> [test.cpp:2]: (style) Found duplicate branches for if and else. \n " , errout . str ( ) ) ;
2011-04-09 23:05:27 +02:00
}
2011-04-10 16:25:02 +02:00
2012-05-30 01:30:37 +02:00
void duplicateBranch1 ( ) {
// tests inspired by http://www.viva64.com/en/b/0149/ ( Comparision between PVS-Studio and cppcheck )
// Errors detected in Quake 3: Arena by PVS-Studio: Fragement 2
check ( " void f() \n "
" { \n "
" if (front < 0) \n "
" frac = (front)/(front-back); \n "
" else \n "
" frac = (front)/(front-back); \n "
" } \n " ) ;
ASSERT_EQUALS ( " [test.cpp:5] -> [test.cpp:3]: (style) Found duplicate branches for if and else. \n " , errout . str ( ) ) ;
check ( " void f() \n "
" { \n "
" if (front < 0) \n "
" { frac = (front)/(front-back);} \n "
" else \n "
" frac = (front)/(front-back); \n "
" } \n " ) ;
ASSERT_EQUALS ( " [test.cpp:5] -> [test.cpp:3]: (style) Found duplicate branches for if and else. \n " , errout . str ( ) ) ;
check ( " void f() \n "
" { \n "
" if (front < 0) \n "
" { frac = (front)/(front-back);} \n "
" else \n "
" frac = (front)/((front-back)); \n "
" } \n " ) ;
ASSERT_EQUALS ( " [test.cpp:5] -> [test.cpp:3]: (style) Found duplicate branches for if and else. \n " , errout . str ( ) ) ;
}
2011-10-13 20:53:06 +02:00
void duplicateExpression1 ( ) {
2011-10-08 12:45:56 +02:00
check ( " void foo() { \n "
2011-04-10 16:25:02 +02:00
" if (a == a) { } \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:2] -> [test.cpp:2]: (style) Same expression on both sides of '=='. \n " , errout . str ( ) ) ;
check ( " void fun() { \n "
" return (a && a || \n "
" b == b && \n "
" c - c && \n "
" d > d && \n "
" e < e && \n "
" f); \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:2] -> [test.cpp:2]: (style) Same expression on both sides of '&&'. \n "
" [test.cpp:3] -> [test.cpp:3]: (style) Same expression on both sides of '=='. \n "
" [test.cpp:4] -> [test.cpp:4]: (style) Same expression on both sides of '-'. \n "
" [test.cpp:5] -> [test.cpp:5]: (style) Same expression on both sides of '>'. \n "
" [test.cpp:6] -> [test.cpp:6]: (style) Same expression on both sides of '<'. \n " , errout . str ( ) ) ;
2011-11-05 15:40:43 +01:00
check ( " void foo() { \n "
" return a && a; \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:2] -> [test.cpp:2]: (style) Same expression on both sides of '&&'. \n " , errout . str ( ) ) ;
2011-11-05 22:17:48 +01:00
check ( " void foo() { \n "
" a = b && b; \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:2] -> [test.cpp:2]: (style) Same expression on both sides of '&&'. \n " , errout . str ( ) ) ;
check ( " void foo() { \n "
2011-11-08 21:26:33 +01:00
" f(a,b == b); \n "
2011-11-05 22:17:48 +01:00
" } " ) ;
2011-11-08 21:26:33 +01:00
ASSERT_EQUALS ( " [test.cpp:2] -> [test.cpp:2]: (style) Same expression on both sides of '=='. \n " , errout . str ( ) ) ;
check ( " void foo() { \n "
" f(b == b, a); \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:2] -> [test.cpp:2]: (style) Same expression on both sides of '=='. \n " , errout . str ( ) ) ;
2011-11-08 21:22:31 +01:00
check ( " void foo() { \n "
" if (x!=2 || x!=2) {} \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:2] -> [test.cpp:2]: (style) Same expression on both sides of '||'. \n " , errout . str ( ) ) ;
check ( " void foo() { \n "
" if (x!=2 || x!=3 || x!=2) {} \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:2] -> [test.cpp:2]: (style) Same expression on both sides of '||'. \n " , errout . str ( ) ) ;
check ( " void foo() { \n "
" if (a && b || a && b) {} \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:2] -> [test.cpp:2]: (style) Same expression on both sides of '||'. \n " , errout . str ( ) ) ;
check ( " void foo() { \n "
" if (a && b || b && c) {} \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2011-11-08 21:24:44 +01:00
check ( " void foo() { \n "
" if (a && b | b && c) {} \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check ( " void foo() { \n "
" if ((a + b) | (a + b)) {} \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:2] -> [test.cpp:2]: (style) Same expression on both sides of '|'. \n " , errout . str ( ) ) ;
2011-11-12 10:23:34 +01:00
2011-11-08 21:24:44 +01:00
check ( " void foo() { \n "
" if ((a | b) & (a | b)) {} \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:2] -> [test.cpp:2]: (style) Same expression on both sides of '&'. \n " , errout . str ( ) ) ;
2011-11-12 10:23:34 +01:00
2011-12-01 17:07:55 +01:00
check ( " void foo() { \n "
" if (a1[a2[c & 0xff] & 0xff]) {} \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2011-11-12 10:23:34 +01:00
check ( " void d(const char f, int o, int v) \n "
" { \n "
" if (((f=='R') && (o == 1) && ((v < 2) || (v > 99))) || \n "
" ((f=='R') && (o == 2) && ((v < 2) || (v > 99))) || \n "
" ((f=='T') && (o == 2) && ((v < 200) || (v > 9999)))) {} \n "
" } \n " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2012-05-14 09:57:30 +02:00
}
void duplicateIf1 ( ) { // ticket 3689 ( avoid false positive )
check ( " #define INT32_MAX 0x7fffffffLL \n "
" #define INT48_MAX 0x7fffffffffffLL \n "
" #define INT64_MAX 0x7fffffffffffffffLL \n "
" int fitInt(long long int nValue){ \n "
" if( nValue < INT32_MAX ) \n "
" { \n "
" return 32; \n "
" } \n "
" if( nValue < INT48_MAX ) \n "
" { \n "
" return 48; \n "
" } \n "
" else if( nValue < INT64_MAX ) \n "
" { \n "
" return 64; \n "
" } else \n "
" { \n "
" return -1; \n "
" } \n "
" } \n " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2011-04-10 16:25:02 +02:00
}
2011-04-19 01:20:27 +02:00
2011-10-13 20:53:06 +02:00
void duplicateExpression2 ( ) { // ticket #2730
2011-04-19 01:20:27 +02:00
check ( " int main() \n "
" { \n "
" long double ldbl; \n "
" double dbl, in; \n "
" float flt; \n "
" int have_nan = 0; \n "
" ldbl = sqrtl(-1.0); \n "
" dbl = sqrt(-1.0); \n "
" flt = sqrtf(-1.0); \n "
" if (ldbl != ldbl) have_nan = 1; \n "
" if (!(dbl == dbl)) have_nan = 1; \n "
" if (flt != flt) have_nan = 1; \n "
" return have_nan; \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:7]: (error) Passing value -1.0 to sqrtl() leads to undefined result \n "
" [test.cpp:8]: (error) Passing value -1.0 to sqrt() leads to undefined result \n "
" [test.cpp:9]: (error) Passing value -1.0 to sqrtf() leads to undefined result \n " , errout . str ( ) ) ;
}
2011-04-26 07:45:27 +02:00
2011-11-10 21:49:14 +01:00
void duplicateExpression3 ( ) {
check ( " void foo() { \n "
" if (x() || x()) {} \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check ( " struct A { \n "
" void foo() const; \n "
" bool bar() const; \n "
" }; \n "
" void A::foo() const { \n "
" if (bar() && bar()) {} \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:6] -> [test.cpp:6]: (style) Same expression on both sides of '&&'. \n " , errout . str ( ) ) ;
check ( " struct A { \n "
" void foo(); \n "
" bool bar(); \n "
" bool bar() const; \n "
" }; \n "
" void A::foo() { \n "
" if (bar() && bar()) {} \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check ( " class B { \n "
" void bar(int i); \n "
" }; \n "
" class A { \n "
" void bar(int i) const; \n "
" }; \n "
" void foo() { \n "
" B b; \n "
" A a; \n "
" if (b.bar(1) && b.bar(1)) {} \n "
" if (a.bar(1) && a.bar(1)) {} \n "
" } \n " ) ;
ASSERT_EQUALS ( " [test.cpp:11] -> [test.cpp:11]: (style) Same expression on both sides of '&&'. \n " , errout . str ( ) ) ;
check ( " class D { void strcmp(); }; \n "
" void foo() { \n "
" D d; \n "
" if (d.strcmp() && d.strcmp()) {} \n "
" } \n " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check ( " void foo() { \n "
" if ((strcmp(a, b) == 0) || (strcmp(a, b) == 0)) {} \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:2] -> [test.cpp:2]: (style) Same expression on both sides of '||'. \n " , errout . str ( ) ) ;
check ( " void foo() { \n "
" if (str == \" ( \" || str == \" ( \" ) {} \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:2] -> [test.cpp:2]: (style) Same expression on both sides of '||'. \n " , errout . str ( ) ) ;
2011-12-01 19:49:04 +01:00
check ( " void foo() { \n "
" if (bar(a) && !strcmp(a, b) && bar(a) && !strcmp(a, b)) {} \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2011-11-10 21:49:14 +01:00
}
2011-12-01 17:46:33 +01:00
void duplicateExpression4 ( ) {
check ( " void foo() { \n "
" if (*a++ != b || *a++ != b) {} \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check ( " void foo() { \n "
" if (*a-- != b || *a-- != b) {} \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2011-11-10 21:49:14 +01:00
2012-05-17 07:26:57 +02:00
void duplicateExpression5 ( ) { // #3749 - macros with same values
Preprocessor : : macroChar = ' $ ' ;
check ( " void f() { \n "
" if ($a == $a) { } \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2011-10-13 20:53:06 +02:00
void alwaysTrueFalseStringCompare ( ) {
2011-04-26 07:45:27 +02:00
check_preprocess_suppress (
" #define MACRO \" 00FF00 \" \n "
" int main() \n "
" { \n "
" if (strcmp(MACRO, \" 00FF00 \" ) == 0) "
" { "
" std::cout << \" Equal \n \" "
" } "
" } " ) ;
2012-04-26 23:04:55 +02:00
ASSERT_EQUALS ( " [test.cpp:4]: (warning) Unnecessary comparison of static strings. \n " , errout . str ( ) ) ;
2011-04-26 07:45:27 +02:00
check_preprocess_suppress (
" int main() \n "
" { \n "
" if (stricmp( \" hotdog \" , \" HOTdog \" ) == 0) "
" { "
" std::cout << \" Equal \n \" "
" } "
" } " ) ;
2012-04-26 23:04:55 +02:00
ASSERT_EQUALS ( " [test.cpp:3]: (warning) Unnecessary comparison of static strings. \n " , errout . str ( ) ) ;
2011-04-26 07:45:27 +02:00
check_preprocess_suppress (
" #define MACRO \" Hotdog \" \n "
" int main() \n "
" { \n "
" if (QString::compare( \" Hamburger \" , MACRO) == 0) "
" { "
" std::cout << \" Equal \n \" "
" } "
" } " ) ;
2012-04-26 23:04:55 +02:00
ASSERT_EQUALS ( " [test.cpp:4]: (warning) Unnecessary comparison of static strings. \n " , errout . str ( ) ) ;
2011-04-26 07:45:27 +02:00
check_preprocess_suppress (
" int main() \n "
" { \n "
" if (QString::compare(argv[2], \" hotdog \" ) == 0) "
" { "
" std::cout << \" Equal \n \" "
" } "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2011-10-28 22:03:18 +02:00
check_preprocess_suppress (
" int main() \n "
" { \n "
" if (strncmp( \" hotdog \" , \" hotdog \" , 6) == 0) "
" { "
" std::cout << \" Equal \n \" "
" } "
" } " ) ;
2012-04-26 23:04:55 +02:00
ASSERT_EQUALS ( " [test.cpp:3]: (warning) Unnecessary comparison of static strings. \n " , errout . str ( ) ) ;
2011-10-28 22:05:11 +02:00
2011-10-29 12:21:22 +02:00
check (
2011-10-28 22:05:11 +02:00
" int foo(const char *buf) \n "
" { \n "
" if (strcmp(buf, buf) == 0) "
" { "
" std::cout << \" Equal \n \" "
" } "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:3]: (warning) Comparison of identical string variables. \n " , errout . str ( ) ) ;
2012-03-11 11:01:39 +01:00
check_preprocess_suppress (
" int main() { \n "
" if ( \" str \" == \" str \" ) { \n "
" std::cout << \" Equal \n \" \n "
" } \n "
" } " ) ;
2012-04-26 23:04:55 +02:00
ASSERT_EQUALS ( " [test.cpp:2]: (warning) Unnecessary comparison of static strings. \n " , errout . str ( ) ) ;
2012-03-11 11:01:39 +01:00
check_preprocess_suppress (
" int main() { \n "
" if ( \" str \" != \" str \" ) { \n "
" std::cout << \" Equal \n \" \n "
" } \n "
" } " ) ;
2012-04-26 23:04:55 +02:00
ASSERT_EQUALS ( " [test.cpp:2]: (warning) Unnecessary comparison of static strings. \n " , errout . str ( ) ) ;
2012-03-11 11:01:39 +01:00
check_preprocess_suppress (
" int main() { \n "
" if (a+ \" str \" != \" str \" +b) { \n "
" std::cout << \" Equal \n \" \n "
" } \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2011-04-26 07:45:27 +02:00
}
2011-08-07 01:23:09 +02:00
2012-03-23 21:47:13 +01:00
void checkPointerSizeof ( ) {
2011-10-28 22:06:55 +02:00
check (
2012-03-23 21:47:13 +01:00
" char *x = malloc(10); \n "
" free(x); " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2011-10-28 22:06:55 +02:00
2012-03-20 18:50:05 +01:00
check (
" int *x = malloc(sizeof(*x)); \n "
" free(x); " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check (
" int *x = malloc(sizeof(int)); \n "
" free(x); " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check (
" int *x = malloc(sizeof(x)); \n "
" free(x); " ) ;
2012-05-06 19:37:41 +02:00
ASSERT_EQUALS ( " [test.cpp:1]: (warning, inconclusive) Using size of pointer x instead of size of its data. \n " , errout . str ( ) ) ;
2012-03-23 21:47:13 +01:00
check (
" int *x = malloc(100 * sizeof(x)); \n "
" free(x); " ) ;
2012-05-06 19:37:41 +02:00
ASSERT_EQUALS ( " [test.cpp:1]: (warning, inconclusive) Using size of pointer x instead of size of its data. \n " , errout . str ( ) ) ;
2012-03-23 21:47:13 +01:00
check (
" int *x = malloc(sizeof(x) * 100); \n "
" free(x); " ) ;
2012-05-06 19:37:41 +02:00
ASSERT_EQUALS ( " [test.cpp:1]: (warning, inconclusive) Using size of pointer x instead of size of its data. \n " , errout . str ( ) ) ;
2012-03-20 18:50:05 +01:00
check (
" int *x = malloc(sizeof *x); \n "
" free(x); " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check (
" int *x = malloc(sizeof x); \n "
" free(x); " ) ;
2012-05-06 19:37:41 +02:00
ASSERT_EQUALS ( " [test.cpp:1]: (warning, inconclusive) Using size of pointer x instead of size of its data. \n " , errout . str ( ) ) ;
2012-03-23 21:47:13 +01:00
check (
" int *x = malloc(100 * sizeof x); \n "
" free(x); " ) ;
2012-05-06 19:37:41 +02:00
ASSERT_EQUALS ( " [test.cpp:1]: (warning, inconclusive) Using size of pointer x instead of size of its data. \n " , errout . str ( ) ) ;
2012-03-23 21:47:13 +01:00
check (
" int *x = calloc(1, sizeof(*x)); \n "
" free(x); " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check (
" int *x = calloc(1, sizeof *x); \n "
" free(x); " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check (
" int *x = calloc(1, sizeof(x)); \n "
" free(x); " ) ;
2012-05-06 19:37:41 +02:00
ASSERT_EQUALS ( " [test.cpp:1]: (warning, inconclusive) Using size of pointer x instead of size of its data. \n " , errout . str ( ) ) ;
2012-03-23 21:47:13 +01:00
check (
" int *x = calloc(1, sizeof x); \n "
" free(x); " ) ;
2012-05-06 19:37:41 +02:00
ASSERT_EQUALS ( " [test.cpp:1]: (warning, inconclusive) Using size of pointer x instead of size of its data. \n " , errout . str ( ) ) ;
2012-03-23 21:47:13 +01:00
check (
" int *x = calloc(1, sizeof(int)); \n "
" free(x); " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check (
" char x[10]; \n "
" memset(x, 0, sizeof(x)); " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2012-04-18 16:35:04 +02:00
check (
" char* x[10]; \n "
" memset(x, 0, sizeof(x)); " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2012-03-23 21:47:13 +01:00
check (
" char x[10]; \n "
" memset(x, 0, sizeof x); " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check (
" int *x = malloc(sizeof(int)); \n "
" memset(x, 0, sizeof(int)); \n "
" free(x); " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check (
" int *x = malloc(sizeof(int)); \n "
" memset(x, 0, sizeof(*x)); \n "
" free(x); " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check (
" int *x = malloc(sizeof(int)); \n "
" memset(x, 0, sizeof *x); \n "
" free(x); " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check (
" int *x = malloc(sizeof(int)); \n "
" memset(x, 0, sizeof x); \n "
" free(x); " ) ;
2012-05-06 19:37:41 +02:00
ASSERT_EQUALS ( " [test.cpp:2]: (warning, inconclusive) Using size of pointer x instead of size of its data. \n " , errout . str ( ) ) ;
2012-03-23 21:47:13 +01:00
check (
" int *x = malloc(sizeof(int)); \n "
" memset(x, 0, sizeof(x)); \n "
" free(x); " ) ;
2012-05-06 19:37:41 +02:00
ASSERT_EQUALS ( " [test.cpp:2]: (warning, inconclusive) Using size of pointer x instead of size of its data. \n " , errout . str ( ) ) ;
2012-03-23 21:47:13 +01:00
check (
" int *x = malloc(sizeof(int) * 10); \n "
" memset(x, 0, sizeof(x) * 10); \n "
" free(x); " ) ;
2012-05-06 19:37:41 +02:00
ASSERT_EQUALS ( " [test.cpp:2]: (warning, inconclusive) Using size of pointer x instead of size of its data. \n " , errout . str ( ) ) ;
2012-03-23 21:47:13 +01:00
check (
" int *x = malloc(sizeof(int) * 10); \n "
" memset(x, 0, sizeof x * 10); \n "
" free(x); " ) ;
2012-05-06 19:37:41 +02:00
ASSERT_EQUALS ( " [test.cpp:2]: (warning, inconclusive) Using size of pointer x instead of size of its data. \n " , errout . str ( ) ) ;
2012-03-23 21:47:13 +01:00
check (
" int *x = malloc(sizeof(int) * 10); \n "
" memset(x, 0, sizeof(*x) * 10); \n "
" free(x); " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check (
" int *x = malloc(sizeof(int) * 10); \n "
" memset(x, 0, sizeof *x * 10); \n "
" free(x); " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check (
" int *x = malloc(sizeof(int) * 10); \n "
" memset(x, 0, sizeof(int) * 10); \n "
" free(x); " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check (
" int fun(const char *buf1) \n "
" { \n "
" const char *buf1_ex = \" foobarbaz \" ; \n "
" return strncmp(buf1, buf1_ex, sizeof(buf1_ex)) == 0; \n "
" } " ) ;
2012-05-06 19:37:41 +02:00
ASSERT_EQUALS ( " [test.cpp:4]: (warning, inconclusive) Using size of pointer buf1_ex instead of size of its data. \n " , errout . str ( ) ) ;
2012-03-23 21:47:13 +01:00
check (
" int fun(const char *buf1) { \n "
" return strncmp(buf1, foo(buf2), sizeof(buf1)) == 0; \n "
" } " ) ;
2012-05-06 19:37:41 +02:00
ASSERT_EQUALS ( " [test.cpp:2]: (warning, inconclusive) Using size of pointer buf1 instead of size of its data. \n " , errout . str ( ) ) ;
2012-03-20 18:50:05 +01:00
}
2011-11-06 18:24:37 +01:00
void check_signOfUnsignedVariable ( const char code [ ] , bool inconclusive = false ) {
2011-08-07 01:23:09 +02:00
// Clear the error buffer..
errout . str ( " " ) ;
Settings settings ;
2011-08-07 09:28:08 +02:00
settings . addEnabled ( " style " ) ;
2011-11-06 18:24:37 +01:00
settings . inconclusive = inconclusive ;
2011-08-07 01:23:09 +02:00
// Tokenize..
Tokenizer tokenizer ( & settings , this ) ;
std : : istringstream istr ( code ) ;
tokenizer . tokenize ( istr , " test.cpp " ) ;
// Check for redundant code..
CheckOther checkOther ( & tokenizer , & settings , this ) ;
checkOther . checkSignOfUnsignedVariable ( ) ;
}
2011-10-13 20:53:06 +02:00
void checkSignOfUnsignedVariable ( ) {
2011-10-09 20:35:46 +02:00
check_signOfUnsignedVariable (
" void foo() { \n "
" for(unsigned char i = 10; i >= 0; i--) "
" printf( \" %u \" , i); \n "
" } " ) ;
2012-01-14 11:50:09 +01:00
ASSERT_EQUALS ( " [test.cpp:2]: (style) An unsigned variable 'i' can't be negative so it is unnecessary to test it. \n " , errout . str ( ) ) ;
2011-10-09 20:35:46 +02:00
check_signOfUnsignedVariable (
" void foo(bool b) { \n "
" for(unsigned int i = 10; b || i >= 0; i--) "
" printf( \" %u \" , i); \n "
" } " ) ;
2012-01-14 11:50:09 +01:00
ASSERT_EQUALS ( " [test.cpp:2]: (style) An unsigned variable 'i' can't be negative so it is unnecessary to test it. \n " , errout . str ( ) ) ;
2011-10-09 20:35:46 +02:00
2011-08-07 01:23:09 +02:00
check_signOfUnsignedVariable (
" bool foo(unsigned int x) { \n "
" if (x < 0) "
" return true; \n "
" return false; \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:2]: (style) Checking if unsigned variable 'x' is less than zero. \n " , errout . str ( ) ) ;
check_signOfUnsignedVariable (
" bool foo(int x) { \n "
" if (x < 0) "
" return true; \n "
" return false; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check_signOfUnsignedVariable (
" bool foo(unsigned int x) { \n "
" if (0 > x) "
" return true; \n "
" return false; \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:2]: (style) Checking if unsigned variable 'x' is less than zero. \n " , errout . str ( ) ) ;
check_signOfUnsignedVariable (
" bool foo(int x) { \n "
" if (0 > x) "
" return true; \n "
" return false; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check_signOfUnsignedVariable (
" bool foo(unsigned int x) { \n "
" if (x >= 0) "
" return true; \n "
" return false; \n "
" } " ) ;
2012-01-14 11:50:09 +01:00
ASSERT_EQUALS ( " [test.cpp:2]: (style) An unsigned variable 'x' can't be negative so it is unnecessary to test it. \n " , errout . str ( ) ) ;
2011-08-07 01:23:09 +02:00
check_signOfUnsignedVariable (
" bool foo(int x) { \n "
" if (x >= 0) "
" return true; \n "
" return false; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2011-09-27 03:24:34 +02:00
check_signOfUnsignedVariable (
" bool foo(unsigned int x, bool y) { \n "
" if (x < 0 && y) "
" return true; \n "
" return false; \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:2]: (style) Checking if unsigned variable 'x' is less than zero. \n " , errout . str ( ) ) ;
check_signOfUnsignedVariable (
" bool foo(int x, bool y) { \n "
" if (x < 0 && y) "
" return true; \n "
" return false; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check_signOfUnsignedVariable (
" bool foo(unsigned int x, bool y) { \n "
" if (0 > x && y) "
" return true; \n "
" return false; \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:2]: (style) Checking if unsigned variable 'x' is less than zero. \n " , errout . str ( ) ) ;
check_signOfUnsignedVariable (
" bool foo(int x, bool y) { \n "
" if (0 > x && y) "
" return true; \n "
" return false; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check_signOfUnsignedVariable (
" bool foo(unsigned int x, bool y) { \n "
" if (x >= 0 && y) "
" return true; \n "
" return false; \n "
" } " ) ;
2012-01-14 11:50:09 +01:00
ASSERT_EQUALS ( " [test.cpp:2]: (style) An unsigned variable 'x' can't be negative so it is unnecessary to test it. \n " , errout . str ( ) ) ;
2011-09-27 03:24:34 +02:00
check_signOfUnsignedVariable (
" bool foo(int x, bool y) { \n "
" if (x >= 0 && y) "
" return true; \n "
" return false; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check_signOfUnsignedVariable (
" bool foo(unsigned int x, bool y) { \n "
" if (y && x < 0) "
" return true; \n "
" return false; \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:2]: (style) Checking if unsigned variable 'x' is less than zero. \n " , errout . str ( ) ) ;
check_signOfUnsignedVariable (
" bool foo(int x, bool y) { \n "
" if (y && x < 0) "
" return true; \n "
" return false; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check_signOfUnsignedVariable (
" bool foo(unsigned int x, bool y) { \n "
" if (y && 0 > x) "
" return true; \n "
" return false; \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:2]: (style) Checking if unsigned variable 'x' is less than zero. \n " , errout . str ( ) ) ;
check_signOfUnsignedVariable (
" bool foo(int x, bool y) { \n "
" if (y && 0 > x) "
" return true; \n "
" return false; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check_signOfUnsignedVariable (
" bool foo(unsigned int x, bool y) { \n "
" if (y && x >= 0) "
" return true; \n "
" return false; \n "
" } " ) ;
2012-01-14 11:50:09 +01:00
ASSERT_EQUALS ( " [test.cpp:2]: (style) An unsigned variable 'x' can't be negative so it is unnecessary to test it. \n " , errout . str ( ) ) ;
2011-09-27 03:24:34 +02:00
check_signOfUnsignedVariable (
" bool foo(int x, bool y) { \n "
" if (y && x >= 0) "
" return true; \n "
" return false; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check_signOfUnsignedVariable (
" bool foo(unsigned int x, bool y) { \n "
" if (x < 0 || y) "
" return true; \n "
" return false; \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:2]: (style) Checking if unsigned variable 'x' is less than zero. \n " , errout . str ( ) ) ;
check_signOfUnsignedVariable (
" bool foo(int x, bool y) { \n "
" if (x < 0 || y) "
" return true; \n "
" return false; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check_signOfUnsignedVariable (
" bool foo(unsigned int x, bool y) { \n "
" if (0 > x || y) "
" return true; \n "
" return false; \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:2]: (style) Checking if unsigned variable 'x' is less than zero. \n " , errout . str ( ) ) ;
check_signOfUnsignedVariable (
" bool foo(int x, bool y) { \n "
" if (0 > x || y) "
" return true; \n "
" return false; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check_signOfUnsignedVariable (
" bool foo(unsigned int x, bool y) { \n "
" if (x >= 0 || y) "
" return true; \n "
" return false; \n "
" } " ) ;
2012-01-14 11:50:09 +01:00
ASSERT_EQUALS ( " [test.cpp:2]: (style) An unsigned variable 'x' can't be negative so it is unnecessary to test it. \n " , errout . str ( ) ) ;
2011-09-27 03:24:34 +02:00
check_signOfUnsignedVariable (
" bool foo(int x, bool y) { \n "
" if (x >= 0 || y) "
" return true; \n "
" return false; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2011-11-06 18:24:37 +01:00
// #3233 - FP when template is used (template parameter is numeric constant)
{
const char code [ ] =
" template<int n> void foo(unsigned int x) { \n "
" if (x <= n); \n "
" } \n "
" foo<0>(); " ;
check_signOfUnsignedVariable ( code , false ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check_signOfUnsignedVariable ( code , true ) ;
2012-05-06 19:37:41 +02:00
ASSERT_EQUALS ( " [test.cpp:2]: (style, inconclusive) Checking if unsigned variable 'x' is less than zero. This might be a false warning. \n " , errout . str ( ) ) ;
2011-11-06 18:24:37 +01:00
}
2011-08-07 01:23:09 +02:00
}
2011-10-11 08:41:39 +02:00
2011-10-13 20:53:06 +02:00
void checkForSuspiciousSemicolon1 ( ) {
2011-10-11 08:41:39 +02:00
check (
" void foo() { \n "
" for(int i = 0; i < 10; ++i); \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
// Empty block
check (
" void foo() { \n "
" for(int i = 0; i < 10; ++i); { \n "
" } \n "
" } " ) ;
2012-05-06 19:37:41 +02:00
ASSERT_EQUALS ( " [test.cpp:2]: (warning, inconclusive) Suspicious use of ; at the end of 'if/for/while' statement. \n " , errout . str ( ) ) ;
2011-10-11 08:41:39 +02:00
// Block with some tokens to make sure the tokenizer output
// stays the same for "for(); {}"
check (
" void foo() { \n "
" for(int i = 0; i < 10; ++i); { \n "
" int j = 123; \n "
" } \n "
" } " ) ;
2012-05-06 19:37:41 +02:00
ASSERT_EQUALS ( " [test.cpp:2]: (warning, inconclusive) Suspicious use of ; at the end of 'if/for/while' statement. \n " , errout . str ( ) ) ;
2011-10-11 08:41:39 +02:00
check (
" void foo() { \n "
" while (!quit); { \n "
" do_something(); \n "
" } \n "
" } " ) ;
2012-05-06 19:37:41 +02:00
ASSERT_EQUALS ( " [test.cpp:2]: (warning, inconclusive) Suspicious use of ; at the end of 'if/for/while' statement. \n " , errout . str ( ) ) ;
2011-10-11 08:41:39 +02:00
}
2011-10-13 20:53:06 +02:00
void checkForSuspiciousSemicolon2 ( ) {
2011-10-11 08:41:39 +02:00
check (
" void foo() { \n "
" if (i == 1); { \n "
" do_something(); \n "
" } \n "
" } " ) ;
2012-05-06 19:37:41 +02:00
ASSERT_EQUALS ( " [test.cpp:2]: (warning, inconclusive) Suspicious use of ; at the end of 'if/for/while' statement. \n " , errout . str ( ) ) ;
2011-10-11 08:41:39 +02:00
// Seen this in the wild
check (
" void foo() { \n "
" if (Match()); \n "
" do_something(); \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check (
" void foo() { \n "
" if (Match()); \n "
" else \n "
" do_something(); \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check (
" void foo() { \n "
" if (i == 1) \n "
" ; \n "
" { \n "
" do_something(); \n "
" } \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check (
" void foo() { \n "
" if (i == 1); \n "
" \n "
" { \n "
" do_something(); \n "
" } \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2011-10-22 17:12:52 +02:00
2012-01-15 01:19:34 +01:00
void checkDoubleFree ( ) {
check (
" void foo(char *p) { \n "
" free(p); \n "
" free(p); \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:3]: (error) Memory pointed to by 'p' is freed twice. \n " , errout . str ( ) ) ;
check (
" void foo(char *p, char *r) { \n "
" free(p); \n "
" free(r); \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check (
" void foo() { \n "
" free(p); \n "
" free(r); \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check (
" void foo(char *p) { \n "
" if (x < 3) free(p); \n "
" else if (x > 9) free(p); \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check (
" void foo(char *p) { \n "
" free(p); \n "
" getNext(&p); \n "
" free(p); \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check (
" void foo(char *p) { \n "
" free(p); \n "
" bar(); \n "
" free(p); \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:4]: (error) Memory pointed to by 'p' is freed twice. \n " , errout . str ( ) ) ;
check (
" void foo(char *p) { \n "
" free(p); \n "
" printf( \" Freed memory at location %x \" , (unsigned int) p); \n "
" free(p); \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:4]: (error) Memory pointed to by 'p' is freed twice. \n " , errout . str ( ) ) ;
check (
" void foo(DIR *p) { \n "
" closedir(p); \n "
" closedir(p); \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:3]: (error) Directory handle 'p' closed twice. \n " , errout . str ( ) ) ;
check (
" void foo(DIR *p, DIR *r) { \n "
" closedir(p); \n "
" closedir(r); \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check (
" void foo(DIR *p) { \n "
" if (x < 3) closedir(p); \n "
" else if (x > 9) closedir(p); \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check (
" void foo(DIR *p) { \n "
" closedir(p); \n "
" gethandle(&p); \n "
" closedir(p); \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check (
" void foo(DIR *p) { \n "
" closedir(p); \n "
" gethandle(); \n "
" closedir(p); \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:4]: (error) Directory handle 'p' closed twice. \n " , errout . str ( ) ) ;
check (
" void foo(Data* p) { \n "
" free(p->a); \n "
" free(p->b); \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check (
" void f() { \n "
" char *p = malloc(100); \n "
" if (x) { \n "
" free(p); \n "
" bailout(); \n "
" } \n "
" free(p); \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check (
" void f() { \n "
" char *p = malloc(100); \n "
" if (x) { \n "
" free(p); \n "
" x = 0; \n "
" } \n "
" free(p); \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:7]: (error) Memory pointed to by 'p' is freed twice. \n " , errout . str ( ) ) ;
check (
" void f() { \n "
" char *p = do_something(); \n "
" free(p); \n "
" p = do_something(); \n "
" free(p); \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check (
" void foo(char *p) { \n "
" g_free(p); \n "
" g_free(p); \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:3]: (error) Memory pointed to by 'p' is freed twice. \n " , errout . str ( ) ) ;
check (
" void foo(char *p, char *r) { \n "
" g_free(p); \n "
" g_free(r); \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check (
" void foo(char *p) { \n "
" g_free(p); \n "
" getNext(&p); \n "
" g_free(p); \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check (
" void foo(char *p) { \n "
" g_free(p); \n "
" bar(); \n "
" g_free(p); \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:4]: (error) Memory pointed to by 'p' is freed twice. \n " , errout . str ( ) ) ;
check (
" void foo(char *p) { \n "
" delete p; \n "
" delete p; \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:3]: (error) Memory pointed to by 'p' is freed twice. \n " , errout . str ( ) ) ;
check (
" void foo(char *p, char *r) { \n "
" delete p; \n "
" delete r; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check (
" void foo(char *p) { \n "
" delete p; \n "
" getNext(&p); \n "
" delete p; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check (
" void foo(char *p) { \n "
" delete p; \n "
" bar(); \n "
" delete p; \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:4]: (error) Memory pointed to by 'p' is freed twice. \n " , errout . str ( ) ) ;
check (
" void foo(char *p) { \n "
" delete[] p; \n "
" delete[] p; \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:3]: (error) Memory pointed to by 'p' is freed twice. \n " , errout . str ( ) ) ;
check (
" void foo(char *p, char *r) { \n "
" delete[] p; \n "
" delete[] r; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check (
" void foo(char *p) { \n "
" delete[] p; \n "
" getNext(&p); \n "
" delete[] p; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
check (
" void foo(char *p) { \n "
" delete[] p; \n "
" bar(); \n "
" delete[] p; \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:4]: (error) Memory pointed to by 'p' is freed twice. \n " , errout . str ( ) ) ;
2012-01-25 07:43:44 +01:00
check (
2012-02-04 20:33:48 +01:00
" ~LineMarker() { \n "
" delete pxpm; \n "
" } \n "
" LineMarker &operator=(const LineMarker &) { \n "
" delete pxpm; \n "
" pxpm = NULL; \n "
" return *this; \n "
2012-01-25 07:43:44 +01:00
" } "
) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2012-02-04 20:24:40 +01:00
check (
2012-02-04 20:33:48 +01:00
" void foo() \n "
" { \n "
" int* ptr = NULL; \n "
" try \n "
" { \n "
" ptr = new int(4); \n "
" } \n "
" catch(...) \n "
" { \n "
" delete ptr; \n "
" throw; \n "
" } \n "
" delete ptr; \n "
2012-02-04 20:24:40 +01:00
" } "
) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2012-02-17 06:03:38 +01:00
check (
" int foo() \n "
" { \n "
" int* a = new int; \n "
" bool doDelete = true; \n "
" if (a != 0) \n "
" { \n "
" doDelete = false; \n "
" delete a; \n "
" } \n "
" if(doDelete) \n "
" delete a; \n "
" return 0; \n "
" } "
) ;
2012-02-18 21:13:21 +01:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2012-01-15 01:19:34 +01:00
}
2008-12-19 22:15:18 +01:00
} ;
2009-01-05 16:49:57 +01:00
REGISTER_TEST ( TestOther )