2008-12-18 22:28:57 +01:00
/*
2009-01-21 21:04:20 +01:00
* Cppcheck - A tool for static C / C + + code analysis
2022-02-05 11:45:17 +01:00
* Copyright ( C ) 2007 - 2022 Cppcheck team .
2008-12-18 22:28:57 +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-18 22:28:57 +01:00
*/
2017-05-27 04:33:47 +02:00
# include "checkunusedvar.h"
2022-01-27 19:03:20 +01:00
# include "config.h"
# include "errortypes.h"
2020-06-30 10:59:57 +02:00
# include "preprocessor.h"
2017-05-27 04:33:47 +02:00
# include "settings.h"
2008-12-18 22:28:57 +01:00
# include "testsuite.h"
2009-10-25 12:49:06 +01:00
# include "tokenize.h"
2008-12-18 22:28:57 +01:00
2022-01-27 19:03:20 +01:00
# include <iosfwd>
# include <list>
2017-05-27 04:33:47 +02:00
# include <string>
2008-12-18 22:28:57 +01:00
2011-10-13 20:53:06 +02:00
class TestUnusedVar : public TestFixture {
2008-12-18 22:28:57 +01:00
public :
2021-08-07 20:51:18 +02:00
TestUnusedVar ( ) : TestFixture ( " TestUnusedVar " ) { }
2008-12-18 22:28:57 +01:00
private :
2015-10-07 18:33:57 +02:00
Settings settings ;
2019-01-12 15:45:25 +01:00
void run ( ) OVERRIDE {
2021-02-24 22:00:06 +01:00
settings . severity . enable ( Severity : : style ) ;
settings . severity . enable ( Severity : : information ) ;
2019-11-17 12:08:21 +01:00
settings . checkLibrary = true ;
2019-05-31 08:06:36 +02:00
LOAD_LIB_2 ( settings . library , " std.cfg " ) ;
2015-10-07 18:33:57 +02:00
2020-07-23 11:10:08 +02:00
TEST_CASE ( isRecordTypeWithoutSideEffects ) ;
2020-11-26 17:34:42 +01:00
TEST_CASE ( cleanFunction ) ;
2020-07-23 11:10:08 +02:00
2014-02-01 22:40:35 +01:00
TEST_CASE ( emptyclass ) ; // #5355 - False positive: Variable is not assigned a value.
TEST_CASE ( emptystruct ) ; // #5355 - False positive: Variable is not assigned a value.
2009-01-05 16:49:57 +01:00
TEST_CASE ( structmember1 ) ;
TEST_CASE ( structmember2 ) ;
TEST_CASE ( structmember3 ) ;
2009-01-10 15:39:20 +01:00
TEST_CASE ( structmember4 ) ;
2009-01-11 15:39:52 +01:00
TEST_CASE ( structmember5 ) ;
2009-10-17 17:36:55 +02:00
TEST_CASE ( structmember6 ) ;
2010-04-09 19:55:41 +02:00
TEST_CASE ( structmember7 ) ;
TEST_CASE ( structmember8 ) ;
2010-09-04 11:21:34 +02:00
TEST_CASE ( structmember9 ) ; // #2017 - struct is inherited
2011-12-18 20:15:41 +01:00
TEST_CASE ( structmember_extern ) ; // No false positives for extern structs
2010-12-05 18:33:53 +01:00
TEST_CASE ( structmember10 ) ;
2012-11-18 15:24:47 +01:00
TEST_CASE ( structmember11 ) ; // #4168 - initialization with {} / passed by address to unknown function
2015-12-17 14:08:24 +01:00
TEST_CASE ( structmember12 ) ; // #7179 - FP unused structmember
2016-09-05 17:27:12 +02:00
TEST_CASE ( structmember13 ) ; // #3088 - __attribute__((packed))
2017-11-12 22:33:17 +01:00
TEST_CASE ( structmember14 ) ; // #6508 - (struct x){1,2,..}
2020-06-30 10:59:57 +02:00
TEST_CASE ( structmember15 ) ; // #3088 - #pragma pack(1)
2016-08-02 18:50:04 +02:00
TEST_CASE ( structmember_sizeof ) ;
2021-10-30 19:34:46 +02:00
TEST_CASE ( structmember16 ) ; // #10485
2021-12-18 22:55:52 +01:00
TEST_CASE ( structmember17 ) ; // #10591
2022-02-02 19:28:16 +01:00
TEST_CASE ( structmember18 ) ; // #10684
2010-02-18 19:55:47 +01:00
2010-02-18 18:45:13 +01:00
TEST_CASE ( localvar1 ) ;
TEST_CASE ( localvar2 ) ;
TEST_CASE ( localvar3 ) ;
TEST_CASE ( localvar4 ) ;
TEST_CASE ( localvar5 ) ;
2010-03-16 19:25:10 +01:00
TEST_CASE ( localvar6 ) ;
2010-04-15 18:44:52 +02:00
TEST_CASE ( localvar8 ) ;
2010-04-16 16:25:57 +02:00
TEST_CASE ( localvar9 ) ; // ticket #1605
2010-04-24 09:45:03 +02:00
TEST_CASE ( localvar10 ) ;
2010-04-24 12:21:26 +02:00
TEST_CASE ( localvar11 ) ;
2010-05-01 10:26:15 +02:00
TEST_CASE ( localvar12 ) ;
2010-05-01 21:15:14 +02:00
TEST_CASE ( localvar13 ) ; // ticket #1640
2010-05-09 07:10:51 +02:00
TEST_CASE ( localvar14 ) ; // ticket #5
2010-05-23 10:41:05 +02:00
TEST_CASE ( localvar15 ) ;
2010-05-26 19:22:35 +02:00
TEST_CASE ( localvar16 ) ; // ticket #1709
2010-06-01 20:00:43 +02:00
TEST_CASE ( localvar17 ) ; // ticket #1720
2010-06-03 07:05:57 +02:00
TEST_CASE ( localvar18 ) ; // ticket #1723
2010-06-08 18:24:42 +02:00
TEST_CASE ( localvar19 ) ; // ticket #1776
2010-06-21 18:12:01 +02:00
TEST_CASE ( localvar20 ) ; // ticket #1799
2010-06-22 17:04:11 +02:00
TEST_CASE ( localvar21 ) ; // ticket #1807
2010-06-25 07:52:12 +02:00
TEST_CASE ( localvar22 ) ; // ticket #1811
2010-06-29 08:38:24 +02:00
TEST_CASE ( localvar23 ) ; // ticket #1808
2010-07-07 08:39:18 +02:00
TEST_CASE ( localvar24 ) ; // ticket #1803
2010-07-08 08:42:34 +02:00
TEST_CASE ( localvar25 ) ; // ticket #1729
2010-08-07 15:53:51 +02:00
TEST_CASE ( localvar26 ) ; // ticket #1894
2010-11-02 20:01:12 +01:00
TEST_CASE ( localvar27 ) ; // ticket #2160
2010-11-15 17:30:07 +01:00
TEST_CASE ( localvar28 ) ; // ticket #2205
2010-11-15 17:53:55 +01:00
TEST_CASE ( localvar29 ) ; // ticket #2206 (array initialization)
2010-12-03 18:45:49 +01:00
TEST_CASE ( localvar30 ) ;
2010-12-19 18:27:31 +01:00
TEST_CASE ( localvar31 ) ; // ticket #2286
2010-12-21 08:13:40 +01:00
TEST_CASE ( localvar32 ) ; // ticket #2330
2010-12-25 19:17:53 +01:00
TEST_CASE ( localvar33 ) ; // ticket #2346
2010-12-27 15:12:17 +01:00
TEST_CASE ( localvar34 ) ; // ticket #2368
2011-02-09 19:20:44 +01:00
TEST_CASE ( localvar35 ) ; // ticket #2535
2011-06-08 19:54:01 +02:00
TEST_CASE ( localvar36 ) ; // ticket #2805
2011-09-04 20:48:05 +02:00
TEST_CASE ( localvar37 ) ; // ticket #3078
2011-12-18 20:15:41 +01:00
TEST_CASE ( localvar38 ) ;
2011-12-30 09:47:15 +01:00
TEST_CASE ( localvar39 ) ; // ticket #3454
2012-01-08 08:44:18 +01:00
TEST_CASE ( localvar40 ) ; // ticket #3473
2014-10-16 10:59:46 +02:00
TEST_CASE ( localvar41 ) ; // ticket #3603
TEST_CASE ( localvar42 ) ; // ticket #3742
TEST_CASE ( localvar43 ) ; // ticket #3602
TEST_CASE ( localvar44 ) ; // ticket #4020
TEST_CASE ( localvar45 ) ; // ticket #4899
TEST_CASE ( localvar46 ) ; // ticket #5491 (C++11 style initialization)
2015-04-13 21:21:57 +02:00
TEST_CASE ( localvar47 ) ; // ticket #6603
2015-08-27 23:56:26 +02:00
TEST_CASE ( localvar48 ) ; // ticket #6954
2016-07-09 09:22:52 +02:00
TEST_CASE ( localvar49 ) ; // ticket #7594
2017-07-01 11:03:49 +02:00
TEST_CASE ( localvar50 ) ; // ticket #6261 : dostuff(cond ? buf1 : buf2)
2017-08-01 14:56:53 +02:00
TEST_CASE ( localvar51 ) ; // ticket #8128 - FN : tok = tok->next();
2018-12-13 18:52:56 +01:00
TEST_CASE ( localvar52 ) ;
TEST_CASE ( localvar53 ) ; // continue
2018-12-14 18:56:09 +01:00
TEST_CASE ( localvar54 ) ; // ast, {}
2018-12-16 21:45:26 +01:00
TEST_CASE ( localvar55 ) ;
2019-01-02 20:23:02 +01:00
TEST_CASE ( localvar56 ) ;
2019-07-29 08:49:19 +02:00
TEST_CASE ( localvar57 ) ; // #8974 - increment
2020-09-26 22:13:05 +02:00
TEST_CASE ( localvar58 ) ; // #9901 - increment false positive
2020-10-25 20:32:45 +01:00
TEST_CASE ( localvar59 ) ; // #9737
2021-10-24 21:22:06 +02:00
TEST_CASE ( localvar60 ) ;
2018-12-16 11:18:37 +01:00
TEST_CASE ( localvarloops ) ; // loops
2010-04-30 21:36:48 +02:00
TEST_CASE ( localvaralias1 ) ;
TEST_CASE ( localvaralias2 ) ; // ticket #1637
2010-05-04 17:26:09 +02:00
TEST_CASE ( localvaralias3 ) ; // ticket #1639
2010-05-04 17:28:03 +02:00
TEST_CASE ( localvaralias4 ) ; // ticket #1643
2010-05-05 17:31:07 +02:00
TEST_CASE ( localvaralias5 ) ; // ticket #1647
2010-06-06 20:37:48 +02:00
TEST_CASE ( localvaralias6 ) ; // ticket #1729
2010-06-23 06:54:14 +02:00
TEST_CASE ( localvaralias7 ) ; // ticket #1732
2010-07-12 09:50:18 +02:00
TEST_CASE ( localvaralias8 ) ;
2010-08-31 20:33:28 +02:00
TEST_CASE ( localvaralias9 ) ; // ticket #1996
2010-08-31 20:58:37 +02:00
TEST_CASE ( localvaralias10 ) ; // ticket #2004
2013-02-16 16:07:05 +01:00
TEST_CASE ( localvaralias11 ) ; // ticket #4423 - iterator
2013-02-20 17:43:16 +01:00
TEST_CASE ( localvaralias12 ) ; // ticket #4394
2013-03-20 06:38:53 +01:00
TEST_CASE ( localvaralias13 ) ; // ticket #4487
2017-07-09 11:19:00 +02:00
TEST_CASE ( localvaralias14 ) ; // ticket #5619
2017-07-23 23:32:14 +02:00
TEST_CASE ( localvaralias15 ) ; // ticket #6315
2018-12-13 18:52:56 +01:00
TEST_CASE ( localvaralias16 ) ;
2018-12-30 20:20:20 +01:00
TEST_CASE ( localvaralias17 ) ; // ticket #8911
2019-08-04 10:21:16 +02:00
TEST_CASE ( localvaralias18 ) ; // ticket #9234 - iterator
2022-01-24 21:52:45 +01:00
TEST_CASE ( localvaralias19 ) ; // ticket #9828
2010-03-31 20:20:51 +02:00
TEST_CASE ( localvarasm ) ;
2010-06-24 17:00:32 +02:00
TEST_CASE ( localvarstatic ) ;
2012-06-28 17:22:56 +02:00
TEST_CASE ( localvarextern ) ;
2011-07-15 01:15:59 +02:00
TEST_CASE ( localvardynamic1 ) ;
TEST_CASE ( localvardynamic2 ) ; // ticket #2904
2012-01-08 08:31:00 +01:00
TEST_CASE ( localvardynamic3 ) ; // ticket #3467
2011-05-11 18:58:25 +02:00
TEST_CASE ( localvararray1 ) ; // ticket #2780
2011-12-26 08:12:23 +01:00
TEST_CASE ( localvararray2 ) ; // ticket #3438
2012-08-25 13:07:33 +02:00
TEST_CASE ( localvararray3 ) ; // ticket #3980
2016-05-17 16:03:55 +02:00
TEST_CASE ( localvararray4 ) ; // ticket #4839
2017-06-03 15:31:29 +02:00
TEST_CASE ( localvararray5 ) ; // ticket #7092
2011-07-22 00:37:37 +02:00
TEST_CASE ( localvarstring1 ) ;
TEST_CASE ( localvarstring2 ) ; // ticket #2929
2012-02-25 12:56:33 +01:00
TEST_CASE ( localvarconst1 ) ;
TEST_CASE ( localvarconst2 ) ;
2019-07-03 08:17:06 +02:00
TEST_CASE ( localvarreturn ) ; // ticket #9167
2020-04-12 20:35:54 +02:00
TEST_CASE ( localvarmaybeunused ) ;
2010-02-18 18:45:13 +01:00
2012-03-26 21:19:42 +02:00
TEST_CASE ( localvarthrow ) ; // ticket #3687
2012-07-24 20:47:29 +02:00
TEST_CASE ( localVarStd ) ;
2019-07-14 16:20:45 +02:00
TEST_CASE ( localVarClass ) ;
2020-09-27 19:15:15 +02:00
TEST_CASE ( localVarSmartPtr ) ;
2012-07-24 20:47:29 +02:00
2010-02-18 18:45:13 +01:00
// Don't give false positives for variables in structs/unions
TEST_CASE ( localvarStruct1 ) ;
TEST_CASE ( localvarStruct2 ) ;
TEST_CASE ( localvarStruct3 ) ;
2011-07-01 03:58:11 +02:00
TEST_CASE ( localvarStruct5 ) ;
2011-07-01 14:45:29 +02:00
TEST_CASE ( localvarStruct6 ) ;
2018-12-15 11:54:00 +01:00
TEST_CASE ( localvarStruct7 ) ;
2019-12-20 18:31:44 +01:00
TEST_CASE ( localvarStruct8 ) ;
2020-02-15 16:43:06 +01:00
TEST_CASE ( localvarStruct9 ) ;
2021-05-09 20:09:10 +02:00
TEST_CASE ( localvarStruct10 ) ;
2021-08-27 17:37:30 +02:00
TEST_CASE ( localvarStruct11 ) ; // 10095
2021-09-24 07:30:17 +02:00
TEST_CASE ( localvarStruct12 ) ; // #10495
2022-01-25 22:05:54 +01:00
TEST_CASE ( localvarStruct13 ) ; // #10398
2012-02-26 08:29:02 +01:00
TEST_CASE ( localvarStructArray ) ;
2020-10-02 20:22:09 +02:00
TEST_CASE ( localvarUnion1 ) ;
2010-02-18 18:45:13 +01:00
TEST_CASE ( localvarOp ) ; // Usage with arithmetic operators
TEST_CASE ( localvarInvert ) ; // Usage with inverted variable
TEST_CASE ( localvarIf ) ; // Usage in if
TEST_CASE ( localvarIfElse ) ; // return tmp1 ? tmp2 : tmp3;
2021-04-26 07:38:03 +02:00
TEST_CASE ( localvarDeclaredInIf ) ;
2010-02-18 18:45:13 +01:00
TEST_CASE ( localvarOpAssign ) ; // a |= b;
TEST_CASE ( localvarFor ) ; // for ( ; var; )
2012-12-17 18:19:05 +01:00
TEST_CASE ( localvarForEach ) ; // #4155 - BOOST_FOREACH, hlist_for_each, etc
2010-12-02 20:08:05 +01:00
TEST_CASE ( localvarShift1 ) ; // 1 >> var
2012-01-23 08:02:59 +01:00
TEST_CASE ( localvarShift3 ) ; // x << y
2010-05-09 07:15:40 +02:00
TEST_CASE ( localvarCast ) ;
2010-06-10 07:21:47 +02:00
TEST_CASE ( localvarClass ) ;
2010-06-14 15:46:57 +02:00
TEST_CASE ( localvarUnused ) ;
2010-06-21 18:12:01 +02:00
TEST_CASE ( localvarFunction ) ; // ticket #1799
2011-09-11 08:19:35 +02:00
TEST_CASE ( localvarIfNOT ) ; // #3104 - if ( NOT var )
2012-03-21 18:40:32 +01:00
TEST_CASE ( localvarAnd ) ; // #3672
2012-04-28 15:43:42 +02:00
TEST_CASE ( localvarSwitch ) ; // #3744 - false positive when localvar is used in switch
2012-09-30 17:22:35 +02:00
TEST_CASE ( localvarNULL ) ; // #4203 - Setting NULL value is not redundant - it is safe
2013-03-28 06:44:37 +01:00
TEST_CASE ( localvarUnusedGoto ) ; // #4447, #4558 goto
2015-10-27 14:46:58 +01:00
TEST_CASE ( localvarRangeBasedFor ) ; // #7075
2016-01-01 12:14:18 +01:00
TEST_CASE ( localvarAssignInWhile ) ;
2016-01-30 16:49:39 +01:00
TEST_CASE ( localvarTemplate ) ; // #4955 - variable is used as template parameter
2016-01-30 20:59:32 +01:00
TEST_CASE ( localvarFuncPtr ) ; // #7194
2016-09-03 20:38:36 +02:00
TEST_CASE ( localvarAddr ) ; // #7477
2018-11-14 17:04:14 +01:00
TEST_CASE ( localvarDelete ) ;
2019-01-26 21:43:44 +01:00
TEST_CASE ( localvarLambda ) ; // #8941, #8948
2012-08-10 12:36:08 +02:00
2016-01-01 16:04:13 +01:00
TEST_CASE ( localvarCppInitialization ) ;
2014-09-30 12:39:27 +02:00
TEST_CASE ( localvarCpp11Initialization ) ;
2014-08-31 19:46:30 +02:00
TEST_CASE ( chainedAssignment ) ; // #5466
2012-08-10 12:36:08 +02:00
TEST_CASE ( crash1 ) ;
2013-04-01 12:41:14 +02:00
TEST_CASE ( crash2 ) ;
2013-02-14 06:31:41 +01:00
TEST_CASE ( usingNamespace ) ; // #4585
2016-05-26 18:07:56 +02:00
TEST_CASE ( lambdaFunction ) ; // #5078
2016-10-01 21:21:07 +02:00
TEST_CASE ( namespaces ) ; // #7557
2017-01-22 10:16:40 +01:00
TEST_CASE ( bracesInitCpp11 ) ; // #7895 - "int var{123}" initialization
2018-12-13 18:52:56 +01:00
TEST_CASE ( argument ) ;
2019-11-16 19:49:43 +01:00
TEST_CASE ( argumentClass ) ;
2019-05-31 08:06:36 +02:00
TEST_CASE ( escapeAlias ) ; // #9150
2020-02-15 17:18:21 +01:00
TEST_CASE ( volatileData ) ; // #9280
2021-05-18 20:35:00 +02:00
TEST_CASE ( globalData ) ;
2008-12-18 22:28:57 +01:00
}
2021-11-29 07:34:39 +01:00
# define functionVariableUsage(...) functionVariableUsage_(__FILE__, __LINE__, __VA_ARGS__)
# define checkStructMemberUsage(...) checkStructMemberUsage_(__FILE__, __LINE__, __VA_ARGS__)
void checkStructMemberUsage_ ( const char * file , int line , const char code [ ] , const std : : list < Directive > * directives = nullptr ) {
2010-06-18 07:19:26 +02:00
// Clear the error buffer..
errout . str ( " " ) ;
2020-06-30 10:59:57 +02:00
Preprocessor preprocessor ( settings , nullptr ) ;
if ( directives )
preprocessor . setDirectives ( * directives ) ;
2010-12-01 18:00:55 +01:00
// Tokenize..
Tokenizer tokenizer ( & settings , this ) ;
2020-06-30 10:59:57 +02:00
tokenizer . setPreprocessor ( & preprocessor ) ;
2010-12-01 18:00:55 +01:00
std : : istringstream istr ( code ) ;
2021-11-29 07:34:39 +01:00
ASSERT_LOC ( tokenizer . tokenize ( istr , " test.cpp " ) , file , line ) ;
2010-06-18 07:19:26 +02:00
// Check for unused variables..
2011-08-19 20:35:25 +02:00
CheckUnusedVar checkUnusedVar ( & tokenizer , & settings , this ) ;
2021-11-29 07:34:39 +01:00
( checkUnusedVar . checkStructMemberUsage ) ( ) ;
2010-06-18 07:19:26 +02:00
}
2020-07-23 11:10:08 +02:00
void isRecordTypeWithoutSideEffects ( ) {
functionVariableUsage (
" class A {}; \n "
" void f() { \n "
" A a; \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:3]: (style) Unused variable: a \n " , errout . str ( ) ) ;
functionVariableUsage (
" class A {}; \n "
" class B { \n "
" public: \n "
" A a; \n "
" }; \n "
" void f() { \n "
" B b; \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:7]: (style) Unused variable: b \n " , errout . str ( ) ) ;
functionVariableUsage (
" class C { \n "
" public: \n "
" C() = default; \n "
" }; \n "
" void f() { \n "
" C c; \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:6]: (style) Unused variable: c \n " , errout . str ( ) ) ;
functionVariableUsage (
" class D { \n "
" public: \n "
" D() {} \n "
" }; \n "
" void f() { \n "
" D d; \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:6]: (style) Unused variable: d \n " , errout . str ( ) ) ;
functionVariableUsage (
" class E { \n "
" public: \n "
" uint32_t u{1}; \n "
" }; \n "
" void f() { \n "
" E e; \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:6]: (style) Unused variable: e \n " , errout . str ( ) ) ;
2020-10-25 07:11:45 +01:00
functionVariableUsage (
" class F { \n "
" public: \n "
" F() : x(0) {} \n "
" int x; \n "
" }; \n "
" void f() { \n "
" F f; \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:7]: (style) Unused variable: f \n " , errout . str ( ) ) ;
functionVariableUsage (
" class F { \n "
" public: \n "
" F() : x{0} {} \n "
" int x; \n "
" }; \n "
" void f() { \n "
" F f; \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:7]: (style) Unused variable: f \n " , errout . str ( ) ) ;
functionVariableUsage (
" int y = 0; \n "
" class F { \n "
" public: \n "
" F() : x(y) {} \n "
" int x; \n "
" }; \n "
" void f() { \n "
" F f; \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:8]: (style) Unused variable: f \n " , errout . str ( ) ) ;
functionVariableUsage (
" int y = 0; "
" class F { \n "
" public: \n "
" F() : x(++y) {} \n "
" int x; \n "
" }; \n "
" void f() { \n "
" F f; \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:7]: (style) Unused variable: f \n " , errout . str ( ) ) ;
functionVariableUsage (
" int y = 0; "
" class F { \n "
" public: \n "
" F() : x(--y) {} \n "
" int x; \n "
" }; \n "
" void f() { \n "
" F f; \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:7]: (style) Unused variable: f \n " , errout . str ( ) ) ;
functionVariableUsage (
" int y = 0; "
" class F { \n "
" public: \n "
" F() : x(y+=1) {} \n "
" int x; \n "
" }; \n "
" void f() { \n "
" F f; \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:7]: (style) Unused variable: f \n " , errout . str ( ) ) ;
functionVariableUsage (
" int y = 0; "
" class F { \n "
" public: \n "
" F() : x(y-=1) {} \n "
" int x; \n "
" }; \n "
" void f() { \n "
" F f; \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:7]: (style) Unused variable: f \n " , errout . str ( ) ) ;
2020-07-23 11:10:08 +02:00
// non-empty constructor
functionVariableUsage (
" class F { \n "
" public: \n "
" F() { \n "
2020-10-25 07:11:45 +01:00
" int i = 0; \n "
2020-07-23 11:10:08 +02:00
" (void) i; "
" } \n "
" }; \n "
" void f() { \n "
" F f; \n "
" } " ) ;
TODO_ASSERT_EQUALS ( " error " , " " , errout . str ( ) ) ;
// side-effect variable
functionVariableUsage (
" class F { \n "
" public: \n "
" F() { \n "
2020-10-25 07:11:45 +01:00
" int i = 0; \n "
2020-07-23 11:10:08 +02:00
" (void) i; "
" } \n "
" }; \n "
" class G { \n "
" public: \n "
" F f; \n "
" }; \n "
" void f() { \n "
" G g; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2020-10-25 07:11:45 +01:00
// side-effect variable in initialization list
functionVariableUsage (
" class F { \n "
" public: \n "
" F() { \n "
" int i = 0; \n "
" (void) i; "
" } \n "
" }; \n "
" class G { \n "
" public: \n "
" G() : f(F()) {} \n "
" F f; "
" }; \n "
" void f() { \n "
" G g; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2020-07-23 11:10:08 +02:00
// unknown variable type
functionVariableUsage (
" class H { \n "
" public: \n "
" unknown_type u{1}; \n "
" }; \n "
" void f() { \n "
" H h; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2020-10-25 07:11:45 +01:00
// unknown variable type in initialization list
functionVariableUsage (
" class H { \n "
" public: \n "
" H() : x{0}, u(1) {} \n "
" int x; "
" unknown_type u; \n "
" }; \n "
" void f() { \n "
" H h; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2020-10-25 07:12:30 +01:00
// unknown variable type used for initialization
2020-10-25 07:11:45 +01:00
functionVariableUsage (
" unknown_type y = 0; \n "
" class F { \n "
" public: \n "
" F() : x(y) {} \n "
" int x; \n "
" }; \n "
" void f() { \n "
" F f; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
functionVariableUsage (
" int sideEffectFunc(); \n "
" class F { \n "
" public: \n "
" F() : x(sideEffectFunc()) {} \n "
" int x; \n "
" }; \n "
" void f() { \n "
" F f; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
functionVariableUsage (
" class F { \n "
" public: \n "
2020-11-26 17:34:42 +01:00
" F() : x(++unknownValue) {} \n "
2020-10-25 07:11:45 +01:00
" int x; \n "
" }; \n "
" void f() { \n "
" F f; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2020-07-23 11:10:08 +02:00
2020-10-25 07:11:45 +01:00
functionVariableUsage (
" class F { \n "
" public: \n "
2020-11-26 17:34:42 +01:00
" F() : x(--unknownValue) {} \n "
2020-10-25 07:11:45 +01:00
" int x; \n "
" }; \n "
" void f() { \n "
" F f; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
functionVariableUsage (
" class F { \n "
" public: \n "
2020-11-26 17:34:42 +01:00
" F() : x(unknownValue+=1) {} \n "
2020-10-25 07:11:45 +01:00
" int x; \n "
" }; \n "
" void f() { \n "
" F f; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
functionVariableUsage (
" class F { \n "
" public: \n "
2020-11-26 17:34:42 +01:00
" F() : x(unknownValue-=1) {} \n "
2020-10-25 07:11:45 +01:00
" int x; \n "
" }; \n "
" void f() { \n "
" F f; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2020-11-26 17:34:42 +01:00
}
2020-10-25 07:12:30 +01:00
2020-11-28 05:52:35 +01:00
void cleanFunction ( ) {
2020-11-26 17:34:42 +01:00
// unknown function
2020-10-25 07:11:45 +01:00
functionVariableUsage (
" class F { \n "
" public: \n "
2020-11-26 17:34:42 +01:00
" F() : x(func()) {} \n "
2020-10-25 07:11:45 +01:00
" int x; \n "
" }; \n "
" void f() { \n "
" F f; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2020-11-26 17:34:42 +01:00
// function forward declaration
functionVariableUsage (
" int func(); \n "
" class C { \n "
" public: \n "
" C() : x(func()) {} \n "
" int x; \n "
" }; \n "
" void f() { \n "
" C c; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2020-11-28 05:52:35 +01:00
2020-11-26 17:34:42 +01:00
// return literal
functionVariableUsage (
" int func() { return 1; } \n "
" class C { \n "
" public: \n "
" C() : x(func()) {} \n "
" int x; \n "
" }; \n "
" void f() { \n "
" C c; \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:8]: (style) Unused variable: c \n " , errout . str ( ) ) ;
// return variable without side effects
functionVariableUsage (
" int func() { \n "
" int x = 1; \n "
" return x; \n "
" } \n "
" class C { \n "
" public: \n "
" C() : x(func()) {} \n "
" int x; \n "
" }; \n "
" void f() { \n "
" C c; \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:11]: (style) Unused variable: c \n " , errout . str ( ) ) ;
// return variable with side effects
functionVariableUsage (
" int func() { \n "
" unknown_type x = 1; \n "
" return x; \n "
" } \n "
" class C { \n "
" public: \n "
" C() : x(func()) {} \n "
" int x; \n "
" }; \n "
" void f() { \n "
" C c; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
// return unknown variable
functionVariableUsage (
" int func() { \n "
" return unknown_var; \n "
" } \n "
" class C { \n "
" public: \n "
" C() : x(func()) {} \n "
" int x; \n "
" }; \n "
" void f() { \n "
" C c; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
// return variable is global, but not changed
functionVariableUsage (
" int x = 1; \n "
" int func() { \n "
" return x; \n "
" } \n "
" class C { \n "
" public: \n "
" C() : x(func()) {} \n "
" int x; \n "
" }; \n "
" void f() { \n "
" C c; \n "
" } " ) ;
2020-12-19 08:55:19 +01:00
ASSERT_EQUALS ( " [test.cpp:11]: (style) Unused variable: c \n " , errout . str ( ) ) ;
2020-11-26 17:34:42 +01:00
// changing global variable in return
functionVariableUsage (
" int x = 1; \n "
" int func() { \n "
" return x++; \n "
" } \n "
" class C { \n "
" public: \n "
" C() : x(func()) {} \n "
" int x; \n "
" }; \n "
" void f() { \n "
" C c; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
// changing global variable in function body
functionVariableUsage (
" int x = 1; \n "
" int func() { \n "
" x++; \n "
" return 1; \n "
" } \n "
" class C { \n "
" public: \n "
" C() : x(func()) {} \n "
" int x; \n "
" }; \n "
" void f() { \n "
" C c; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
functionVariableUsage (
" int x = 1; \n "
" int func() { \n "
" --x; \n "
" return 1; \n "
" } \n "
" class C { \n "
" public: \n "
" C() : x(func()) {} \n "
" int x; \n "
" }; \n "
" void f() { \n "
" C c; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
functionVariableUsage (
" int x = 1; \n "
" int func() { \n "
" x += 2; \n "
" return 1; \n "
" } \n "
" class C { \n "
" public: \n "
" C() : x(func()) {} \n "
" int x; \n "
" }; \n "
" void f() { \n "
" C c; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
functionVariableUsage (
" int x = 1; \n "
" int func() { \n "
" x = 2; \n "
" return 1; \n "
" } \n "
" class C { \n "
" public: \n "
" C() : x(func()) {} \n "
" int x; \n "
" }; \n "
" void f() { \n "
" C c; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2020-12-19 08:55:19 +01:00
// global variable use in function body without change
functionVariableUsage (
" int global = 1; \n "
" int func() { \n "
" int x = global + 1; \n "
" return x; \n "
" } \n "
" class C { \n "
" public: \n "
" C() : x(func()) {} \n "
" int x; \n "
" }; \n "
" void f() { \n "
" C c; \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:12]: (style) Unused variable: c \n " , errout . str ( ) ) ;
2020-11-26 17:34:42 +01:00
// changing global array variable in function body
functionVariableUsage (
" int x[] = {0, 1, 3}; \n "
" int func() { \n "
" x[0] = 4; \n "
" return 1; \n "
" } \n "
" class C { \n "
" public: \n "
" C() : x(func()) {} \n "
" int x; \n "
" }; \n "
" void f() { \n "
" C c; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2020-12-19 08:55:19 +01:00
functionVariableUsage (
" int x[] = {0, 1, 3}; \n "
" int func() { \n "
" *x = 2; \n "
" return 1; \n "
" } \n "
" class C { \n "
" public: \n "
" C() : x(func()) {} \n "
" int x; \n "
" }; \n "
" void f() { \n "
" C c; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2021-01-01 08:06:20 +01:00
functionVariableUsage (
" int x[] = {0, 1, 3}; \n "
" int func() { \n "
" *(x) = 2; \n "
" return 1; \n "
" } \n "
" class C { \n "
" public: \n "
" C() : x(func()) {} \n "
" int x; \n "
" }; \n "
" void f() { \n "
" C c; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
// pointer arithmetic on global array
2020-12-19 08:55:19 +01:00
functionVariableUsage (
" int x[] = {0, 1, 3}; \n "
" int func() { \n "
" *(x + 1) = 2; \n "
" return 1; \n "
" } \n "
" class C { \n "
" public: \n "
" C() : x(func()) {} \n "
" int x; \n "
" }; \n "
" void f() { \n "
" C c; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2021-01-01 08:06:20 +01:00
functionVariableUsage (
" int x[][] = {{0, 1}, {2, 3}}; \n "
" int func() { \n "
" *((x + 1) + 1) = 4; \n "
" return 1; \n "
" } \n "
" class C { \n "
" public: \n "
" C() : x(func()) {} \n "
" int x; \n "
" }; \n "
" void f() { \n "
" C c; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
functionVariableUsage (
" int x[] = {0, 1, 3}; \n "
" int func() { \n "
" int local = *(x + 1); \n "
" (void) local; \n "
" return 1; \n "
" } \n "
" class C { \n "
" public: \n "
" C() : x(func()) {} \n "
" int x; \n "
" }; \n "
" void f() { \n "
" C c; \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:13]: (style) Unused variable: c \n " , errout . str ( ) ) ;
functionVariableUsage (
" int x[] = {0, 1, 3}; \n "
" int func() { \n "
" int* local = x + 2; \n "
" (void) local; \n "
" return 1; \n "
" } \n "
" class C { \n "
" public: \n "
" C() : x(func()) {} \n "
" int x; \n "
" }; \n "
" void f() { \n "
" C c; \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:13]: (style) Unused variable: c \n " , errout . str ( ) ) ;
functionVariableUsage (
" int x[] = {0, 1, 3}; \n "
" int func() { \n "
" int* local = x + 2; \n "
" return *local; \n "
" } \n "
" class C { \n "
" public: \n "
" C() : x(func()) {} \n "
" int x; \n "
" }; \n "
" void f() { \n "
" C c; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
functionVariableUsage (
" int x[] = {0, 1, 3}; \n "
" int func() { \n "
" return *(x + 1); \n "
" } \n "
" class C { \n "
" public: \n "
" C() : x(func()) {} \n "
" int x; \n "
" }; \n "
" void f() { \n "
" C c; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2020-11-26 17:34:42 +01:00
// changing local variable
functionVariableUsage (
" int func() { \n "
" int x = 1; \n "
" x = 2; \n "
" x++; \n "
" return x; \n "
" } \n "
" class C { \n "
" public: \n "
" C() : x(func()) {} \n "
" int x; \n "
" }; \n "
" void f() { \n "
" C c; \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:13]: (style) Unused variable: c \n " , errout . str ( ) ) ;
// variable of user-defined class without side effects
functionVariableUsage (
" class A {}; \n "
" A func() { \n "
" A a; \n "
" return a; \n "
" } \n "
" class C { \n "
" public: \n "
" C() : x(func()) {} \n "
" A x; \n "
" }; \n "
" void f() { \n "
" C c; \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:12]: (style) Unused variable: c \n " , errout . str ( ) ) ;
// variable of user-defined class with side effects
functionVariableUsage (
" class A { \n "
" public: \n "
" unknown_type u{1}; \n "
" }; \n "
" int func() { \n "
" A a; \n "
" return 1; \n "
" } \n "
" class C { \n "
" public: \n "
" C() : x(func()) {} \n "
" int x; \n "
" }; \n "
" void f() { \n "
" C c; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
// unknown type variable
functionVariableUsage (
" int func() { \n "
" unknown_type a; \n "
" return 1; \n "
" } \n "
" class C { \n "
" public: \n "
" C() : x(func()) {} \n "
" int x; \n "
" }; \n "
" void f() { \n "
" C c; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
// nested clean function call
functionVariableUsage (
" int another_func() { return 1;} \n "
" int func() { \n "
" another_func(); \n "
" return 1; \n "
" } \n "
" class C { \n "
" public: \n "
" C() : x(func()) {} \n "
" int x; \n "
" }; \n "
" void f() { \n "
" C c; \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:12]: (style) Unused variable: c \n " , errout . str ( ) ) ;
// nested side-effects function call
functionVariableUsage (
" int global = 1; "
" int another_func() { \n "
" global++; \n "
" return global;} \n "
" int func() { \n "
" another_func(); \n "
" return 1; \n "
" } \n "
" class C { \n "
" public: \n "
" C() : x(func()) {} \n "
" int x; \n "
" }; \n "
" void f() { \n "
" C c; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
// unknown nested function
functionVariableUsage (
" int func() { \n "
" unknown_func(); \n "
" return 1; \n "
" } \n "
" class C { \n "
" public: \n "
" C() : x(func()) {} \n "
" int x; \n "
" }; \n "
" void f() { \n "
" C c; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
// clean function recursion
functionVariableUsage (
" int func(int i) { \n "
" if (i != 2) { \n "
" func(i++); \n "
" return 2; \n "
" } \n "
" return i; \n "
" } \n "
" class C { \n "
" public: \n "
" C() : x(func(0)) {} \n "
" int x; \n "
" }; \n "
" void f() { \n "
" C c; \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:14]: (style) Unused variable: c \n " , errout . str ( ) ) ;
// indirect clean function recursion
functionVariableUsage (
" void another_func() { \n "
" func(0); \n "
" } \n "
" int func(int i) { \n "
" if (i != 2) { \n "
" another_func(); \n "
" return 2; \n "
" } \n "
" return i; \n "
" } \n "
" class C { \n "
" public: \n "
" C() : x(func(0)) {} \n "
" int x; \n "
" }; \n "
" void f() { \n "
" C c; \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:17]: (style) Unused variable: c \n " , errout . str ( ) ) ;
// side-effect function recursion
functionVariableUsage (
" int global = 1; \n "
" int func(int i) { \n "
" if (i != 2) { \n "
" global++; \n "
" func(i++); \n "
" return 2; \n "
" } \n "
" return i; \n "
" } \n "
" class C { \n "
" public: \n "
" C() : x(func(0)) {} \n "
" int x; \n "
" }; \n "
" void f() { \n "
" C c; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
// multiple returns (side-effect & clean)
functionVariableUsage (
" int func(int i) { \n "
" if (i == 0) { return 0;} \n "
" else { return unknownSideEffectFunction(); } \n "
" } \n "
" class C { \n "
" public: \n "
" C() : x(func(0)) {} \n "
" int x; \n "
" }; \n "
" void f() { \n "
" C c; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
// multiple clean returns
functionVariableUsage (
" int func(int i) { \n "
" if (i == 0) { return 0;} \n "
" else { return i; } \n "
" } \n "
" class C { \n "
" public: \n "
" C() : x(func(0)) {} \n "
" int x; \n "
" }; \n "
" void f() { \n "
" C c; \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:11]: (style) Unused variable: c \n " , errout . str ( ) ) ;
// multiple side-effect returns
functionVariableUsage (
" int func(int i) { \n "
" if (i == 0) { return unknownSideEffectFunction();} \n "
" else { return unknown_var; } \n "
" } \n "
" class C { \n "
" public: \n "
" C() : x(func(0)) {} \n "
" int x; \n "
" }; \n "
" void f() { \n "
" C c; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
// argument return
functionVariableUsage (
" int func(int i) { \n "
" return i; \n "
" } \n "
" class C { \n "
" public: \n "
" C() : x(func(0)) {} \n "
" int x; \n "
" }; \n "
" void f() { \n "
" C c; \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:10]: (style) Unused variable: c \n " , errout . str ( ) ) ;
// global variable modifying through function argument
functionVariableUsage (
" char buf[10]; \n "
" int func(char* p) { \n "
" *p = 0; \n "
" return 1; \n "
" } \n "
" class C { \n "
" public: \n "
" C() : x(func(buf)) {} \n "
" int x; \n "
" }; \n "
" void f() { \n "
" C c; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
// global variable modifying through local pointer
functionVariableUsage (
" int global = 1; \n "
" int func() { \n "
2020-12-19 08:55:19 +01:00
" int* p = &global; \n "
2020-11-26 17:34:42 +01:00
" *p = 0; \n "
" return 1; \n "
" } \n "
" class C { \n "
" public: \n "
" C() : x(func()) {} \n "
" int x; \n "
" }; \n "
" void f() { \n "
" C c; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2020-12-19 08:55:19 +01:00
// global variable assigning to local pointer, but not modifying
functionVariableUsage (
" int global = 1; \n "
" int func() { \n "
" int* p = &global; \n "
" (void) p; \n "
" return 1; \n "
" } \n "
" class C { \n "
" public: \n "
" C() : x(func()) {} \n "
" int x; \n "
" }; \n "
" void f() { \n "
" C c; \n "
" } " ) ;
2021-01-01 08:06:20 +01:00
ASSERT_EQUALS ( " [test.cpp:13]: (style) Unused variable: c \n " , errout . str ( ) ) ;
2020-12-19 08:55:19 +01:00
// global struct variable modification
functionVariableUsage (
" struct S { int x; } s; \n "
" int func() { \n "
" s.x = 1; \n "
" return 1; \n "
" } \n "
" class C { \n "
" public: \n "
" C() : x(func()) {} \n "
" int x; \n "
" }; \n "
" void f() { \n "
" C c; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
// global struct variable without modification
2020-11-26 17:34:42 +01:00
functionVariableUsage (
" struct S { int x; } s; \n "
" int func() { \n "
2020-12-19 08:55:19 +01:00
" int y = s.x + 1; \n "
" return y; \n "
" } \n "
" class C { \n "
" public: \n "
" C() : x(func()) {} \n "
" int x; \n "
" }; \n "
" void f() { \n "
" C c; \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:12]: (style) Unused variable: c \n " , errout . str ( ) ) ;
// global pointer to struct variable modification
functionVariableUsage (
" struct S { int x; }; \n "
" struct S* s = new(struct S); \n "
" int func() { \n "
" s->x = 1; \n "
2020-11-26 17:34:42 +01:00
" return 1; \n "
" } \n "
" class C { \n "
" public: \n "
" C() : x(func()) {} \n "
" int x; \n "
" }; \n "
" void f() { \n "
" C c; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2020-12-19 08:55:19 +01:00
// global pointer to struct variable without modification
functionVariableUsage (
" struct S { int x; }; \n "
" struct S* s = new(struct S); \n "
" int func() { \n "
" int y = s->x + 1; \n "
" return y; \n "
" } \n "
" class C { \n "
" public: \n "
" C() : x(func()) {} \n "
" int x; \n "
" }; \n "
" void f() { \n "
" C c; \n "
" } " ) ;
2021-01-01 08:06:20 +01:00
ASSERT_EQUALS ( " [test.cpp:13]: (style) Unused variable: c \n " , errout . str ( ) ) ;
2020-07-23 11:10:08 +02:00
}
2014-02-01 22:40:35 +01:00
// #5355 - False positive: Variable is not assigned a value.
2014-11-20 14:20:09 +01:00
void emptyclass ( ) {
2014-02-01 22:40:35 +01:00
functionVariableUsage ( " class Carla { \n "
" }; \n "
" class Fred : Carla { \n "
" }; \n "
" void foo() { \n "
" Fred fred; \n "
" throw fred; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
// #5355 - False positive: Variable is not assigned a value.
2014-11-20 14:20:09 +01:00
void emptystruct ( ) {
2014-02-01 22:40:35 +01:00
functionVariableUsage ( " struct Fred { \n "
" }; \n "
" void foo() { \n "
" Fred fred; \n "
" throw fred; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2014-11-20 14:20:09 +01:00
void structmember1 ( ) {
2010-06-18 07:19:26 +02:00
checkStructMemberUsage ( " struct abc \n "
" { \n "
" int a; \n "
" int b; \n "
" int c; \n "
2013-03-20 15:36:16 +01:00
" }; " ) ;
2015-09-22 16:38:23 +02:00
ASSERT_EQUALS ( " [test.cpp:3]: (style) struct member 'abc::a' is never used. \n "
" [test.cpp:4]: (style) struct member 'abc::b' is never used. \n "
" [test.cpp:5]: (style) struct member 'abc::c' is never used. \n " , errout . str ( ) ) ;
checkStructMemberUsage ( " union abc \n "
" { \n "
" int a; \n "
" int b; \n "
" int c; \n "
" }; " ) ;
ASSERT_EQUALS ( " [test.cpp:3]: (style) union member 'abc::a' is never used. \n "
" [test.cpp:4]: (style) union member 'abc::b' is never used. \n "
" [test.cpp:5]: (style) union member 'abc::c' is never used. \n " , errout . str ( ) ) ;
2008-12-18 22:28:57 +01:00
}
2014-11-20 14:20:09 +01:00
void structmember2 ( ) {
2010-06-18 07:19:26 +02:00
checkStructMemberUsage ( " struct ABC \n "
" { \n "
" int a; \n "
" int b; \n "
" int c; \n "
" }; \n "
" \n "
" void foo() \n "
" { \n "
" struct ABC abc; \n "
" int a = abc.a; \n "
" int b = abc.b; \n "
" int c = abc.c; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2009-06-05 02:39:36 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2008-12-18 22:28:57 +01:00
}
2014-11-20 14:20:09 +01:00
void structmember3 ( ) {
2010-06-18 07:19:26 +02:00
checkStructMemberUsage ( " struct ABC \n "
" { \n "
" int a; \n "
" int b; \n "
" int c; \n "
" }; \n "
" \n "
" static struct ABC abc[] = { {1, 2, 3} }; \n "
" \n "
" void foo() \n "
" { \n "
" int a = abc[0].a; \n "
" int b = abc[0].b; \n "
" int c = abc[0].c; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2009-06-05 02:39:36 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2009-01-10 15:39:20 +01:00
}
2014-11-20 14:20:09 +01:00
void structmember4 ( ) {
2010-06-18 07:19:26 +02:00
checkStructMemberUsage ( " struct ABC \n "
" { \n "
" const int a; \n "
" }; \n "
" \n "
" void foo() \n "
" { \n "
" ABC abc; \n "
" if (abc.a == 2); \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2009-06-05 02:39:36 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2009-01-11 15:39:52 +01:00
}
2014-11-20 14:20:09 +01:00
void structmember5 ( ) {
2010-06-18 07:19:26 +02:00
checkStructMemberUsage ( " struct AB \n "
" { \n "
" int a; \n "
" int b; \n "
" void reset() \n "
" { \n "
" a = 1; \n "
" b = 2; \n "
" } \n "
" }; \n "
" \n "
" void foo() \n "
" { \n "
" struct AB ab; \n "
" ab.reset(); \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2009-06-05 02:39:36 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2008-12-18 22:28:57 +01:00
}
2009-10-17 17:36:55 +02:00
2014-11-20 14:20:09 +01:00
void structmember6 ( ) {
2010-06-18 07:19:26 +02:00
checkStructMemberUsage ( " struct AB \n "
" { \n "
" int a; \n "
" int b; \n "
" }; \n "
" \n "
" void foo(char *buf) \n "
" { \n "
" struct AB *ab = (struct AB *)&buf[10]; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2010-06-18 07:19:26 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
checkStructMemberUsage ( " struct AB \n "
" { \n "
" int a; \n "
" int b; \n "
" }; \n "
" \n "
" void foo(char *buf) \n "
" { \n "
" struct AB *ab = (AB *)&buf[10]; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2009-10-17 19:31:14 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2009-10-17 17:36:55 +02:00
}
2010-02-18 19:55:47 +01:00
2014-11-20 14:20:09 +01:00
void structmember7 ( ) {
2010-06-18 07:19:26 +02:00
checkStructMemberUsage ( " struct AB \n "
" { \n "
" int a; \n "
" int b; \n "
" }; \n "
" \n "
" void foo(struct AB *ab) \n "
" { \n "
" ab->a = 0; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2010-06-18 07:19:26 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
checkStructMemberUsage ( " struct AB \n "
" { \n "
" int a; \n "
" int b; \n "
" }; \n "
" \n "
" void foo(struct AB _shuge *ab) \n "
" { \n "
" ab->a = 0; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2010-04-09 19:55:41 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2014-11-20 14:20:09 +01:00
void structmember8 ( ) {
2010-06-18 07:19:26 +02:00
checkStructMemberUsage ( " struct AB \n "
" { \n "
" int a; \n "
" int b; \n "
" }; \n "
" \n "
" void foo(char *ab) \n "
" { \n "
" ((AB *)ab)->b = 0; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2010-04-09 19:55:41 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2014-11-20 14:20:09 +01:00
void structmember9 ( ) {
2010-09-04 11:21:34 +02:00
checkStructMemberUsage ( " struct base { \n "
" int a; \n "
" }; \n "
" \n "
" struct derived : public base { "
2013-03-20 15:36:16 +01:00
" } " ) ;
2010-09-04 11:21:34 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2014-11-20 14:20:09 +01:00
void structmember10 ( ) {
2010-12-05 18:33:53 +01:00
// Fred may have some useful side-effects
checkStructMemberUsage ( " struct abc { \n "
" Fred fred; \n "
2013-03-20 15:36:16 +01:00
" }; " ) ;
2010-12-05 18:33:53 +01:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2014-11-20 14:20:09 +01:00
void structmember11 ( ) { // #4168
2012-11-18 15:24:47 +01:00
checkStructMemberUsage ( " struct abc { int x; }; \n "
" struct abc s = {0}; \n "
2013-03-20 15:36:16 +01:00
" void f() { do_something(&s); } " ) ;
2012-11-18 15:24:47 +01:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
checkStructMemberUsage ( " struct abc { int x; }; \n "
" struct abc s = {0}; \n "
2013-03-20 15:36:16 +01:00
" void f() { } " ) ;
2012-11-18 15:24:47 +01:00
TODO_ASSERT_EQUALS ( " abc::x is not used " , " " , errout . str ( ) ) ;
2015-12-17 14:08:24 +01:00
}
void structmember12 ( ) { // #7179
checkStructMemberUsage ( " #include <stdio.h> \n "
2015-12-17 15:40:54 +01:00
" struct \n "
" { \n "
" union \n "
" { \n "
" struct \n "
" { \n "
" int a; \n "
" } struct1; \n "
" }; \n "
" } var = {0}; \n "
" int main(int argc, char *argv[]) \n "
" { \n "
2017-05-18 21:52:31 +02:00
" printf( \" var.struct1.a = %d \" , var.struct1.a); \n "
2015-12-17 15:40:54 +01:00
" return 1; \n "
2021-02-20 12:58:42 +01:00
" } " ) ;
2015-12-17 14:08:24 +01:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2012-11-18 15:24:47 +01:00
}
2016-09-05 17:27:12 +02:00
void structmember13 ( ) { // #3088 - struct members required by hardware
checkStructMemberUsage ( " struct S { \n "
" int x; \n "
" } __attribute__((packed)); " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2017-11-12 22:33:17 +01:00
void structmember14 ( ) { // #6508
checkStructMemberUsage ( " struct bstr { char *bstart; size_t len; }; \n "
" struct bstr bstr0(void) { \n "
" return (struct bstr){ \" hello \" ,6}; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2020-06-30 10:59:57 +02:00
void structmember15 ( ) { // #3088
std : : list < Directive > directives ;
directives . emplace_back ( " test.cpp " , 1 , " #pragma pack(1) " ) ;
checkStructMemberUsage ( " \n struct Foo { int x; int y; }; " , & directives ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2014-11-20 14:20:09 +01:00
void structmember_extern ( ) {
2010-04-17 11:16:05 +02:00
// extern struct => no false positive
2010-06-18 07:19:26 +02:00
checkStructMemberUsage ( " extern struct AB \n "
" { \n "
" int a; \n "
" int b; \n "
" } ab; \n "
" \n "
" void foo() \n "
" { \n "
" ab.b = 0; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2010-04-17 11:16:05 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
// global linkage => no false positive
2010-06-18 07:19:26 +02:00
checkStructMemberUsage ( " struct AB \n "
" { \n "
" int a; \n "
" int b; \n "
" } ab; \n "
" \n "
" void foo() \n "
" { \n "
" ab.b = 0; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2010-04-17 11:16:05 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
// static linkage => error message
2010-06-18 07:19:26 +02:00
checkStructMemberUsage ( " static struct AB \n "
" { \n "
" int a; \n "
" int b; \n "
" } ab; \n "
" \n "
" void foo() \n "
" { \n "
" ab.b = 0; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2015-09-22 16:38:23 +02:00
ASSERT_EQUALS ( " [test.cpp:3]: (style) struct member 'AB::a' is never used. \n " , errout . str ( ) ) ;
2020-04-08 18:09:20 +02:00
checkStructMemberUsage ( " struct A \n "
2020-04-08 22:39:17 +02:00
" { \n "
" static const int a = 0; \n "
" }; \n "
" \n "
" int foo() \n "
" { \n "
" return A::a; \n "
" } " ) ;
2020-04-08 18:09:20 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2010-04-17 11:16:05 +02:00
}
2016-08-02 18:50:04 +02:00
void structmember_sizeof ( ) {
checkStructMemberUsage ( " struct Header { \n "
" uint8_t message_type; \n "
" } \n "
" \n "
" input.skip(sizeof(Header)); " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
checkStructMemberUsage ( " struct Header { \n "
" uint8_t message_type; \n "
" } \n "
" \n "
" input.skip(sizeof(struct Header)); " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2021-10-30 19:34:46 +02:00
void structmember16 ( ) {
checkStructMemberUsage ( " struct S { \n "
" static const int N = 128; \n " // <- used
" char E[N]; \n " // <- not used
" }; \n " ) ;
ASSERT_EQUALS ( " [test.cpp:3]: (style) struct member 'S::E' is never used. \n " , errout . str ( ) ) ;
}
2021-12-18 22:55:52 +01:00
void structmember17 ( ) { // #10591
checkStructMemberUsage ( " struct tagT { int i; }; \n "
" void f() { \n "
" struct tagT t{}; \n "
" t.i = 0; \n " // <- used
" g(t); \n "
" }; \n " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
checkStructMemberUsage ( " typedef struct tagT { int i; } typeT; \n "
" void f() { \n "
" struct typeT t{}; \n "
" t.i = 0; \n " // <- used
" g(t); \n "
" }; \n " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2021-12-21 10:24:38 +01:00
checkStructMemberUsage ( " struct T { int i; }; \n "
" void f() { \n "
" struct T t{}; \n "
" t.i = 0; \n " // <- used
" g(t); \n "
" }; \n " ) ;
TODO_ASSERT_EQUALS ( " " , " [test.cpp:1]: (style) struct member 'T::i' is never used. \n " , errout . str ( ) ) ; // due to removeMacroInClassDef()
2021-12-18 22:55:52 +01:00
}
2022-02-02 19:28:16 +01:00
void structmember18 ( ) { // #10684
checkStructMemberUsage ( " struct S { uint8_t padding[500]; }; \n "
" static S s = { 0 }; \n "
" uint8_t f() { \n "
" uint8_t* p = (uint8_t*)&s; \n "
" return p[10]; \n "
" }; \n " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
checkStructMemberUsage ( " struct S { uint8_t padding[500]; }; \n "
" uint8_t f(const S& s) { \n "
" std::cout << &s; \n "
" auto p = reinterpret_cast<const uint8_t*>(&s); \n "
" return p[10]; \n "
" }; \n " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2021-11-29 07:34:39 +01:00
void functionVariableUsage_ ( const char * file , int line , const char code [ ] , const char filename [ ] = " test.cpp " ) {
2010-02-18 18:45:13 +01:00
// Clear the error buffer..
errout . str ( " " ) ;
2010-12-01 18:00:55 +01:00
// Tokenize..
Tokenizer tokenizer ( & settings , this ) ;
std : : istringstream istr ( code ) ;
2021-11-29 07:34:39 +01:00
ASSERT_LOC ( tokenizer . tokenize ( istr , filename ) , file , line ) ;
2010-06-18 07:19:26 +02:00
2010-02-18 18:45:13 +01:00
// Check for unused variables..
2011-08-19 20:35:25 +02:00
CheckUnusedVar checkUnusedVar ( & tokenizer , & settings , this ) ;
checkUnusedVar . checkFunctionVariableUsage ( ) ;
2010-02-18 18:45:13 +01:00
}
2014-11-20 14:20:09 +01:00
void localvar1 ( ) {
2021-05-13 20:21:02 +02:00
// extracttests.disable
2010-02-18 18:45:13 +01:00
functionVariableUsage ( " void foo() \n "
" { \n "
" int i = 0; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-11-01 18:40:20 +01:00
ASSERT_EQUALS ( " [test.cpp:3]: (style) Variable 'i' is assigned a value that is never used. \n " , errout . str ( ) ) ;
2010-04-15 18:44:52 +02:00
2010-04-29 07:10:50 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
" int i(0); \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-11-01 18:40:20 +01:00
ASSERT_EQUALS ( " [test.cpp:3]: (style) Variable 'i' is assigned a value that is never used. \n " , errout . str ( ) ) ;
2010-04-29 07:10:50 +02:00
2010-07-07 08:50:34 +02:00
// if a is undefined then Cppcheck can't determine if "int i(a)" is a
// * variable declaration
// * function declaration
2010-05-01 09:26:47 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
" int i(a); \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-11-01 18:40:20 +01:00
ASSERT_EQUALS ( " [test.cpp:3]: (style) Variable 'i' is assigned a value that is never used. \n " , errout . str ( ) ) ;
2010-05-01 09:26:47 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
" int j = 0; \n "
" int i(j); \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-11-01 18:40:20 +01:00
ASSERT_EQUALS ( " [test.cpp:4]: (style) Variable 'i' is assigned a value that is never used. \n " , errout . str ( ) ) ;
2010-05-01 09:26:47 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
" int j = 0; \n "
" int & i = j; \n "
2012-09-02 18:50:17 +02:00
" x(j); \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2018-12-13 18:52:56 +01:00
ASSERT_EQUALS ( " [test.cpp:4]: (style) Variable 'i' is assigned a value that is never used. \n " , errout . str ( ) ) ;
2010-05-01 09:26:47 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
" int j = 0; \n "
" const int & i = j; \n "
2012-09-02 18:50:17 +02:00
" x(j); \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2018-12-13 18:52:56 +01:00
ASSERT_EQUALS ( " [test.cpp:4]: (style) Variable 'i' is assigned a value that is never used. \n " , errout . str ( ) ) ;
2010-05-01 09:26:47 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
" int j = 0; \n "
" int & i(j); \n "
2012-09-02 18:50:17 +02:00
" x(j); \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-11-01 18:40:20 +01:00
ASSERT_EQUALS ( " [test.cpp:4]: (style) Variable 'i' is assigned a value that is never used. \n " , errout . str ( ) ) ;
2010-05-01 09:26:47 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
" int j = 0; \n "
" const int & i(j); \n "
2012-09-02 18:50:17 +02:00
" x(j); \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-11-01 18:40:20 +01:00
ASSERT_EQUALS ( " [test.cpp:4]: (style) Variable 'i' is assigned a value that is never used. \n " , errout . str ( ) ) ;
2010-05-01 09:26:47 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
2018-12-13 18:52:56 +01:00
" int * j = Data; \n "
2010-05-01 09:26:47 +02:00
" int * i(j); \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-11-01 18:40:20 +01:00
ASSERT_EQUALS ( " [test.cpp:4]: (style) Variable 'i' is assigned a value that is never used. \n " , errout . str ( ) ) ;
2010-05-01 09:26:47 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
2018-12-13 18:52:56 +01:00
" int * j = Data; \n "
2010-05-01 09:26:47 +02:00
" const int * i(j); \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-11-01 18:40:20 +01:00
ASSERT_EQUALS ( " [test.cpp:4]: (style) Variable 'i' is assigned a value that is never used. \n " , errout . str ( ) ) ;
2010-05-01 09:26:47 +02:00
2010-04-15 18:44:52 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
" bool i = false; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-11-01 18:40:20 +01:00
ASSERT_EQUALS ( " [test.cpp:3]: (style) Variable 'i' is assigned a value that is never used. \n " , errout . str ( ) ) ;
2010-04-15 18:44:52 +02:00
2010-04-29 07:10:50 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
" bool i = true; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-11-01 18:40:20 +01:00
ASSERT_EQUALS ( " [test.cpp:3]: (style) Variable 'i' is assigned a value that is never used. \n " , errout . str ( ) ) ;
2010-04-29 07:10:50 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
" char *i; \n "
" i = fgets(); \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-11-01 18:40:20 +01:00
ASSERT_EQUALS ( " [test.cpp:4]: (style) Variable 'i' is assigned a value that is never used. \n " , errout . str ( ) ) ;
2010-04-29 07:10:50 +02:00
// undefined variables are not reported because they may be classes with constructors
functionVariableUsage ( " undefined foo() \n "
" { \n "
" undefined i = 0; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2018-12-13 18:52:56 +01:00
// ? ASSERT_EQUALS("", errout.str());
2010-04-29 07:10:50 +02:00
2012-06-22 15:59:41 +02:00
functionVariableUsage ( " undefined foo() \n "
" { \n "
" undefined i = 0; \n "
" } \n " ,
" test.c " ) ;
2012-11-01 18:40:20 +01:00
ASSERT_EQUALS ( " [test.c:3]: (style) Variable 'i' is assigned a value that is never used. \n " , errout . str ( ) ) ;
2012-06-22 15:59:41 +02:00
2010-04-29 07:10:50 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
" int i = undefined; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-11-01 18:40:20 +01:00
ASSERT_EQUALS ( " [test.cpp:3]: (style) Variable 'i' is assigned a value that is never used. \n " , errout . str ( ) ) ;
2010-04-29 07:10:50 +02:00
2010-04-15 18:44:52 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
2018-12-13 18:52:56 +01:00
" int * i = Data; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-11-01 18:40:20 +01:00
ASSERT_EQUALS ( " [test.cpp:3]: (style) Variable 'i' is assigned a value that is never used. \n " , errout . str ( ) ) ;
2010-04-15 18:44:52 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
2018-12-13 18:52:56 +01:00
" void * i = Data; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-11-01 18:40:20 +01:00
ASSERT_EQUALS ( " [test.cpp:3]: (style) Variable 'i' is assigned a value that is never used. \n " , errout . str ( ) ) ;
2010-04-29 07:10:50 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
2018-12-13 18:52:56 +01:00
" const void * i = Data; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-11-01 18:40:20 +01:00
ASSERT_EQUALS ( " [test.cpp:3]: (style) Variable 'i' is assigned a value that is never used. \n " , errout . str ( ) ) ;
2010-04-29 07:10:50 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
2018-12-13 18:52:56 +01:00
" struct S * i = DATA; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-11-01 18:40:20 +01:00
ASSERT_EQUALS ( " [test.cpp:3]: (style) Variable 'i' is assigned a value that is never used. \n " , errout . str ( ) ) ;
2010-04-29 07:10:50 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
2018-12-13 18:52:56 +01:00
" const struct S * i = DATA; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-11-01 18:40:20 +01:00
ASSERT_EQUALS ( " [test.cpp:3]: (style) Variable 'i' is assigned a value that is never used. \n " , errout . str ( ) ) ;
2010-04-29 07:10:50 +02:00
2010-05-01 09:26:47 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
" struct S & i = j; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-11-01 18:40:20 +01:00
ASSERT_EQUALS ( " [test.cpp:3]: (style) Variable 'i' is assigned a value that is never used. \n " , errout . str ( ) ) ;
2010-05-01 09:26:47 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
" const struct S & i = j; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-11-01 18:40:20 +01:00
ASSERT_EQUALS ( " [test.cpp:3]: (style) Variable 'i' is assigned a value that is never used. \n " , errout . str ( ) ) ;
2010-05-01 09:26:47 +02:00
2010-04-29 07:10:50 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
2018-12-13 18:52:56 +01:00
" undefined * i = X; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-11-01 18:40:20 +01:00
ASSERT_EQUALS ( " [test.cpp:3]: (style) Variable 'i' is assigned a value that is never used. \n " , errout . str ( ) ) ;
2010-04-29 07:10:50 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
" int i = 0; \n "
" int j = i; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-11-01 18:40:20 +01:00
ASSERT_EQUALS ( " [test.cpp:4]: (style) Variable 'j' is assigned a value that is never used. \n " , errout . str ( ) ) ;
2010-04-30 18:11:51 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
" int i[10] = { 0 }; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-11-01 18:40:20 +01:00
ASSERT_EQUALS ( " [test.cpp:3]: (style) Variable 'i' is assigned a value that is never used. \n " , errout . str ( ) ) ;
2010-04-30 18:11:51 +02:00
functionVariableUsage ( " void foo(int n) \n "
" { \n "
" int i[n] = { 0 }; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-11-01 18:40:20 +01:00
ASSERT_EQUALS ( " [test.cpp:3]: (style) Variable 'i' is assigned a value that is never used. \n " , errout . str ( ) ) ;
2010-04-30 18:11:51 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
" char i[10] = \" 123456789 \" ; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-11-01 18:40:20 +01:00
ASSERT_EQUALS ( " [test.cpp:3]: (style) Variable 'i' is assigned a value that is never used. \n " , errout . str ( ) ) ;
2010-04-30 18:11:51 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
" char *i = \" 123456789 \" ; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-11-01 18:40:20 +01:00
ASSERT_EQUALS ( " [test.cpp:3]: (style) Variable 'i' is assigned a value that is never used. \n " , errout . str ( ) ) ;
2012-09-02 18:50:17 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
" int i = 0; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-11-01 18:40:20 +01:00
ASSERT_EQUALS ( " [test.cpp:3]: (style) Variable 'i' is assigned a value that is never used. \n " , errout . str ( ) ) ;
2012-09-04 13:06:04 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
" int i = 0,code=10; \n "
" for(i = 0; i < 10; i++) { \n "
" std::cout<<code<<std::endl; \n "
" code += 2; \n "
" } \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-09-04 13:06:04 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
functionVariableUsage ( " void foo() \n "
" { \n "
" int i = 0,code=10,d=10; \n "
" for(i = 0; i < 10; i++) { \n "
" std::cout<<code<<std::endl; \n "
" code += 2; \n "
2012-11-01 18:40:20 +01:00
" d = code; \n "
2012-09-04 13:06:04 +02:00
" } \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2018-12-16 11:18:37 +01:00
ASSERT_EQUALS ( " [test.cpp:3]: (style) Variable 'd' is assigned a value that is never used. \n "
" [test.cpp:7]: (style) Variable 'd' is assigned a value that is never used. \n " ,
errout . str ( ) ) ;
2012-09-04 13:06:04 +02:00
2012-11-28 06:11:33 +01:00
functionVariableUsage ( " void foo() \n "
" { \n "
" int i = 0,code=10,d=10; \n "
" for(i = 0; i < 10; i++) { \n "
" std::cout<<code<<std::endl; \n "
" code += 2; \n "
" g(d); \n "
" d = code; \n "
" } \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-11-28 06:11:33 +01:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2012-12-04 21:39:51 +01:00
functionVariableUsage ( " void foo() \n "
" { \n "
" int i = 0,code=10,d=10; \n "
" for(i = 0; i < 10; i++) { \n "
" std::cout<<code<<std::endl; \n "
" code += 2; \n "
" if (i == 3) { \n "
" return d; \n "
" } \n "
" d = code; \n "
" } \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-12-04 21:39:51 +01:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
functionVariableUsage ( " void foo() \n "
" { \n "
" int i = 0,a=10,b=20; \n "
" for(i = 0; i < 10; i++) { \n "
" std::cout<<a<<std::endl; \n "
" int tmp=a; \n "
" a=b; \n "
" b=tmp; \n "
" } \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-12-04 21:39:51 +01:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2012-09-04 13:06:04 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
" int code=10; \n "
" while(code < 20) { \n "
" std::cout<<code<<std::endl; \n "
" code += 2; \n "
" } \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-09-04 13:06:04 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
functionVariableUsage ( " void foo() \n "
" { \n "
" int code=10,d=10; \n "
" while(code < 20) { \n "
" std::cout<<code<<std::endl; \n "
" code += 2; \n "
" d += code; \n "
" } \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2018-12-27 17:27:51 +01:00
ASSERT_EQUALS ( " [test.cpp:3]: (style) Variable 'd' is assigned a value that is never used. \n "
" [test.cpp:7]: (style) Variable 'd' is assigned a value that is never used. \n " , errout . str ( ) ) ;
2012-09-04 13:06:04 +02:00
2012-11-28 06:11:33 +01:00
functionVariableUsage ( " void foo() \n "
" { \n "
" int code=10,d=10; \n "
" while(code < 20) { \n "
" std::cout<<code<<std::endl; \n "
" code += 2; \n "
" g(d); \n "
" d += code; \n "
" } \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-11-28 06:11:33 +01:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2012-12-04 21:39:51 +01:00
functionVariableUsage ( " void foo() \n "
" { \n "
" int code=10,d=10; \n "
" while(code < 20) { \n "
" std::cout<<code<<std::endl; \n "
" code += 2; \n "
" if (i == 3) { \n "
" return d; \n "
" } \n "
" d += code; \n "
" } \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-12-04 21:39:51 +01:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
functionVariableUsage ( " void foo() \n "
" { \n "
" int a=10,b=20; \n "
" while(a != 30) { \n "
" std::cout<<a<<std::endl; \n "
" int tmp=a; \n "
" a=b; \n "
" b=tmp; \n "
" } \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-12-04 21:39:51 +01:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2012-11-28 06:11:33 +01:00
functionVariableUsage ( " void foo() \n "
" { \n "
" int code=10; \n "
" do { \n "
" std::cout<<code<<std::endl; \n "
" code += 2; \n "
2012-12-03 21:49:53 +01:00
" } while(code < 20); \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-11-28 06:11:33 +01:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
functionVariableUsage ( " void foo() \n "
" { \n "
" int code=10,d=10; \n "
" do { \n "
" std::cout<<code<<std::endl; \n "
" code += 2; \n "
" d += code; \n "
2012-12-03 21:49:53 +01:00
" } while(code < 20); \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2018-12-27 17:27:51 +01:00
ASSERT_EQUALS ( " [test.cpp:3]: (style) Variable 'd' is assigned a value that is never used. \n "
" [test.cpp:7]: (style) Variable 'd' is assigned a value that is never used. \n " , errout . str ( ) ) ;
2012-11-28 06:11:33 +01:00
functionVariableUsage ( " void foo() \n "
" { \n "
" int code=10,d=10; \n "
" do { \n "
" std::cout<<code<<std::endl; \n "
" code += 2; \n "
" g(d); \n "
" d += code; \n "
2012-12-03 21:49:53 +01:00
" } while(code < 20); \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-12-04 21:39:51 +01:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
functionVariableUsage ( " void foo() \n "
" { \n "
" int code=10,d=10; \n "
" do { \n "
" std::cout<<code<<std::endl; \n "
" code += 2; \n "
" if (i == 3) { \n "
" return d; \n "
" } \n "
" d += code; \n "
" } while(code < 20); \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-12-04 21:39:51 +01:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
functionVariableUsage ( " void foo() \n "
" { \n "
" int a=10,b=20; \n "
" do { \n "
" std::cout<<a<<std::endl; \n "
" int tmp=a; \n "
" a=b; \n "
" b=tmp; \n "
2012-12-07 01:48:27 +01:00
" } while( a!=30 ); \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-11-28 06:11:33 +01:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2012-09-04 13:06:04 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
" int code=10; \n "
" for(int i=0; i < 10; i++) { \n "
" if(true) { \n "
" std::cout<<code<<std::endl; \n "
" code += 2; \n "
" } \n "
" } \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-09-04 13:06:04 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
functionVariableUsage ( " void foo() \n "
" { \n "
" int code=10; \n "
" for(int i=0; i < 10; i++) { \n "
" if(true) { \n "
" std::cout<<code<<std::endl; \n "
" } \n "
" code += 2; \n "
" } \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-09-04 13:06:04 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
functionVariableUsage ( " void foo() \n "
" { \n "
" int code=10; \n "
" while(code < 20) { \n "
" if(true) { \n "
" std::cout<<code<<std::endl; \n "
" code += 2; \n "
" } \n "
" } \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-09-04 13:06:04 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2012-11-28 06:11:33 +01:00
functionVariableUsage ( " void foo() \n "
" { \n "
" int code=10; \n "
" do { \n "
" if(true) { \n "
" std::cout<<code<<std::endl; \n "
" code += 2; \n "
" } \n "
2012-12-03 21:49:53 +01:00
" } while(code < 20); \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-11-28 06:11:33 +01:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2014-08-03 19:13:37 +02:00
functionVariableUsage ( " void foo(int j = 0) { \n " // #5985 - default function parameters should not affect checking results
" int i = 0; \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:2]: (style) Variable 'i' is assigned a value that is never used. \n " , errout . str ( ) ) ;
2021-05-13 20:21:02 +02:00
// extracttests.enable
2010-02-18 18:45:13 +01:00
}
2014-11-20 14:20:09 +01:00
void localvar2 ( ) {
2021-05-13 21:31:44 +02:00
// extracttests.disable: uninitialized variables and stuff
2021-05-13 20:21:02 +02:00
2010-04-15 18:44:52 +02:00
functionVariableUsage ( " int foo() \n "
2010-02-18 18:45:13 +01:00
" { \n "
" int i; \n "
" return i; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-11-01 18:40:20 +01:00
ASSERT_EQUALS ( " [test.cpp:3]: (style) Variable 'i' is not assigned a value. \n " , errout . str ( ) ) ;
2010-04-15 18:44:52 +02:00
functionVariableUsage ( " bool foo() \n "
" { \n "
" bool i; \n "
" return i; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-11-01 18:40:20 +01:00
ASSERT_EQUALS ( " [test.cpp:3]: (style) Variable 'i' is not assigned a value. \n " , errout . str ( ) ) ;
2010-04-29 07:10:50 +02:00
// undefined variables are not reported because they may be classes with constructors
functionVariableUsage ( " undefined foo() \n "
" { \n "
" undefined i; \n "
" return i; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2010-06-18 07:19:26 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2010-04-29 07:10:50 +02:00
2012-06-22 15:59:41 +02:00
functionVariableUsage ( " undefined foo() \n "
" { \n "
" undefined i; \n "
" return i; \n "
" } \n " ,
" test.c " ) ;
2012-11-01 18:40:20 +01:00
ASSERT_EQUALS ( " [test.c:3]: (style) Variable 'i' is not assigned a value. \n " , errout . str ( ) ) ;
2012-06-22 15:59:41 +02:00
2010-04-29 07:10:50 +02:00
functionVariableUsage ( " undefined *foo() \n "
" { \n "
" undefined * i; \n "
" return i; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-11-01 18:40:20 +01:00
ASSERT_EQUALS ( " [test.cpp:3]: (style) Variable 'i' is not assigned a value. \n " , errout . str ( ) ) ;
2010-04-29 07:10:50 +02:00
functionVariableUsage ( " int *foo() \n "
" { \n "
" int * i; \n "
" return i; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-11-01 18:40:20 +01:00
ASSERT_EQUALS ( " [test.cpp:3]: (style) Variable 'i' is not assigned a value. \n " , errout . str ( ) ) ;
2010-04-29 07:10:50 +02:00
functionVariableUsage ( " const int *foo() \n "
" { \n "
" const int * i; \n "
" return i; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-11-01 18:40:20 +01:00
ASSERT_EQUALS ( " [test.cpp:3]: (style) Variable 'i' is not assigned a value. \n " , errout . str ( ) ) ;
2010-04-29 07:10:50 +02:00
functionVariableUsage ( " struct S *foo() \n "
" { \n "
" struct S * i; \n "
" return i; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-11-01 18:40:20 +01:00
ASSERT_EQUALS ( " [test.cpp:3]: (style) Variable 'i' is not assigned a value. \n " , errout . str ( ) ) ;
2010-04-29 07:10:50 +02:00
functionVariableUsage ( " const struct S *foo() \n "
" { \n "
" const struct S * i; \n "
" return i; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-11-01 18:40:20 +01:00
ASSERT_EQUALS ( " [test.cpp:3]: (style) Variable 'i' is not assigned a value. \n " , errout . str ( ) ) ;
2010-04-29 07:10:50 +02:00
2010-04-30 18:11:51 +02:00
// assume f() can write a
2010-04-29 07:10:50 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
" int a[10]; \n "
" f(a[0]); \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2010-04-30 18:11:51 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2010-04-29 07:10:50 +02:00
2010-04-30 18:11:51 +02:00
// assume f() can write a
2010-04-29 07:10:50 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
" int a[10]; \n "
" f(a[0], 0); \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2010-04-30 18:11:51 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2010-04-29 07:10:50 +02:00
2010-04-30 18:11:51 +02:00
// assume f() can write a
2010-04-29 07:10:50 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
" int a[10]; \n "
" f(0, a[0]); \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2010-04-30 18:11:51 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2010-04-29 07:10:50 +02:00
2010-04-30 18:11:51 +02:00
// assume f() can write a
2010-04-29 07:10:50 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
" int a[10]; \n "
" f(0, a[0], 0); \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2010-04-30 18:11:51 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
// f() can not write a (not supported yet)
functionVariableUsage ( " void f(const int & i) { } \n "
" void foo() \n "
" { \n "
" int a[10]; \n "
" f(a[0]); \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-11-01 18:40:20 +01:00
TODO_ASSERT_EQUALS ( " [test.cpp:4]: (style) Variable 'a' is not assigned a value. \n " ,
2011-01-30 12:54:19 +01:00
" " , errout . str ( ) ) ;
2010-04-30 18:11:51 +02:00
// f() writes a
functionVariableUsage ( " void f(int & i) { } \n "
" void foo() \n "
" { \n "
" int a[10]; \n "
" f(a[0]); \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2010-04-30 18:11:51 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2017-02-28 22:04:05 +01:00
functionVariableUsage ( " void f(int * i); \n "
" void foo() \n "
" { \n "
" int a[10]; \n "
" f(a+1); \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2021-05-13 21:31:44 +02:00
// extracttests.enable
2010-02-18 18:45:13 +01:00
}
2014-11-20 14:20:09 +01:00
void localvar3 ( ) {
2021-05-13 20:21:02 +02:00
functionVariableUsage ( " void foo(int abc) \n "
2010-02-18 18:45:13 +01:00
" { \n "
" int i; \n "
" if ( abc ) \n "
" ; \n "
" else i = 0; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-11-01 18:40:20 +01:00
ASSERT_EQUALS ( " [test.cpp:6]: (style) Variable 'i' is assigned a value that is never used. \n " , errout . str ( ) ) ;
2010-02-18 18:45:13 +01:00
}
2014-11-20 14:20:09 +01:00
void localvar4 ( ) {
2010-02-18 18:45:13 +01:00
functionVariableUsage ( " void foo() \n "
" { \n "
" int i = 0; \n "
" f(i); \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2010-06-18 07:19:26 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2010-04-29 07:10:50 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
" int i = 0; \n "
" f(&i); \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2010-06-18 07:19:26 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2010-02-18 18:45:13 +01:00
}
2014-11-20 14:20:09 +01:00
void localvar5 ( ) {
2010-02-18 18:45:13 +01:00
functionVariableUsage ( " void foo() \n "
" { \n "
" int a = 0; \n "
" b = (char)a; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2010-06-18 07:19:26 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2010-02-18 18:45:13 +01:00
}
2014-11-20 14:20:09 +01:00
void localvar6 ( ) {
2021-05-14 19:07:30 +02:00
functionVariableUsage ( " void foo() { \n "
2010-04-29 07:10:50 +02:00
" int b[10]; \n "
" for (int i=0;i<10;++i) \n "
" b[i] = 0; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2021-05-14 19:07:30 +02:00
ASSERT_EQUALS ( " [test.cpp:4]: (style) Variable 'b[i]' is assigned a value that is never used. \n " , errout . str ( ) ) ;
2010-04-29 07:10:50 +02:00
2021-05-14 19:07:30 +02:00
functionVariableUsage ( " void foo() { \n "
2010-03-16 19:25:10 +01:00
" int a = 0; \n "
" int b[10]; \n "
" for (int i=0;i<10;++i) \n "
" b[i] = ++a; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2021-05-14 19:07:30 +02:00
ASSERT_EQUALS ( " [test.cpp:5]: (style) Variable 'b[i]' is assigned a value that is never used. \n " , errout . str ( ) ) ;
functionVariableUsage ( " void foo() { \n "
" int b[10]; \n "
" for (int i=0;i<10;++i) \n "
" *(b+i) = 0; \n "
" } " ) ;
TODO_ASSERT_EQUALS ( " [test.cpp:4]: (style) Variable '*(b+i)' is assigned a value that is never used. \n " , " " , errout . str ( ) ) ;
2010-03-16 19:25:10 +01:00
}
2014-11-20 14:20:09 +01:00
void localvar8 ( ) {
2010-04-15 18:44:52 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
" int i; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2010-04-24 09:45:03 +02:00
ASSERT_EQUALS ( " [test.cpp:3]: (style) Unused variable: i \n " , errout . str ( ) ) ;
2010-04-15 18:44:52 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
" int i[2]; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2010-04-24 09:45:03 +02:00
ASSERT_EQUALS ( " [test.cpp:3]: (style) Unused variable: i \n " , errout . str ( ) ) ;
2010-04-15 18:44:52 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
" void * i; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2010-04-24 09:45:03 +02:00
ASSERT_EQUALS ( " [test.cpp:3]: (style) Unused variable: i \n " , errout . str ( ) ) ;
2010-04-15 18:44:52 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
" const void * i; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2010-04-24 09:45:03 +02:00
ASSERT_EQUALS ( " [test.cpp:3]: (style) Unused variable: i \n " , errout . str ( ) ) ;
2010-04-15 18:44:52 +02:00
2021-05-13 20:21:02 +02:00
// extracttests.start: struct A {int x;};
2010-04-15 18:44:52 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
" A * i; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2010-04-24 09:45:03 +02:00
ASSERT_EQUALS ( " [test.cpp:3]: (style) Unused variable: i \n " , errout . str ( ) ) ;
2010-04-15 18:44:52 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
" struct A * i; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2010-04-24 09:45:03 +02:00
ASSERT_EQUALS ( " [test.cpp:3]: (style) Unused variable: i \n " , errout . str ( ) ) ;
2010-04-15 18:44:52 +02:00
2010-04-29 07:10:50 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
" const struct A * i; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2010-04-29 07:10:50 +02:00
ASSERT_EQUALS ( " [test.cpp:3]: (style) Unused variable: i \n " , errout . str ( ) ) ;
2010-04-15 18:44:52 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
" int * i[2]; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2011-01-30 12:54:19 +01:00
TODO_ASSERT_EQUALS ( " [test.cpp:3]: (style) Unused variable: i \n " , " " , errout . str ( ) ) ;
2010-04-15 18:44:52 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
" const int * i[2]; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2011-01-30 12:54:19 +01:00
TODO_ASSERT_EQUALS ( " [test.cpp:3]: (style) Unused variable: i \n " , " " , errout . str ( ) ) ;
2010-04-15 18:44:52 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
" void * i[2]; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2011-01-30 12:54:19 +01:00
TODO_ASSERT_EQUALS ( " [test.cpp:3]: (style) Unused variable: i \n " , " " , errout . str ( ) ) ;
2010-04-15 18:44:52 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
" const void * i[2]; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2011-01-30 12:54:19 +01:00
TODO_ASSERT_EQUALS ( " [test.cpp:3]: (style) Unused variable: i \n " , " " , errout . str ( ) ) ;
2010-04-15 18:44:52 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
2010-04-29 07:10:50 +02:00
" struct A * i[2]; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2011-01-30 12:54:19 +01:00
TODO_ASSERT_EQUALS ( " [test.cpp:3]: (style) Unused variable: i \n " , " " , errout . str ( ) ) ;
2010-04-15 18:44:52 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
2010-04-29 07:10:50 +02:00
" const struct A * i[2]; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2011-01-30 12:54:19 +01:00
TODO_ASSERT_EQUALS ( " [test.cpp:3]: (style) Unused variable: i \n " , " " , errout . str ( ) ) ;
2010-04-15 18:44:52 +02:00
2010-04-30 18:11:51 +02:00
functionVariableUsage ( " void foo(int n) \n "
" { \n "
" int i[n]; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2010-04-30 18:11:51 +02:00
ASSERT_EQUALS ( " [test.cpp:3]: (style) Unused variable: i \n " , errout . str ( ) ) ;
2010-04-15 18:44:52 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
2010-04-29 07:10:50 +02:00
" int i = 0; \n "
" int &j = i; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2018-12-13 18:52:56 +01:00
ASSERT_EQUALS ( " [test.cpp:4]: (style) Variable 'j' is assigned a value that is never used. \n " , errout . str ( ) ) ;
2010-04-15 18:44:52 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
2010-04-29 07:10:50 +02:00
" int i; \n "
" int &j = i; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2018-12-13 18:52:56 +01:00
ASSERT_EQUALS ( " [test.cpp:4]: (style) Variable 'j' is assigned a value that is never used. \n "
" [test.cpp:3]: (style) Unused variable: i \n " , errout . str ( ) ) ;
2010-04-15 18:44:52 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
2010-04-29 07:10:50 +02:00
" int i; \n "
" int &j = i; \n "
" j = 0; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2022-01-18 22:03:52 +01:00
TODO_ASSERT_EQUALS ( " [test.cpp:5]: (style) Variable 'i' is assigned a value that is never used. \n " ,
" " ,
errout . str ( ) ) ;
2010-04-15 18:44:52 +02:00
2012-12-29 12:45:37 +01:00
functionVariableUsage ( " double foo() \n "
" { \n "
" double i = 0.0; \n "
" const double j = i; \n "
" return j; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-12-29 12:45:37 +01:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2010-04-15 18:44:52 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
2010-04-29 07:10:50 +02:00
" A * i; \n "
" i->f(); \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2010-04-29 07:10:50 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2010-04-15 18:44:52 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
2010-04-29 07:10:50 +02:00
" char * i; \n "
" if (i); \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2010-04-29 07:10:50 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
functionVariableUsage ( " void foo() \n "
" { \n "
" char * i = 0; \n "
" if (i); \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2010-04-29 07:10:50 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
functionVariableUsage ( " void foo() \n "
" { \n "
" char * i = new char[10]; \n "
" if (i); \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2010-04-29 07:10:50 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2010-04-15 18:44:52 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
" char *i; \n "
" f(i); \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2010-04-15 18:44:52 +02:00
functionVariableUsage ( " int a; \n "
" void foo() \n "
" { \n "
" return &a; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2010-04-15 18:44:52 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2010-04-16 15:57:09 +02:00
functionVariableUsage ( " int a[10]; \n "
" void foo() \n "
" { \n "
" int *p = a; \n "
" for (int i = 0; i < 10; i++) \n "
" p[i] = 0; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2010-04-16 15:57:09 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2010-04-15 18:44:52 +02:00
functionVariableUsage ( " int a[10]; \n "
" void foo() \n "
" { \n "
" int *p = &a[0]; \n "
" for (int i = 0; i < 10; i++) \n "
" p[i] = 0; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2010-04-16 15:57:09 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2010-04-29 07:10:50 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
" int a[10]; \n "
" int x; \n "
" a[0] = 0; \n "
" x = a[0]; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-11-01 18:40:20 +01:00
ASSERT_EQUALS ( " [test.cpp:6]: (style) Variable 'x' is assigned a value that is never used. \n " , errout . str ( ) ) ;
2010-04-29 07:10:50 +02:00
2021-05-13 20:21:02 +02:00
// extracttests.start: int f();
2010-04-29 07:10:50 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
" int a, b, c; \n "
2010-05-05 19:34:03 +02:00
" a = b = c = f(); \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2018-12-13 18:52:56 +01:00
ASSERT_EQUALS ( " [test.cpp:4]: (style) Variable 'a' is assigned a value that is never used. \n " , errout . str ( ) ) ;
2010-04-29 07:10:50 +02:00
functionVariableUsage ( " int * foo() \n "
" { \n "
" return &undefined[0]; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2010-04-29 07:10:50 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2010-04-15 18:44:52 +02:00
}
2014-11-20 14:20:09 +01:00
void localvar9 ( ) {
2010-04-16 16:25:57 +02:00
// ticket #1605
functionVariableUsage ( " void foo() \n "
" { \n "
" int a[10]; \n "
" for (int i = 0; i < 10; ) \n "
" a[i++] = 0; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2022-01-18 22:03:52 +01:00
TODO_ASSERT_EQUALS ( " [test.cpp:5]: (style) Variable 'a' is assigned a value that is never used. \n " ,
" " ,
errout . str ( ) ) ;
2010-04-24 09:45:03 +02:00
}
2014-11-20 14:20:09 +01:00
void localvar10 ( ) {
2010-04-24 09:45:03 +02:00
functionVariableUsage ( " void foo(int x) \n "
" { \n "
" int i; \n "
" if (x) { \n "
" int i; \n "
" } else { \n "
" int i; \n "
" } \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2010-04-24 09:45:03 +02:00
ASSERT_EQUALS ( " [test.cpp:3]: (style) Unused variable: i \n "
" [test.cpp:5]: (style) Unused variable: i \n "
" [test.cpp:7]: (style) Unused variable: i \n " , errout . str ( ) ) ;
functionVariableUsage ( " void foo(int x) \n "
" { \n "
" int i; \n "
" if (x) \n "
" int i; \n "
" else \n "
" int i; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2010-04-24 09:45:03 +02:00
ASSERT_EQUALS ( " [test.cpp:3]: (style) Unused variable: i \n "
" [test.cpp:5]: (style) Unused variable: i \n "
" [test.cpp:7]: (style) Unused variable: i \n " , errout . str ( ) ) ;
functionVariableUsage ( " void foo(int x) \n "
" { \n "
" int i; \n "
" if (x) { \n "
" int i; \n "
" } else { \n "
" int i = 0; \n "
" } \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2018-12-13 18:52:56 +01:00
ASSERT_EQUALS ( " [test.cpp:7]: (style) Variable 'i' is assigned a value that is never used. \n "
" [test.cpp:3]: (style) Unused variable: i \n "
" [test.cpp:5]: (style) Unused variable: i \n " , errout . str ( ) ) ;
2010-04-24 09:45:03 +02:00
functionVariableUsage ( " void foo(int x) \n "
" { \n "
" int i; \n "
" if (x) { \n "
" int i; \n "
" } else { \n "
" int i; \n "
" } \n "
2018-12-13 18:52:56 +01:00
" i = 1; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-11-01 18:40:20 +01:00
ASSERT_EQUALS ( " [test.cpp:9]: (style) Variable 'i' is assigned a value that is never used. \n "
2010-04-24 09:45:03 +02:00
" [test.cpp:5]: (style) Unused variable: i \n "
" [test.cpp:7]: (style) Unused variable: i \n " , errout . str ( ) ) ;
2010-04-16 16:25:57 +02:00
}
2014-11-20 14:20:09 +01:00
void localvar11 ( ) {
2010-04-24 12:21:26 +02:00
functionVariableUsage ( " void foo(int x) \n "
" { \n "
" int a = 0; \n "
" if (x == 1) \n "
" { \n "
" a = 123; \n " // redundant assignment
" return; \n "
" } \n "
2018-12-13 18:52:56 +01:00
" x = a; \n " // redundant assignment
2013-03-20 15:36:16 +01:00
" } " ) ;
2018-12-13 18:52:56 +01:00
ASSERT_EQUALS ( " [test.cpp:6]: (style) Variable 'a' is assigned a value that is never used. \n "
" [test.cpp:9]: (style) Variable 'x' is assigned a value that is never used. \n " , errout . str ( ) ) ;
2010-04-24 12:21:26 +02:00
// The variable 'a' is initialized. But the initialized value is
// never used. It is only initialized for security reasons.
functionVariableUsage ( " void foo(int x) \n "
" { \n "
" int a = 0; \n "
" if (x == 1) \n "
" a = 123; \n "
" else if (x == 2) \n "
" a = 456; \n "
" else \n "
" return; \n "
" x = a; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2018-12-13 18:52:56 +01:00
ASSERT_EQUALS ( " [test.cpp:10]: (style) Variable 'x' is assigned a value that is never used. \n " , errout . str ( ) ) ;
2010-04-24 12:21:26 +02:00
}
2014-11-20 14:20:09 +01:00
void localvar12 ( ) {
2010-05-01 10:26:15 +02:00
// ticket #1574
functionVariableUsage ( " void foo() \n "
" { \n "
" int a, b, c, d, e, f; \n "
2018-12-13 18:52:56 +01:00
" a = b = c = d = e = f = 15; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2010-05-01 10:26:15 +02:00
ASSERT_EQUALS (
2012-11-01 18:40:20 +01:00
" [test.cpp:4]: (style) Variable 'a' is assigned a value that is never used. \n "
" [test.cpp:4]: (style) Variable 'b' is assigned a value that is never used. \n "
" [test.cpp:4]: (style) Variable 'c' is assigned a value that is never used. \n "
" [test.cpp:4]: (style) Variable 'd' is assigned a value that is never used. \n "
" [test.cpp:4]: (style) Variable 'e' is assigned a value that is never used. \n "
" [test.cpp:4]: (style) Variable 'f' is assigned a value that is never used. \n " ,
2010-05-01 11:54:04 +02:00
errout . str ( ) ) ;
2010-05-01 10:26:15 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
" int a, b, c = 0; \n "
" a = b = c; \n "
" \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2010-05-01 10:26:15 +02:00
TODO_ASSERT_EQUALS (
2012-11-01 18:40:20 +01:00
" [test.cpp:4]: (style) Variable 'a' is assigned a value that is never used. \n "
" [test.cpp:4]: (style) Variable 'b' is assigned a value that is never used. \n "
" [test.cpp:3]: (style) Variable 'c' is assigned a value that is never used. \n " ,
2011-01-30 12:54:19 +01:00
2012-11-01 18:40:20 +01:00
" [test.cpp:4]: (style) Variable 'a' is assigned a value that is never used. \n "
" [test.cpp:4]: (style) Variable 'b' is assigned a value that is never used. \n " ,
2010-05-01 11:54:04 +02:00
errout . str ( ) ) ;
2010-05-01 10:26:15 +02:00
}
2014-11-20 14:20:09 +01:00
void localvar13 ( ) { // ticket #1640
2021-05-13 20:21:02 +02:00
// extracttests.start: struct OBJECT { int ySize; };
2010-05-01 21:15:14 +02:00
functionVariableUsage ( " void foo( OBJECT *obj ) \n "
" { \n "
" int x; \n "
" x = obj->ySize / 8; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-11-01 18:40:20 +01:00
ASSERT_EQUALS ( " [test.cpp:4]: (style) Variable 'x' is assigned a value that is never used. \n " , errout . str ( ) ) ;
2010-05-01 21:15:14 +02:00
}
2014-11-20 14:20:09 +01:00
void localvar14 ( ) {
2010-05-09 07:10:51 +02:00
// ticket #5
functionVariableUsage ( " void foo() \n "
" { \n "
" int a[10]; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2010-05-09 07:10:51 +02:00
ASSERT_EQUALS ( " [test.cpp:3]: (style) Unused variable: a \n " , errout . str ( ) ) ;
}
2014-11-20 14:20:09 +01:00
void localvar15 ( ) {
2010-06-18 07:19:26 +02:00
functionVariableUsage ( " int foo() \n "
" { \n "
" int a = 5; \n "
" int b[a]; \n "
" b[0] = 0; \n "
" return b[0]; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2010-06-18 07:19:26 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2010-05-23 10:41:05 +02:00
2010-06-18 07:19:26 +02:00
functionVariableUsage ( " int foo() \n "
" { \n "
" int a = 5; \n "
" int * b[a]; \n "
" b[0] = &c; \n "
" return *b[0]; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2010-06-18 07:19:26 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2010-05-23 10:41:05 +02:00
2010-06-18 07:19:26 +02:00
functionVariableUsage ( " int * foo() \n "
" { \n "
" int a = 5; \n "
" const int * b[a]; \n "
" b[0] = &c; \n "
" return b[0]; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2010-06-18 07:19:26 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2010-05-23 10:41:05 +02:00
2010-06-18 07:19:26 +02:00
functionVariableUsage ( " struct B * foo() \n "
" { \n "
" int a = 5; \n "
" struct B * b[a]; \n "
" b[0] = &c; \n "
" return b[0]; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2010-06-18 07:19:26 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2010-05-23 10:41:05 +02:00
2010-06-18 07:19:26 +02:00
functionVariableUsage ( " const struct B * foo() \n "
" { \n "
" int a = 5; \n "
" const struct B * b[a]; \n "
" b[0] = &c; \n "
" return b[0]; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2010-06-18 07:19:26 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2010-05-23 10:41:05 +02:00
}
2014-11-20 14:20:09 +01:00
void localvar16 ( ) { // ticket #1709
2021-05-13 20:21:02 +02:00
functionVariableUsage ( " void foo() \n "
2010-06-18 07:19:26 +02:00
" { \n "
" char buf[5]; \n "
" char *ptr = buf; \n "
" *(ptr++) = 0; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2021-05-13 21:53:06 +02:00
TODO_ASSERT_EQUALS ( " [test.cpp:5]: (style) Variable 'buf' is assigned a value that is never used. \n " , " " , errout . str ( ) ) ;
2012-06-24 16:54:37 +02:00
// #3910
2021-05-13 20:21:02 +02:00
functionVariableUsage ( " void foo() { \n "
2012-06-24 16:54:37 +02:00
" char buf[5]; \n "
" char *data[2]; \n "
" data[0] = buf; \n "
" do_something(data); \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-06-24 16:54:37 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2021-05-13 20:21:02 +02:00
functionVariableUsage ( " void foo() { \n "
2012-06-24 16:54:37 +02:00
" char buf1[5]; \n "
" char buf2[5]; \n "
" char *data[2]; \n "
" data[0] = buf1; \n "
" data[1] = buf2; \n "
" do_something(data); \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-06-24 16:54:37 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2010-05-26 19:22:35 +02:00
}
2014-11-20 14:20:09 +01:00
void localvar17 ( ) { // ticket #1720
2021-05-13 20:21:02 +02:00
// extracttests.disable
2010-06-02 18:10:32 +02:00
// Don't crash when checking the code below!
functionVariableUsage ( " void foo() \n "
" { \n "
2018-12-13 18:52:56 +01:00
" struct DATA *data = DATA; \n "
2010-06-02 18:10:32 +02:00
" char *k = data->req; \n "
" char *ptr; \n "
" char *line_start; \n "
" ptr = data->buffer; \n "
" line_start = ptr; \n "
" data->info = k; \n "
" line_start = ptr; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-11-01 18:40:20 +01:00
ASSERT_EQUALS ( " [test.cpp:10]: (style) Variable 'line_start' is assigned a value that is never used. \n " , errout . str ( ) ) ;
2021-05-13 20:21:02 +02:00
// extracttests.enable
2010-06-01 20:00:43 +02:00
}
2014-11-20 14:20:09 +01:00
void localvar18 ( ) { // ticket #1723
2010-06-03 07:05:57 +02:00
functionVariableUsage ( " A::A(int iValue) { \n "
" UserDefinedException* pe = new UserDefinedException(); \n "
" throw pe; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2010-06-18 07:19:26 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2010-06-03 07:05:57 +02:00
}
2014-11-20 14:20:09 +01:00
void localvar19 ( ) { // ticket #1776
2010-06-08 18:24:42 +02:00
functionVariableUsage ( " void foo() { \n "
" int a[10]; \n "
" int c; \n "
" c = *(a); \n "
" } " ) ;
2018-12-13 18:52:56 +01:00
ASSERT_EQUALS ( " [test.cpp:4]: (style) Variable 'c' is assigned a value that is never used. \n "
" [test.cpp:2]: (style) Variable 'a' is not assigned a value. \n " , errout . str ( ) ) ;
2010-06-08 18:24:42 +02:00
}
2014-11-20 14:20:09 +01:00
void localvar20 ( ) { // ticket #1799
2010-06-21 18:12:01 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
" char c1 = 'c'; \n "
" char c2[] = { c1 }; \n "
" a(c2); \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2014-11-20 14:20:09 +01:00
void localvar21 ( ) { // ticket #1807
2010-06-22 17:04:11 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
" char buffer[1024]; \n "
" bar((void *)buffer); \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2014-11-20 14:20:09 +01:00
void localvar22 ( ) { // ticket #1811
2010-06-25 07:52:12 +02:00
functionVariableUsage ( " int foo(int u, int v) \n "
" { \n "
" int h, i; \n "
" h = 0 ? u : v; \n "
" i = 1 ? u : v; \n "
" return h + i; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2010-06-25 07:52:12 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2014-11-20 14:20:09 +01:00
void localvar23 ( ) { // ticket #1808
2010-06-29 08:38:24 +02:00
functionVariableUsage ( " int foo(int c) \n "
" { \n "
" int a; \n "
" int b[10]; \n "
" a = b[c] = 0; \n "
" return a; \n "
" } " ) ;
2022-01-18 22:03:52 +01:00
TODO_ASSERT_EQUALS ( " [test.cpp:5]: (style) Variable 'b' is assigned a value that is never used. \n " ,
" " ,
errout . str ( ) ) ;
2010-06-29 08:38:24 +02:00
}
2014-11-20 14:20:09 +01:00
void localvar24 ( ) { // ticket #1803
2010-07-07 08:39:18 +02:00
functionVariableUsage ( " class MyException \n "
" { \n "
" virtual void raise() const \n "
" { \n "
" throw *this; \n "
" } \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2010-07-07 08:39:18 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2014-11-20 14:20:09 +01:00
void localvar25 ( ) { // ticket #1729
2010-07-08 08:42:34 +02:00
functionVariableUsage ( " int main() { \n "
" int ppos = 1; \n "
" int pneg = 0; \n "
" const char*edge = ppos? \" + \" : pneg ? \" - \" : \" \" ; \n "
2021-10-30 19:04:50 +02:00
" printf( \" This should be a '+' -> %s \\ n \" , edge); \n "
2010-07-08 08:42:34 +02:00
" return 0; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2010-07-08 08:42:34 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2014-11-20 14:20:09 +01:00
void localvar26 ( ) { // ticket #1894
2010-08-07 15:53:51 +02:00
functionVariableUsage ( " int main() { \n "
" const Fred &fred = getfred(); \n "
" int *p = fred.x(); \n "
" *p = 0; "
2013-03-20 15:36:16 +01:00
" } " ) ;
2010-08-07 15:53:51 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2014-11-20 14:20:09 +01:00
void localvar27 ( ) { // ticket #2160
2010-11-02 20:01:12 +01:00
functionVariableUsage ( " void f(struct s *ptr) { \n "
" int param = 1; \n "
" ptr->param = param++; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2010-11-02 20:01:12 +01:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2014-11-20 14:20:09 +01:00
void localvar28 ( ) { // ticket #2205
2010-11-15 17:30:07 +01:00
functionVariableUsage ( " void f(char* buffer, int value) { \n "
" char* pos = buffer; \n "
" int size = value; \n "
" *(int*)pos = size; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2010-11-15 17:30:07 +01:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2014-11-20 14:20:09 +01:00
void localvar29 ( ) { // ticket #2206
2010-11-15 17:53:55 +01:00
functionVariableUsage ( " void f() { \n "
" float s_ranges[] = { 0, 256 }; \n "
" float* ranges[] = { s_ranges }; \n "
" cout << ranges[0][0]; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2010-11-15 17:53:55 +01:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2014-11-20 14:20:09 +01:00
void localvar30 ( ) { // ticket #2264
2010-12-03 18:45:49 +01:00
functionVariableUsage ( " void f() { \n "
" Engine *engine = e; \n "
" x->engine = engine->clone(); \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2010-12-03 18:45:49 +01:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2014-11-20 14:20:09 +01:00
void localvar31 ( ) { // ticket #2286
2010-12-19 18:27:31 +01:00
functionVariableUsage ( " void f() { \n "
" int x = 0; \n "
" a.x = x - b; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2010-12-19 18:27:31 +01:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2010-12-21 19:02:00 +01:00
2014-11-20 14:20:09 +01:00
void localvar32 ( ) {
2013-08-27 06:47:06 +02:00
// ticket #2330 - fstream >> x
2010-12-21 08:13:40 +01:00
functionVariableUsage ( " void f() { \n "
2010-12-21 19:02:00 +01:00
" int x; \n "
2010-12-21 08:13:40 +01:00
" fstream &f = getfile(); \n "
" f >> x; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2010-12-21 08:13:40 +01:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2013-08-27 06:47:06 +02:00
// ticket #4596 - if (c >>= x) {}
2018-12-13 18:52:56 +01:00
functionVariableUsage ( " void f(int x) { \n "
2013-08-27 06:47:06 +02:00
" C c; \n " // possibly some stream class
" if (c >>= x) {} \n "
" } " ) ;
2022-01-18 22:03:52 +01:00
ASSERT_EQUALS ( " [test.cpp:3]: (information) --check-library: Provide <type-checks><unusedvar> configuration for C \n " , errout . str ( ) ) ;
2013-08-27 15:57:38 +02:00
2018-12-13 18:52:56 +01:00
functionVariableUsage ( " void f(int x) { \n "
2013-08-27 15:57:38 +02:00
" C c; \n "
" if (c >>= x) {} \n "
" } " , " test.c " ) ;
2018-12-13 18:52:56 +01:00
ASSERT_EQUALS ( " [test.c:3]: (style) Variable 'c' is assigned a value that is never used. \n " , errout . str ( ) ) ;
2013-08-27 15:57:38 +02:00
2014-07-17 09:33:07 +02:00
functionVariableUsage ( " void f() { \n "
" int x, y; \n "
" std::cin >> x >> y; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2018-04-17 14:23:04 +02:00
// ticket #8494
functionVariableUsage ( " void f(C c) { \n "
" int x; \n "
" c & x; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2010-12-21 08:13:40 +01:00
}
2010-12-19 18:27:31 +01:00
2014-11-20 14:20:09 +01:00
void localvar33 ( ) { // ticket #2345
2010-12-25 19:17:53 +01:00
functionVariableUsage ( " void f() { \n "
" Abc* abc = getabc(); \n "
" while (0 != (abc = abc->next())) { \n "
" ++nOldNum; \n "
" } \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2010-12-25 19:17:53 +01:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2014-11-20 14:20:09 +01:00
void localvar34 ( ) { // ticket #2368
2010-12-27 20:49:07 +01:00
functionVariableUsage ( " void f() { \n "
" int i = 0; \n "
" if (false) { \n "
" } else { \n "
" j -= i; \n "
" } \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2010-12-27 20:49:07 +01:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2010-12-27 15:12:17 +01:00
}
2014-11-20 14:20:09 +01:00
void localvar35 ( ) { // ticket #2535
2011-02-09 19:20:44 +01:00
functionVariableUsage ( " void f() { \n "
" int a, b; \n "
" x(1,a,b); \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2011-02-09 19:20:44 +01:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2014-11-20 14:20:09 +01:00
void localvar36 ( ) { // ticket #2805
2011-06-08 19:54:01 +02:00
functionVariableUsage ( " int f() { \n "
" int a, b; \n "
" a = 2 * (b = 3); \n "
" return a + b; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2011-06-08 19:54:01 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2012-11-15 08:36:43 +01:00
functionVariableUsage ( " int f() { \n " // ticket #4318
" int a,b; \n "
" x(a, b=2); \n " // <- if param2 is passed-by-reference then b might be used in x
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-11-15 08:36:43 +01:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2016-08-02 08:50:04 +02:00
functionVariableUsage ( " int foo() { \n " // ticket #6147
" int a = 0; \n "
" bar(a=a+2); \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
functionVariableUsage ( " int foo() { \n " // ticket #6147
" int a = 0; \n "
" bar(a=2); \n "
" } " ) ;
TODO_ASSERT_EQUALS ( " error " , " " , errout . str ( ) ) ;
functionVariableUsage ( " void bar(int); \n "
" int foo() { \n "
" int a = 0; \n "
" bar(a=a+2); \n "
" } " ) ;
TODO_ASSERT_EQUALS ( " error " , " " , errout . str ( ) ) ;
2011-06-08 19:54:01 +02:00
}
2014-11-20 14:20:09 +01:00
void localvar37 ( ) { // ticket #3078
2011-09-04 20:48:05 +02:00
functionVariableUsage ( " void f() { \n "
" int a = 2; \n "
" ints.at(a) = 0; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2011-09-04 20:48:05 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2014-11-20 14:20:09 +01:00
void localvar38 ( ) {
2011-12-18 20:15:41 +01:00
functionVariableUsage ( " std::string f() { \n "
" const char code[] = \" foo \" ; \n "
" const std::string s1(sizeof_(code)); \n "
" const std::string s2 = sizeof_(code); \n "
" return(s1+s2); \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2011-12-18 20:15:41 +01:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2014-11-20 14:20:09 +01:00
void localvar39 ( ) {
2011-12-30 09:47:15 +01:00
functionVariableUsage ( " void f() { \n "
" int a = 1; \n "
" foo(x*a); \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2011-12-30 09:47:15 +01:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2014-11-20 14:20:09 +01:00
void localvar40 ( ) {
2012-01-08 08:44:18 +01:00
functionVariableUsage ( " int f() { \n "
" int a = 1; \n "
" return x & a; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-01-08 08:44:18 +01:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2014-11-20 14:20:09 +01:00
void localvar41 ( ) {
2012-02-19 15:25:46 +01:00
// #3603 - false positive 'x is assigned a value that is never used'
functionVariableUsage ( " int f() { \n "
" int x = 1; \n "
" int y = FOO::VALUE * x; \n "
" return y; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-02-19 15:25:46 +01:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2014-11-20 14:20:09 +01:00
void localvar42 ( ) { // #3742
2012-04-19 10:08:51 +02:00
functionVariableUsage ( " float g_float = 1; \n "
" extern void SomeTestFunc(float); \n "
" void MyFuncError() \n "
" { \n "
" const float floatA = 2.2f; \n "
" const float floatTot = g_float * floatA; \n "
" SomeTestFunc(floatTot); \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-04-19 10:08:51 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
functionVariableUsage ( " float g_float = 1; \n "
" extern void SomeTestFunc(float); \n "
" void MyFuncNoError() \n "
" { \n "
" const float floatB = 2.2f; \n "
" const float floatTot = floatB * g_float; \n "
" SomeTestFunc(floatTot); \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-04-19 10:08:51 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
functionVariableUsage ( " float g_float = 1; \n "
" extern void SomeTestFunc(float); \n "
" void MyFuncNoError2() \n "
" { \n "
2013-03-04 20:14:56 +01:00
" const float floatC = 2.2f; \n "
2012-04-19 10:08:51 +02:00
" float floatTot = g_float * floatC; \n "
" SomeTestFunc(floatTot); \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-04-19 10:08:51 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2014-11-20 14:20:09 +01:00
void localvar43 ( ) { // ticket #3602 (false positive)
2012-04-27 02:05:45 +02:00
functionVariableUsage ( " void bar() \n "
2012-07-16 14:02:33 +02:00
" { \n "
2012-04-27 02:05:45 +02:00
" int * piArray = NULL; \n "
" unsigned int uiArrayLength = 2048; \n "
" unsigned int uiIndex; \n "
2012-07-16 14:02:33 +02:00
" \n "
2012-04-27 02:05:45 +02:00
" try \n "
" { \n "
2012-07-16 14:02:33 +02:00
" piArray = new int[uiArrayLength]; \n " // Allocate memory
2012-04-27 02:05:45 +02:00
" } \n "
" catch (...) \n "
" { \n "
2012-07-16 14:02:33 +02:00
" SOME_MACRO \n "
" delete [] piArray; \n "
" return; \n "
2012-04-27 02:05:45 +02:00
" } \n "
" for (uiIndex = 0; uiIndex < uiArrayLength; uiIndex++) \n "
" { \n "
2012-07-16 14:02:33 +02:00
" piArray[uiIndex] = -1234; \n "
2012-04-27 02:05:45 +02:00
" } \n "
" delete [] piArray; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-04-27 02:05:45 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2014-11-20 14:20:09 +01:00
void localvar44 ( ) { // #4020 - FP
2012-08-22 19:47:46 +02:00
functionVariableUsage ( " void func() { \n "
2018-12-17 15:40:15 +01:00
" int *sp_mem[2] = { global1, global2 }; \n "
" sp_mem[0][3] = 123; \n "
2012-08-22 19:47:46 +02:00
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2014-11-20 14:20:09 +01:00
void localvar45 ( ) { // #4899 - FP
2013-09-03 17:02:46 +02:00
functionVariableUsage ( " int func() { \n "
" int a = 123; \n "
" int b = (short)-a;; \n "
" return b; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2014-12-07 15:32:09 +01:00
void localvar46 ( ) { // #5491/#5494/#6301
2014-08-05 15:33:57 +02:00
functionVariableUsage ( " int func() { \n "
" int i = 0; \n "
" int j{i}; \n "
" return j; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2022-01-12 22:06:03 +01:00
functionVariableUsage ( " void f(bool b, bool c, double& r) { \n "
" double d{}; \n "
" if (b) { \n "
" d = g(); \n "
" r += d; \n "
" } \n "
" if (c) { \n "
" d = h(); \n "
" r += d; \n "
" } \n "
" } \n " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2014-08-05 15:33:57 +02:00
functionVariableUsage ( " int func() { \n "
" std::mutex m; \n "
" std::unique_lock<std::mutex> l{ m }; \n "
" return 0; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2014-12-07 15:32:09 +01:00
functionVariableUsage ( " int func() { \n "
" std::shared_lock<std::shared_timed_mutex> lock( m ); \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2022-01-10 07:43:02 +01:00
functionVariableUsage ( " void f() { \n " // #10490
" std::shared_lock lock = GetLock(); \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
functionVariableUsage ( " void f() { \n "
" auto&& g = std::lock_guard<std::mutex> { mutex }; \n "
" } \n " ) ;
TODO_ASSERT_EQUALS ( " " , " [test.cpp:2]: (style) Variable 'g' is assigned a value that is never used. \n " , errout . str ( ) ) ;
2014-08-05 15:33:57 +02:00
}
2015-04-13 21:21:57 +02:00
void localvar47 ( ) { // #6603
2021-05-13 20:21:02 +02:00
// extracttests.disable
2015-04-13 21:21:57 +02:00
functionVariableUsage ( " void f() { \n "
" int (SfxUndoManager::*retrieveCount)(bool) const \n "
" = (flag) ? &SfxUndoManager::foo : &SfxUndoManager::bar; \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:3]: (style) Variable 'retrieveCount' is assigned a value that is never used. \n " , errout . str ( ) ) ;
2021-05-13 20:21:02 +02:00
// extracttests.enable
2015-04-13 21:21:57 +02:00
}
2015-08-27 23:56:26 +02:00
void localvar48 ( ) { // #6954
functionVariableUsage ( " void foo() { \n "
" long (*pKoeff)[256] = new long[9][256]; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2016-07-09 09:22:52 +02:00
void localvar49 ( ) { // #7594
functionVariableUsage ( " class A { \n "
" public: \n "
" typedef enum { ID1,ID2,ID3 } Id_t; \n "
" typedef struct {Id_t id; std::string a; } x_t; \n "
" std::vector<x_t> m_vec; \n "
" std::vector<x_t> Get(void); \n "
" void DoSomething(); \n "
" }; \n "
" std::vector<A::x_t> A::Get(void) { \n "
" return m_vec; \n "
" } \n "
" const std::string Bar() { \n "
" return \" x \" ; \n "
" } \n "
" void A::DoSomething(void) { \n "
2018-12-13 18:52:56 +01:00
" const std::string x = Bar(); \n " // <- warning
2016-07-09 09:22:52 +02:00
" } " ) ;
2021-02-20 13:02:14 +01:00
ASSERT_EQUALS ( " [test.cpp:16]: (style) Variable 'x' is assigned a value that is never used. \n " , errout . str ( ) ) ;
2016-07-09 09:22:52 +02:00
}
2017-07-01 11:31:51 +02:00
void localvar50 ( ) { // #6261, #6542
// #6261 - ternary operator in function call
2017-07-01 11:03:49 +02:00
functionVariableUsage ( " void foo() { \n "
" char buf1[10]; \n "
" dostuff(cond?buf1:buf2); \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
functionVariableUsage ( " void foo() { \n "
" char buf1[10]; \n "
" dostuff(cond?buf2:buf1); \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2017-07-01 11:31:51 +02:00
// #6542 - ternary operator
functionVariableUsage ( " void foo(int c) { \n "
" char buf1[10], buf2[10]; \n "
" char *p = c ? buf1 : buf2; \n "
" dostuff(p); \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2017-07-01 11:03:49 +02:00
}
2017-08-01 14:56:53 +02:00
void localvar51 ( ) { // #8128 FN
2021-05-13 20:21:02 +02:00
// extracttests.start: struct Token { const Token* next() const; }; const Token* nameToken();
functionVariableUsage ( " void foo(const Token *var) { \n "
" const Token *tok = nameToken(); \n "
2017-08-01 14:56:53 +02:00
" tok = tok->next(); \n " // read+write
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:3]: (style) Variable 'tok' is assigned a value that is never used. \n " , errout . str ( ) ) ;
functionVariableUsage ( " void foo() { \n "
" int x = 4; \n "
" x = 15 + x; \n " // read+write
" } " ) ;
2018-12-13 18:52:56 +01:00
ASSERT_EQUALS ( " [test.cpp:3]: (style) Variable 'x' is assigned a value that is never used. \n " , errout . str ( ) ) ;
}
void localvar52 ( ) {
functionVariableUsage ( " void foo() { \n "
" std::vector<int> data; \n "
" data[2] = 32; \n "
" return data; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
void localvar53 ( ) {
2021-05-13 20:21:02 +02:00
functionVariableUsage ( " void foo(int a, int loop) { \n "
2018-12-13 18:52:56 +01:00
" bool x = false; \n "
" while (loop) { \n "
" if (a) { \n "
" x = true; \n " // unused value
" continue; \n "
" } \n "
" } \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:2]: (style) Variable 'x' is assigned a value that is never used. \n " , errout . str ( ) ) ;
2021-05-13 20:21:02 +02:00
functionVariableUsage ( " void foo(int a, int loop) { \n "
2018-12-13 18:52:56 +01:00
" bool x = false; \n "
" while (loop) { \n "
" if (a) { \n "
" x = true; \n "
" continue; \n "
" } \n "
" } \n "
" return x; \n "
" } " ) ;
2019-07-29 07:51:00 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2017-08-02 07:48:38 +02:00
}
2017-08-01 14:56:53 +02:00
2018-12-14 18:56:09 +01:00
void localvar54 ( ) {
functionVariableUsage ( " Padding fun() { \n "
" Distance d = DISTANCE; \n "
" return (Padding){ d, d, d, d }; \n "
2021-02-20 12:58:42 +01:00
" } " ) ;
2018-12-14 18:56:09 +01:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2018-12-16 21:45:26 +01:00
void localvar55 ( ) {
functionVariableUsage ( " void f(int mode) { \n "
" int x = 0; \n " // <- redundant assignment
" \n "
" for (int i = 0; i < 10; i++) { \n "
" if (mode == 0x04) \n "
" x = 0; \n " // <- redundant assignment
" if (mode == 0x0f) { \n "
" x = address; \n "
" data[x] = 0; \n "
" } \n "
" } \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:2]: (style) Variable 'x' is assigned a value that is never used. \n "
" [test.cpp:6]: (style) Variable 'x' is assigned a value that is never used. \n " ,
errout . str ( ) ) ;
}
2019-01-02 20:23:02 +01:00
void localvar56 ( ) {
functionVariableUsage ( " void f() \n "
" { \n "
" int x = 31; \n "
" mask[x] |= 123; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2019-07-29 08:49:19 +02:00
void localvar57 ( ) {
functionVariableUsage ( " void f() \n "
" { \n "
" int x = 0; \n "
" x++; \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:4]: (style) Variable 'x' is assigned a value that is never used. \n " , errout . str ( ) ) ;
}
2020-09-26 22:13:05 +02:00
void localvar58 ( ) { // #9901 - increment false positive
functionVariableUsage ( " void f() { \n "
" int x = 0; \n "
" if (--x > 0) {} \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
functionVariableUsage ( " void f() { \n "
" int x = 0; \n "
" if (x-- > 0) {} \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:3]: (style) Variable 'x' is assigned a value that is never used. \n " , errout . str ( ) ) ;
}
2020-10-25 20:32:45 +01:00
void localvar59 ( ) { // #9737
functionVariableUsage ( " Response foo() { \n "
" const std::vector<char> cmanifest = z; \n "
" return {.a = cmanifest, .b =0}; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2021-10-24 21:22:06 +02:00
void localvar60 ( ) { // #10531
functionVariableUsage ( " void Scale(double scale) { \n "
" for (int i = 0; i < m_points.size(); ++i) { \n "
" auto& p = m_points[i]; \n "
" p += scale; \n "
" } \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2018-12-16 11:18:37 +01:00
void localvarloops ( ) {
// loops
2021-05-13 20:21:02 +02:00
functionVariableUsage ( " void fun(int c) { \n "
2018-12-16 11:18:37 +01:00
" int x; \n "
" while (c) { x=10; } \n "
2021-02-20 12:58:42 +01:00
" } " ) ;
2018-12-16 11:18:37 +01:00
ASSERT_EQUALS ( " [test.cpp:3]: (style) Variable 'x' is assigned a value that is never used. \n " , errout . str ( ) ) ;
2019-01-13 07:59:41 +01:00
functionVariableUsage ( " void dostuff(int x); \n "
2021-05-13 20:21:02 +02:00
" void fun(int y, int c) { \n "
2019-01-13 07:59:41 +01:00
" int x = 1; \n "
" while (c) { \n "
" dostuff(x); \n "
" if (y) { x=10; break; } \n "
" } \n "
2021-02-20 12:58:42 +01:00
" } " ) ;
2019-01-13 07:59:41 +01:00
ASSERT_EQUALS ( " [test.cpp:6]: (style) Variable 'x' is assigned a value that is never used. \n " , errout . str ( ) ) ;
functionVariableUsage ( " void dostuff(int &x); \n "
" void fun() { \n "
2018-12-16 11:18:37 +01:00
" int x = 1; \n "
" while (c) { \n "
" dostuff(x); \n "
" if (y) { x=10; break; } \n "
" } \n "
2021-02-20 12:58:42 +01:00
" } " ) ;
2019-01-13 07:59:41 +01:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ; // TODO : in this special case we can ignore that x is aliased. x is local and there are no function calls after the assignment
2018-12-16 11:18:37 +01:00
functionVariableUsage ( " void fun() { \n "
" int x = 0; \n "
" while (c) { \n "
" dostuff(x); \n "
" x = 10; \n "
" } \n "
2021-02-20 12:58:42 +01:00
" } " ) ;
2018-12-16 11:18:37 +01:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
functionVariableUsage ( " void fun() { \n "
" int x = 0; \n "
" while (x < 10) { x = x + 1; } \n "
2021-02-20 12:58:42 +01:00
" } " ) ;
2018-12-16 11:18:37 +01:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2018-12-16 16:43:04 +01:00
functionVariableUsage ( " void fun() \n "
" { \n "
" int status = 0; \n "
" for (ind = 0; ((ind < nrArgs) && (status < 10)); ind++) \n "
" status = x; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2018-12-27 17:27:51 +01:00
functionVariableUsage ( " void f() \n "
" { \n "
" int sum = 0U; \n "
" for (i = 0U; i < 2U; i++) \n "
" sum += 123; \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:3]: (style) Variable 'sum' is assigned a value that is never used. \n "
" [test.cpp:5]: (style) Variable 'sum' is assigned a value that is never used. \n " , errout . str ( ) ) ;
2018-12-16 11:18:37 +01:00
}
2014-11-20 14:20:09 +01:00
void localvaralias1 ( ) {
2010-04-24 10:35:41 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
" int a; \n "
" int *b = &a; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2018-12-13 18:52:56 +01:00
ASSERT_EQUALS ( " [test.cpp:4]: (style) Variable 'b' is assigned a value that is never used. \n "
" [test.cpp:3]: (style) Unused variable: a \n " , errout . str ( ) ) ;
2010-04-29 07:10:50 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
" int a[10]; \n "
" int *b = a; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2018-12-13 18:52:56 +01:00
ASSERT_EQUALS ( " [test.cpp:4]: (style) Variable 'b' is assigned a value that is never used. \n "
" [test.cpp:3]: (style) Unused variable: a \n " , errout . str ( ) ) ;
2010-04-29 07:10:50 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
" int a; \n "
" int *b = &a; \n "
" *b = 0; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2022-01-18 22:03:52 +01:00
TODO_ASSERT_EQUALS ( " [test.cpp:5]: (style) Variable 'a' is assigned a value that is never used. \n " ,
" " ,
errout . str ( ) ) ;
2010-04-29 07:10:50 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
" int a; \n "
" char *b = (char *)&a; \n "
" *b = 0; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2022-01-18 22:03:52 +01:00
TODO_ASSERT_EQUALS ( " [test.cpp:5]: (style) Variable 'a' is assigned a value that is never used. \n " ,
" " ,
errout . str ( ) ) ;
2010-04-29 07:10:50 +02:00
2010-05-01 09:26:47 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
" int a; \n "
" char *b = (char *)(&a); \n "
" *b = 0; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2022-01-18 22:03:52 +01:00
TODO_ASSERT_EQUALS ( " [test.cpp:5]: (style) Variable 'a' is assigned a value that is never used. \n " ,
" " ,
errout . str ( ) ) ;
2010-05-01 09:26:47 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
" int a; \n "
" const char *b = (const char *)&a; \n "
" *b = 0; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2022-01-18 22:03:52 +01:00
TODO_ASSERT_EQUALS ( " [test.cpp:5]: (style) Variable 'a' is assigned a value that is never used. \n " ,
" " ,
errout . str ( ) ) ;
2010-05-01 09:26:47 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
" int a; \n "
" const char *b = (const char *)(&a); \n "
" *b = 0; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2022-01-18 22:03:52 +01:00
TODO_ASSERT_EQUALS ( " [test.cpp:5]: (style) Variable 'a' is assigned a value that is never used. \n " ,
" " ,
errout . str ( ) ) ;
2010-05-01 09:26:47 +02:00
2010-04-29 07:10:50 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
" int a; \n "
" char *b = static_cast<char *>(&a); \n "
" *b = 0; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2022-01-18 22:03:52 +01:00
TODO_ASSERT_EQUALS ( " [test.cpp:5]: (style) Variable 'a' is assigned a value that is never used. \n " ,
" " ,
errout . str ( ) ) ;
2010-04-29 07:10:50 +02:00
2010-05-01 09:26:47 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
" int a; \n "
" const char *b = static_cast<const char *>(&a); \n "
" *b = 0; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2022-01-18 22:03:52 +01:00
TODO_ASSERT_EQUALS ( " [test.cpp:5]: (style) Variable 'a' is assigned a value that is never used. \n " ,
" " ,
errout . str ( ) ) ;
2010-05-01 09:26:47 +02:00
2010-05-04 17:28:03 +02:00
// a is not a local variable and b is aliased to it
2010-04-29 07:10:50 +02:00
functionVariableUsage ( " int a; \n "
" void foo() \n "
" { \n "
" int *b = &a; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-11-01 18:40:20 +01:00
ASSERT_EQUALS ( " [test.cpp:4]: (style) Variable 'b' is assigned a value that is never used. \n " , errout . str ( ) ) ;
2010-04-29 07:10:50 +02:00
2010-05-04 17:28:03 +02:00
// a is not a local variable and b is aliased to it
2010-04-29 07:10:50 +02:00
functionVariableUsage ( " void foo(int a) \n "
" { \n "
" int *b = &a; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-11-01 18:40:20 +01:00
ASSERT_EQUALS ( " [test.cpp:3]: (style) Variable 'b' is assigned a value that is never used. \n " , errout . str ( ) ) ;
2010-04-29 07:10:50 +02:00
2010-05-04 17:28:03 +02:00
// a is not a local variable and b is aliased to it
2010-04-29 07:10:50 +02:00
functionVariableUsage ( " class A \n "
" { \n "
" int a; \n "
" void foo() \n "
" { \n "
" int *b = &a; \n "
" } \n "
2021-05-13 20:21:02 +02:00
" }; " ) ;
2012-11-01 18:40:20 +01:00
ASSERT_EQUALS ( " [test.cpp:6]: (style) Variable 'b' is assigned a value that is never used. \n " , errout . str ( ) ) ;
2010-04-29 07:10:50 +02:00
functionVariableUsage ( " int a; \n "
" void foo() \n "
" { \n "
" int *b = &a; \n "
" *b = 0; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2010-06-18 07:19:26 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2010-04-29 07:10:50 +02:00
functionVariableUsage ( " void foo(int a) \n "
" { \n "
" int *b = &a; \n "
2010-04-24 10:35:41 +02:00
" *b = 0; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2010-06-18 07:19:26 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2010-04-24 10:35:41 +02:00
2010-04-29 07:10:50 +02:00
functionVariableUsage ( " class A \n "
" { \n "
" int a; \n "
" void foo() \n "
" { \n "
" int *b = &a; \n "
" *b = 0; \n "
" } \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2010-06-18 07:19:26 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2010-04-29 07:10:50 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
" int a[10]; \n "
" int *b = a; \n "
" *b = 0; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2022-01-18 22:03:52 +01:00
TODO_ASSERT_EQUALS ( " [test.cpp:5]: (style) Variable 'a' is assigned a value that is never used. \n " ,
" " ,
errout . str ( ) ) ;
2010-04-29 07:10:50 +02:00
2010-04-24 10:35:41 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
" int a[10]; \n "
2010-04-29 07:10:50 +02:00
" char *b = (char *)a; \n "
" *b = 0; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2022-01-18 22:03:52 +01:00
TODO_ASSERT_EQUALS ( " [test.cpp:5]: (style) Variable 'a' is assigned a value that is never used. \n " ,
" " ,
errout . str ( ) ) ;
2010-04-29 07:10:50 +02:00
2010-05-01 09:26:47 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
" int a[10]; \n "
" char *b = (char *)(a); \n "
" *b = 0; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2022-01-18 22:03:52 +01:00
TODO_ASSERT_EQUALS ( " [test.cpp:5]: (style) Variable 'a' is assigned a value that is never used. \n " ,
" " ,
errout . str ( ) ) ;
2010-05-01 09:26:47 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
" int a[10]; \n "
" const char *b = (const char *)a; \n "
" *b = 0; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2022-01-18 22:03:52 +01:00
TODO_ASSERT_EQUALS ( " [test.cpp:5]: (style) Variable 'a' is assigned a value that is never used. \n " ,
" " ,
errout . str ( ) ) ;
2010-05-01 09:26:47 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
" int a[10]; \n "
" const char *b = (const char *)(a); \n "
" *b = 0; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2022-01-18 22:03:52 +01:00
TODO_ASSERT_EQUALS ( " [test.cpp:5]: (style) Variable 'a' is assigned a value that is never used. \n " ,
" " ,
errout . str ( ) ) ;
2010-05-01 09:26:47 +02:00
2010-04-29 07:10:50 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
" int a[10]; \n "
" char *b = static_cast<char *>(a); \n "
" *b = 0; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2022-01-18 22:03:52 +01:00
TODO_ASSERT_EQUALS ( " [test.cpp:5]: (style) Variable 'a' is assigned a value that is never used. \n " ,
" " ,
errout . str ( ) ) ;
2010-04-29 07:10:50 +02:00
2010-05-01 09:26:47 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
" int a[10]; \n "
" const char *b = static_cast<const char *>(a); \n "
" *b = 0; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2022-01-18 22:03:52 +01:00
TODO_ASSERT_EQUALS ( " [test.cpp:5]: (style) Variable 'a' is assigned a value that is never used. \n " ,
" " ,
errout . str ( ) ) ;
2010-05-01 09:26:47 +02:00
2010-04-29 07:10:50 +02:00
functionVariableUsage ( " int a[10]; \n "
" void foo() \n "
" { \n "
2010-04-24 10:35:41 +02:00
" int *b = a; \n "
" *b = 0; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2010-06-18 07:19:26 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2010-04-29 07:10:50 +02:00
2010-05-04 17:28:03 +02:00
functionVariableUsage ( " int a[10]; \n "
" void foo() \n "
" { \n "
" int *b = a; \n "
" int *c = b; \n "
" *c = 0; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2010-06-18 07:19:26 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2010-05-04 17:28:03 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
" int *b = a; \n "
" int *c = b; \n "
" *c = 0; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2010-06-18 07:19:26 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2010-05-04 17:28:03 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
" int *b = a; \n "
" int *c = b; \n "
" *c = b[0]; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2010-06-18 07:19:26 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2010-05-04 17:28:03 +02:00
2021-05-13 20:21:02 +02:00
// extracttests.start: int a[10];
2010-05-04 17:28:03 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
" int *b = a; \n "
" int c = b[0]; \n "
2012-09-02 18:50:17 +02:00
" x(c); \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2010-06-18 07:19:26 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2010-05-04 17:28:03 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
" int *b = a; \n "
" int c = b[0]; \n "
2012-09-02 18:50:17 +02:00
" x(c); \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2010-06-18 07:19:26 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2010-05-04 17:28:03 +02:00
functionVariableUsage ( " int a[10]; \n "
" void foo() \n "
" { \n "
" int *b = &a[0]; \n "
" a[0] = b[0]; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2010-06-18 07:19:26 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2010-05-04 17:28:03 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
" int *b = &a[0]; \n "
" a[0] = b[0]; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2010-06-18 07:19:26 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2010-05-04 17:28:03 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
" int *b = a; \n "
" a[0] = b[0]; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2010-06-18 07:19:26 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2010-05-04 17:28:03 +02:00
2010-04-29 07:10:50 +02:00
functionVariableUsage ( " void foo(int a[10]) \n "
" { \n "
" int *b = a; \n "
" *b = 0; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2010-06-18 07:19:26 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2010-04-29 07:10:50 +02:00
functionVariableUsage ( " class A \n "
" { \n "
" int a[10]; \n "
" void foo() \n "
" { \n "
" int *b = a; \n "
" *b = 0; \n "
" } \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2010-06-18 07:19:26 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2010-04-29 07:10:50 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
" int a[10]; \n "
" int *b = a; \n "
" int *c = b; \n "
" *c = 0; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2022-01-18 22:03:52 +01:00
TODO_ASSERT_EQUALS ( " [test.cpp:6]: (style) Variable 'a' is assigned a value that is never used. \n " ,
" " ,
errout . str ( ) ) ;
2010-04-29 07:10:50 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
" int a[10]; \n "
" int b[10]; \n "
" int *c = a; \n "
" int *d = b; \n "
" *d = 0; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2022-01-18 22:03:52 +01:00
ASSERT_EQUALS ( " [test.cpp:5]: (style) Variable 'c' is assigned a value that is never used. \n "
" [test.cpp:3]: (style) Unused variable: a \n " ,
errout . str ( ) ) ;
2010-04-29 07:10:50 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
" int a[10]; \n "
" int b[10]; \n "
" int *c = a; \n "
" c = b; \n "
" *c = 0; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2022-01-18 22:03:52 +01:00
ASSERT_EQUALS ( " [test.cpp:3]: (style) Unused variable: a \n "
" " ,
errout . str ( ) ) ;
2010-04-29 07:10:50 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
" int a[10]; \n "
" int b[10]; \n "
" int *c = a; \n "
" c = b; \n "
" *c = 0; \n "
" c = a; \n "
" *c = 0; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2022-01-18 22:03:52 +01:00
TODO_ASSERT_EQUALS ( " [test.cpp:9]: (style) Variable 'a' is assigned a value that is never used. \n "
" [test.cpp:7]: (style) Variable 'b' is assigned a value that is never used. \n " ,
" " ,
errout . str ( ) ) ;
2010-04-29 07:10:50 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
" int a[10], * b = a + 10; \n "
2018-12-13 18:52:56 +01:00
" b[-10] = 1; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2022-01-18 22:03:52 +01:00
TODO_ASSERT_EQUALS ( " [test.cpp:4]: (style) Variable 'b[-10]' is assigned a value that is never used. \n " ,
" " ,
errout . str ( ) ) ;
2010-04-29 07:10:50 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
" int a[10], * b = a + 10; \n "
" b[-10] = 0; \n "
" int * c = b - 10; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2018-12-13 18:52:56 +01:00
ASSERT_EQUALS ( // TODO "[test.cpp:4]: (style) Variable 'a' is assigned a value that is never used.\n"
" [test.cpp:5]: (style) Variable 'c' is assigned a value that is never used. \n " , errout . str ( ) ) ;
2010-04-29 07:10:50 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
" int a[10], * b = a + 10; \n "
" int * c = b - 10; \n "
2018-12-13 18:52:56 +01:00
" c[1] = 3; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2022-01-18 22:03:52 +01:00
TODO_ASSERT_EQUALS ( " [test.cpp:5]: (style) Variable 'c[1]' is assigned a value that is never used. \n " ,
" " ,
errout . str ( ) ) ;
2010-04-29 07:10:50 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
" int a[10], * b = a + 10; \n "
" int * c = b - 10; \n "
" c[1] = c[0]; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2022-01-18 22:03:52 +01:00
TODO_ASSERT_EQUALS ( " [test.cpp:5]: (style) Variable 'c[1]' is assigned a value that is never used. \n " ,
" " ,
errout . str ( ) ) ;
2010-04-29 07:10:50 +02:00
2012-12-28 18:18:36 +01:00
functionVariableUsage ( " void foo() { \n " // #4022 - FP (a is assigned a value that is never used)
" int a[2], *b[2]; \n "
" a[0] = 123; \n "
" b[0] = &a[0]; \n "
" int *d = b[0]; \n "
" return *d; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-12-28 18:18:36 +01:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
functionVariableUsage ( " void foo() { \n " // #4022 - FP (a is assigned a value that is never used)
" entry a[2], *b[2]; \n "
" a[0].value = 123; \n "
" b[0] = &a[0]; \n "
" int d = b[0].value; \n "
" return d; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-12-28 18:18:36 +01:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2010-04-30 18:11:51 +02:00
functionVariableUsage ( " struct S { char c[100]; }; \n "
" void foo() \n "
" { \n "
" char a[100]; \n "
" struct S * s = (struct S *)a; \n "
" s->c[0] = 0; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2010-04-30 18:11:51 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
functionVariableUsage ( " struct S { char c[100]; }; \n "
" void foo() \n "
" { \n "
" char a[100]; \n "
" struct S * s = (struct S *)a; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2018-12-13 18:52:56 +01:00
ASSERT_EQUALS ( " [test.cpp:5]: (style) Variable 's' is assigned a value that is never used. \n "
" [test.cpp:4]: (style) Unused variable: a \n " , errout . str ( ) ) ;
2010-05-01 09:26:47 +02:00
functionVariableUsage ( " struct S { char c[100]; }; \n "
" void foo() \n "
" { \n "
" char a[100]; \n "
" const struct S * s = (const struct S *)a; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2018-12-13 18:52:56 +01:00
ASSERT_EQUALS ( " [test.cpp:5]: (style) Variable 's' is assigned a value that is never used. \n "
" [test.cpp:4]: (style) Unused variable: a \n " , errout . str ( ) ) ;
2010-05-01 09:26:47 +02:00
functionVariableUsage ( " struct S { char c[100]; }; \n "
" void foo() \n "
" { \n "
" char a[100]; \n "
" struct S * s = static_cast<struct S *>(a); \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2018-12-13 18:52:56 +01:00
ASSERT_EQUALS ( " [test.cpp:5]: (style) Variable 's' is assigned a value that is never used. \n "
" [test.cpp:4]: (style) Unused variable: a \n " , errout . str ( ) ) ;
2010-05-01 09:26:47 +02:00
functionVariableUsage ( " struct S { char c[100]; }; \n "
" void foo() \n "
" { \n "
" char a[100]; \n "
" const struct S * s = static_cast<const struct S *>(a); \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2018-12-13 18:52:56 +01:00
ASSERT_EQUALS ( " [test.cpp:5]: (style) Variable 's' is assigned a value that is never used. \n "
" [test.cpp:4]: (style) Unused variable: a \n " , errout . str ( ) ) ;
2010-06-16 17:57:56 +02:00
functionVariableUsage ( " int a[10]; \n "
" void foo() \n "
" { \n "
" int b[10]; \n "
" int c[10]; \n "
" int *d; \n "
" d = b; \n "
" d = a; \n "
" d = c; \n "
" *d = 0; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2022-01-18 22:03:52 +01:00
ASSERT_EQUALS ( " [test.cpp:4]: (style) Unused variable: b \n " ,
errout . str ( ) ) ;
2010-06-16 17:57:56 +02:00
functionVariableUsage ( " int a[10]; \n "
" void foo() \n "
" { \n "
" int b[10]; \n "
" int c[10]; \n "
" int *d; \n "
" d = b; *d = 0; \n "
" d = a; *d = 0; \n "
" d = c; *d = 0; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2022-01-18 22:03:52 +01:00
TODO_ASSERT_EQUALS ( " [test.cpp:7]: (style) Variable 'b' is assigned a value that is never used. \n "
" [test.cpp:9]: (style) Variable 'c' is assigned a value that is never used. \n " ,
" " ,
errout . str ( ) ) ;
2010-04-24 10:35:41 +02:00
}
2014-11-20 14:20:09 +01:00
void localvaralias2 ( ) { // ticket 1637
2010-04-30 21:36:48 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
" int * a; \n "
2012-09-02 18:50:17 +02:00
" x(a); \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2010-06-18 07:19:26 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2010-04-30 21:36:48 +02:00
}
2014-11-20 14:20:09 +01:00
void localvaralias3 ( ) { // ticket 1639
2010-05-04 17:26:09 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
" BROWSEINFO info; \n "
" char szDisplayName[MAX_PATH]; \n "
" info.pszDisplayName = szDisplayName; \n "
" SHBrowseForFolder(&info); \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2010-06-18 07:19:26 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2010-05-04 17:26:09 +02:00
}
2014-11-20 14:20:09 +01:00
void localvaralias4 ( ) { // ticket 1643
2010-05-04 17:28:03 +02:00
functionVariableUsage ( " struct AB { int a; int b; } ab; \n "
" void foo() \n "
" { \n "
" int * a = &ab.a; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-11-01 18:40:20 +01:00
ASSERT_EQUALS ( " [test.cpp:4]: (style) Variable 'a' is assigned a value that is never used. \n " , errout . str ( ) ) ;
2010-05-04 17:28:03 +02:00
functionVariableUsage ( " struct AB { int a; int b; } ab; \n "
" void foo() \n "
" { \n "
" int * a = &ab.a; \n "
" *a = 0; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2010-06-18 07:19:26 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2010-05-04 17:28:03 +02:00
functionVariableUsage ( " struct AB { int a; int b; }; \n "
" void foo() \n "
" { \n "
" struct AB ab; \n "
" int * a = &ab.a; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2018-12-13 18:52:56 +01:00
ASSERT_EQUALS ( " [test.cpp:5]: (style) Variable 'a' is assigned a value that is never used. \n "
" [test.cpp:4]: (style) Variable 'ab' is not assigned a value. \n " , errout . str ( ) ) ;
2010-05-04 17:28:03 +02:00
functionVariableUsage ( " struct AB { int a; int b; }; \n "
" void foo() \n "
" { \n "
" struct AB ab; \n "
" int * a = &ab.a; \n "
" *a = 0; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2010-06-18 07:19:26 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2010-05-04 17:28:03 +02:00
}
2014-11-20 14:20:09 +01:00
void localvaralias5 ( ) { // ticket 1647
2010-05-05 17:31:07 +02:00
functionVariableUsage ( " char foo() \n "
" { \n "
" char buf[8]; \n "
" char *p = &buf[0]; \n "
" *p++ = 0; \n "
" return buf[0]; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2010-06-18 07:19:26 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2010-05-05 17:31:07 +02:00
functionVariableUsage ( " char foo() \n "
" { \n "
" char buf[8]; \n "
" char *p = &buf[1]; \n "
" *p-- = 0; \n "
" return buf[0]; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2010-06-18 07:19:26 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2010-05-05 17:31:07 +02:00
functionVariableUsage ( " char foo() \n "
" { \n "
" char buf[8]; \n "
" char *p = &buf[0]; \n "
" *++p = 0; \n "
" return buf[0]; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2010-06-18 07:19:26 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2010-05-05 17:31:07 +02:00
functionVariableUsage ( " char foo() \n "
" { \n "
" char buf[8]; \n "
" char *p = &buf[1]; \n "
" *--p = 0; \n "
" return buf[0]; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2010-06-18 07:19:26 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2010-05-05 17:31:07 +02:00
}
2014-11-20 14:20:09 +01:00
void localvaralias6 ( ) { // ticket 1729
2021-05-13 20:21:02 +02:00
// extracttests.start: int a(); void b(const char *);
2010-06-06 20:37:48 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
" char buf[8]; \n "
" char *srcdata; \n "
" if (a()) { \n "
" buf[0] = 1; \n "
" srcdata = buf; \n "
" } else { \n "
" srcdata = vdata; \n "
" } \n "
" b(srcdata); \n "
" } " ) ;
2010-07-07 08:26:24 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2010-06-06 20:37:48 +02:00
2010-07-08 07:59:47 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
" char buf[8]; \n "
" char *srcdata; \n "
" if (a()) { \n "
" buf[0] = 1; \n "
" srcdata = buf; \n "
" srcdata = vdata; \n "
" } \n "
" b(srcdata); \n "
" } " ) ;
2022-01-18 22:03:52 +01:00
TODO_ASSERT_EQUALS ( " [test.cpp:6]: (style) Variable 'buf' is assigned a value that is never used. \n " ,
" " ,
errout . str ( ) ) ;
2010-07-08 07:59:47 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
" char buf[8]; \n "
" char *srcdata; \n "
" if (a()) { \n "
" buf[0] = 1; \n "
" srcdata = buf; \n "
" } \n "
" srcdata = vdata; \n "
" b(srcdata); \n "
" } " ) ;
2022-01-18 22:03:52 +01:00
TODO_ASSERT_EQUALS ( " [test.cpp:6]: (style) Variable 'buf' is assigned a value that is never used. \n " ,
" " ,
errout . str ( ) ) ;
2010-07-08 07:59:47 +02:00
2021-05-13 20:21:02 +02:00
functionVariableUsage ( " void foo(char *vdata) \n "
2010-07-08 07:59:47 +02:00
" { \n "
" char buf[8]; \n "
" char *srcdata; \n "
" if (a()) { \n "
" srcdata = buf; \n "
" } \n "
" srcdata = vdata; \n "
" b(srcdata); \n "
" } " ) ;
2010-07-12 09:50:18 +02:00
ASSERT_EQUALS ( " [test.cpp:3]: (style) Unused variable: buf \n " , errout . str ( ) ) ;
2010-07-08 07:59:47 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
" char buf[8]; \n "
" char *srcdata; \n "
" if (a()) { \n "
" srcdata = vdata; \n "
" } \n "
" srcdata = buf; \n "
" b(srcdata); \n "
" } " ) ;
2010-07-12 09:50:18 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2010-07-08 07:59:47 +02:00
2010-06-06 20:37:48 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
" char buf[8]; \n "
" char *srcdata; \n "
" char vdata[8]; \n "
" if (a()) { \n "
" buf[0] = 1; \n "
" srcdata = buf; \n "
" } else { \n "
" srcdata = vdata; \n "
" } \n "
" b(srcdata); \n "
" } " ) ;
2010-07-07 08:26:24 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2010-07-08 07:59:47 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
" char buf[8]; \n "
" char *srcdata; \n "
" char vdata[8]; \n "
" if (a()) { \n "
" buf[0] = 1; \n "
" srcdata = buf; \n "
" srcdata = vdata; \n "
" } \n "
" b(srcdata); \n "
" } " ) ;
2022-01-18 22:03:52 +01:00
TODO_ASSERT_EQUALS ( " [test.cpp:7]: (style) Variable 'buf' is assigned a value that is never used. \n " ,
" " ,
errout . str ( ) ) ;
2010-07-08 07:59:47 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
" char buf[8]; \n "
" char *srcdata; \n "
" char vdata[8]; \n "
" if (a()) { \n "
" buf[0] = 1; \n "
" srcdata = buf; \n "
" } \n "
" srcdata = vdata; \n "
" b(srcdata); \n "
" } " ) ;
2022-01-18 22:03:52 +01:00
TODO_ASSERT_EQUALS ( " [test.cpp:7]: (style) Variable 'buf' is assigned a value that is never used. \n " ,
" " ,
errout . str ( ) ) ;
2010-07-08 07:59:47 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
" char buf[8]; \n "
" char *srcdata; \n "
" char vdata[8]; \n "
" if (a()) { \n "
" srcdata = buf; \n "
" } \n "
" srcdata = vdata; \n "
" b(srcdata); \n "
" } " ) ;
2010-07-12 09:50:18 +02:00
ASSERT_EQUALS ( " [test.cpp:3]: (style) Unused variable: buf \n " , errout . str ( ) ) ;
2010-07-08 07:59:47 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
" char buf[8]; \n "
" char *srcdata; \n "
" char vdata[8]; \n "
" if (a()) { \n "
" srcdata = vdata; \n "
" } \n "
" srcdata = buf; \n "
" b(srcdata); \n "
" } " ) ;
2010-07-12 09:50:18 +02:00
ASSERT_EQUALS ( " [test.cpp:5]: (style) Unused variable: vdata \n " , errout . str ( ) ) ;
2010-06-06 20:37:48 +02:00
}
2014-11-20 14:20:09 +01:00
void localvaralias7 ( ) { // ticket 1732
2010-06-23 06:54:14 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
" char *c[10]; \n "
" char **cp; \n "
" cp = c; \n "
" *cp = 0; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2014-11-20 14:20:09 +01:00
void localvaralias8 ( ) {
2010-07-12 09:50:18 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
" char b1[8]; \n "
" char b2[8]; \n "
" char b3[8]; \n "
" char b4[8]; \n "
" char *pb; \n "
" if (a == 1) \n "
" pb = b1; \n "
" else if (a == 2) \n "
" pb = b2; \n "
" else if (a == 3) \n "
" pb = b3; \n "
" else \n "
" pb = b4; \n "
" b(pb); \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
functionVariableUsage ( " void foo() \n "
" { \n "
" char b1[8]; \n "
" char b2[8]; \n "
" char b3[8]; \n "
" char b4[8]; \n "
" char *pb; \n "
" if (a == 1) \n "
" pb = b1; \n "
" else if (a == 2) \n "
" pb = b2; \n "
" else if (a == 3) \n "
" pb = b3; \n "
" else { \n "
" pb = b1; \n "
" pb = b4; \n "
" } \n "
" b(pb); \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
functionVariableUsage ( " void foo() \n "
" { \n "
" char b1[8]; \n "
" char b2[8]; \n "
" char b3[8]; \n "
" char b4[8]; \n "
" char *pb; \n "
" if (a == 1) \n "
" pb = b1; \n "
" else if (a == 2) \n "
" pb = b2; \n "
" else if (a == 3) \n "
" pb = b3; \n "
" else { \n "
" pb = b1; \n "
" pb = b2; \n "
" pb = b3; \n "
" pb = b4; \n "
" } \n "
" b(pb); \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
functionVariableUsage ( " void foo() \n "
" { \n "
" char b1[8]; \n "
" char b2[8]; \n "
" char b3[8]; \n "
" char b4[8]; \n "
" char *pb; \n "
" if (a == 1) \n "
" pb = b1; \n "
" else if (a == 2) \n "
" pb = b2; \n "
" else if (a == 3) \n "
" pb = b3; \n "
" pb = b4; \n "
" b(pb); \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:3]: (style) Unused variable: b1 \n "
" [test.cpp:4]: (style) Unused variable: b2 \n "
" [test.cpp:5]: (style) Unused variable: b3 \n " , errout . str ( ) ) ;
functionVariableUsage ( " void foo() \n "
" { \n "
" char b1[8]; \n "
" char b2[8]; \n "
" char b3[8]; \n "
" char b4[8]; \n "
" char *pb; \n "
" if (a == 1) \n "
" pb = b1; \n "
" else { \n "
" if (a == 2) \n "
" pb = b2; \n "
" else { \n "
" if (a == 3) \n "
" pb = b3; \n "
" else \n "
" pb = b4; \n "
" } \n "
" } \n "
" b(pb); \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
functionVariableUsage ( " void foo() \n "
" { \n "
" char b1[8]; \n "
" char b2[8]; \n "
" char b3[8]; \n "
" char b4[8]; \n "
" char *pb; \n "
" if (a == 1) \n "
" pb = b1; \n "
" else { \n "
" if (a == 2) \n "
" pb = b2; \n "
" else { \n "
" if (a == 3) \n "
" pb = b3; \n "
" else { \n "
" pb = b1; \n "
" pb = b4; \n "
" } \n "
" } \n "
" } \n "
" b(pb); \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
functionVariableUsage ( " void foo() \n "
" { \n "
" char b1[8]; \n "
" char b2[8]; \n "
" char b3[8]; \n "
" char b4[8]; \n "
" char *pb; \n "
" if (a == 1) \n "
" pb = b1; \n "
" else { \n "
" if (a == 2) \n "
" pb = b2; \n "
" else { \n "
" if (a == 3) \n "
" pb = b3; \n "
" else { \n "
" pb = b1; \n "
" pb = b2; \n "
" pb = b3; \n "
" pb = b4; \n "
" } \n "
" } \n "
" } \n "
" b(pb); \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
functionVariableUsage ( " void foo() \n "
" { \n "
" char b1[8]; \n "
" char b2[8]; \n "
" char b3[8]; \n "
" char b4[8]; \n "
" char *pb; \n "
" if (a == 1) \n "
" pb = b1; \n "
" else { \n "
" if (a == 2) \n "
" pb = b2; \n "
" else { \n "
" if (a == 3) \n "
" pb = b3; \n "
" } \n "
" } \n "
" pb = b4; \n "
" b(pb); \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:3]: (style) Unused variable: b1 \n "
" [test.cpp:4]: (style) Unused variable: b2 \n "
" [test.cpp:5]: (style) Unused variable: b3 \n " , errout . str ( ) ) ;
}
2014-11-20 14:20:09 +01:00
void localvaralias9 ( ) { // ticket 1996
2010-08-31 20:33:28 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
" Foo foo; \n "
" Foo &ref = foo; \n "
" ref[0] = 123; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2012-06-22 15:59:41 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
" Foo foo; \n "
" Foo &ref = foo; \n "
" ref[0] = 123; \n "
" } " ,
" test.c " ) ;
2022-01-18 22:03:52 +01:00
TODO_ASSERT_EQUALS ( " [test.c:5]: (style) Variable 'foo' is assigned a value that is never used. \n " ,
" " ,
errout . str ( ) ) ;
2010-08-31 20:33:28 +02:00
}
2014-11-20 14:20:09 +01:00
void localvaralias10 ( ) { // ticket 2004
2010-08-31 20:58:37 +02:00
functionVariableUsage ( " void foo(Foo &foo) \n "
" { \n "
" Foo &ref = foo; \n "
" int *x = &ref.x(); \n "
" *x = 0; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2012-06-22 15:59:41 +02:00
functionVariableUsage ( " void foo(Foo &foo) \n "
" { \n "
" Foo &ref = foo; \n "
" int *x = &ref.x; \n "
" *x = 0; \n "
" } " ,
" test.c " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2010-08-31 20:58:37 +02:00
}
2014-11-20 14:20:09 +01:00
void localvaralias11 ( ) { // #4423 - iterator
2013-02-16 16:07:05 +01:00
functionVariableUsage ( " void f(Foo &foo) { \n "
" std::set<int>::iterator x = foo.dostuff(); \n "
" *(x) = 0; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2014-11-20 14:20:09 +01:00
void localvaralias12 ( ) { // #4394
2013-02-20 17:43:16 +01:00
functionVariableUsage ( " void f(void) { \n "
" int a[4]; \n "
" int *b = (int*)((int*)a+1); \n "
" x(b); \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2013-03-04 19:13:49 +01:00
functionVariableUsage ( " int f(void) { \n " // #4628
" int x=1,y; \n "
" y = (x * a) / 100; \n "
" return y; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2013-03-04 19:13:49 +01:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2013-02-20 17:43:16 +01:00
}
2014-11-20 14:20:09 +01:00
void localvaralias13 ( ) { // #4487
2013-03-20 06:38:53 +01:00
functionVariableUsage ( " void f(char *p) { \n "
" char a[4]; \n "
" p = a; \n "
" strcpy(p, \" x \" ); \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
functionVariableUsage ( " void f(char *p) { \n "
" char a[4]; \n "
" p = a; \n "
" strcpy(p, \" x \" ); \n "
" } " ) ;
TODO_ASSERT_EQUALS ( " a is assigned value that is never used " , " " , errout . str ( ) ) ;
}
2017-07-09 11:19:00 +02:00
void localvaralias14 ( ) { // #5619
2019-01-13 07:59:41 +01:00
functionVariableUsage ( " char * dostuff(char *p); \n "
" void f() { \n "
" char a[4], *p=a; \n "
" p = dostuff(p); \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:4]: (style) Variable 'p' is assigned a value that is never used. \n " , errout . str ( ) ) ;
functionVariableUsage ( " char * dostuff(char *&p); \n "
" void f() { \n "
" char a[4], *p=a; \n "
" p = dostuff(p); \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ; // TODO: we can warn in this special case; variable is local and there are no function calls after the assignment
2017-07-09 11:19:00 +02:00
functionVariableUsage ( " void f() { \n "
" char a[4], *p=a; \n "
" p = dostuff(p); \n "
" } " ) ;
2019-01-13 07:59:41 +01:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ; // TODO: we can warn in this special case; variable is local and there are no function calls after the assignment
2017-07-09 11:19:00 +02:00
}
2017-07-23 23:32:14 +02:00
void localvaralias15 ( ) { // #6315
functionVariableUsage ( " void f() { \n "
" int x=3; \n "
" int *p = &x; \n "
" int *p2[1] = {p}; \n "
" dostuff(p2); \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2018-12-13 18:52:56 +01:00
void localvaralias16 ( ) {
functionVariableUsage ( " void f() { \n "
" auto x = dostuff(); \n "
" p = x; \n "
" x->data[0] = 9; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2018-12-30 20:20:20 +01:00
void localvaralias17 ( ) {
functionVariableUsage ( " void f() { \n "
" int x; \n "
" unknown_type p = &x; \n "
" *p = 9; \n "
" } " , " test.c " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2019-08-04 10:21:16 +02:00
void localvaralias18 ( ) {
functionVariableUsage ( " void add( std::vector< std::pair< int, double > >& v) \n "
" { \n "
" std::vector< std::pair< int, double > >::iterator it; \n "
" for ( it = v.begin(); it != v.end(); ++it ) \n "
" { \n "
" if ( x ) \n "
" { \n "
" ( *it ).second = 0; \n "
" break; \n "
" } \n "
" } \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2022-01-24 21:52:45 +01:00
void localvaralias19 ( ) { // #9828
functionVariableUsage ( " void f() { \n "
" bool b0{}, b1{}; \n "
" struct { \n "
" bool* pb; \n "
" int val; \n "
" } Map[] = { {&b0, 0}, {&b1, 1} }; \n "
" b0 = true; \n "
" for (auto & m : Map) \n "
" if (m.pb && *m.pb) \n "
" m.val = 1; \n "
" } \n " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2014-11-20 14:20:09 +01:00
void localvarasm ( ) {
2018-12-13 18:52:56 +01:00
2010-03-31 20:20:51 +02:00
functionVariableUsage ( " void foo(int &b) \n "
" { \n "
" int a; \n "
" asm(); \n "
" b = a; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2010-06-18 07:19:26 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2010-03-31 20:20:51 +02:00
}
2014-11-20 14:20:09 +01:00
void localvarStruct1 ( ) {
2010-02-18 18:45:13 +01:00
functionVariableUsage ( " void foo() \n "
" { \n "
" static const struct{ int x, y, w, h; } bounds = {1,2,3,4}; \n "
" return bounds.x + bounds.y + bounds.w + bounds.h; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2010-06-18 07:19:26 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2010-02-18 18:45:13 +01:00
}
2014-11-20 14:20:09 +01:00
void localvarStruct2 ( ) {
2010-02-18 18:45:13 +01:00
functionVariableUsage ( " void foo() \n "
" { \n "
" struct ABC { int a, b, c; }; \n "
" struct ABC abc = { 1, 2, 3 }; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-11-01 18:40:20 +01:00
ASSERT_EQUALS ( " [test.cpp:4]: (style) Variable 'abc' is assigned a value that is never used. \n " , errout . str ( ) ) ;
2010-02-18 18:45:13 +01:00
}
2014-11-20 14:20:09 +01:00
void localvarStruct3 ( ) {
2010-02-18 18:45:13 +01:00
functionVariableUsage ( " void foo() \n "
" { \n "
" int a = 10; \n "
" union { struct { unsigned char x; }; unsigned char z; }; \n "
" do { \n "
" func(); \n "
" } while(a--); \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2010-09-09 20:15:00 +02:00
TODO_ASSERT_EQUALS ( " [test.cpp:4]: (style) Unused variable: x \n "
2011-12-18 20:15:41 +01:00
" [test.cpp:4]: (style) Unused variable: z \n " , " " , errout . str ( ) ) ;
2010-02-18 18:45:13 +01:00
}
2014-11-20 14:20:09 +01:00
void localvarStruct5 ( ) {
2021-05-13 20:21:02 +02:00
// extracttests.disable
2011-07-01 03:58:11 +02:00
functionVariableUsage ( " int foo() { \n "
" A a; \n "
" return a.i; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2011-07-01 03:58:11 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
functionVariableUsage ( " int foo() { \n "
" A a; \n "
" return 0; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2011-07-01 03:58:11 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2012-06-22 15:59:41 +02:00
functionVariableUsage ( " int foo() { \n "
" A a; \n "
" return 0; \n "
" } \n " ,
" test.c " ) ;
ASSERT_EQUALS ( " [test.c:2]: (style) Unused variable: a \n " , errout . str ( ) ) ;
2021-05-13 20:21:02 +02:00
// extracttests.enable
2012-06-22 15:59:41 +02:00
2011-07-01 03:58:11 +02:00
functionVariableUsage ( " struct A { int i; }; \n "
" int foo() { \n "
" A a; \n "
" return a.i; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2011-07-01 03:58:11 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
functionVariableUsage ( " struct A { int i; }; \n "
" int foo() { \n "
" A a; \n "
" a.i = 0; \n "
" return 0; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2018-12-13 18:52:56 +01:00
ASSERT_EQUALS ( " [test.cpp:4]: (style) Variable 'a.i' is assigned a value that is never used. \n " , errout . str ( ) ) ;
2011-07-01 03:58:11 +02:00
functionVariableUsage ( " struct A { int i; }; \n "
" int foo() { \n "
" A a = { 0 }; \n "
" return 0; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-11-01 18:40:20 +01:00
ASSERT_EQUALS ( " [test.cpp:3]: (style) Variable 'a' is assigned a value that is never used. \n " , errout . str ( ) ) ;
2011-07-01 03:58:11 +02:00
2021-05-13 20:21:02 +02:00
// extracttests.disable
2011-07-01 03:58:11 +02:00
functionVariableUsage ( " class A { int i; }; \n "
" int foo() { \n "
" A a = { 0 }; \n "
" return 0; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-11-01 18:40:20 +01:00
ASSERT_EQUALS ( " [test.cpp:3]: (style) Variable 'a' is assigned a value that is never used. \n " , errout . str ( ) ) ;
2021-05-13 20:21:02 +02:00
// extracttests.enable
2011-07-01 03:58:11 +02:00
functionVariableUsage ( " class A { int i; public: A(); { } }; \n "
" int foo() { \n "
" A a; \n "
" return 0; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2011-07-01 03:58:11 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
functionVariableUsage ( " struct A { int i; }; \n "
" int foo() { \n "
" A a; \n "
" return 0; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2011-07-01 03:58:11 +02:00
ASSERT_EQUALS ( " [test.cpp:3]: (style) Unused variable: a \n " , errout . str ( ) ) ;
functionVariableUsage ( " class A { int i; }; \n "
" int foo() { \n "
" A a; \n "
" return 0; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2011-07-01 03:58:11 +02:00
ASSERT_EQUALS ( " [test.cpp:3]: (style) Unused variable: a \n " , errout . str ( ) ) ;
functionVariableUsage ( " class A { int i; public: A(); { } }; \n "
" int foo() { \n "
" A a; \n "
" return 0; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2011-07-01 03:58:11 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
functionVariableUsage ( " class A { unknown i; }; \n "
" int foo() { \n "
" A a; \n "
" return 0; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2011-07-01 03:58:11 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
functionVariableUsage ( " class A : public Fred { int i; }; \n "
" int foo() { \n "
" A a; \n "
" return 0; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2011-07-01 03:58:11 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2012-08-20 16:55:39 +02:00
functionVariableUsage ( " class Fred {char c;}; \n "
" class A : public Fred { int i; }; \n "
" int foo() { \n "
" A a; \n "
" return 0; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-08-20 16:55:39 +02:00
ASSERT_EQUALS ( " [test.cpp:4]: (style) Unused variable: a \n " , errout . str ( ) ) ;
2011-07-01 03:58:11 +02:00
}
2014-11-20 14:20:09 +01:00
void localvarStruct6 ( ) {
2011-07-01 14:45:29 +02:00
functionVariableUsage ( " class Type { }; \n "
" class A { \n "
" public: \n "
" Type & get() { return t; } \n "
" private: \n "
" Type t; \n "
2013-03-20 15:36:16 +01:00
" }; " ) ;
2011-07-01 14:45:29 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2018-12-15 11:54:00 +01:00
void localvarStruct7 ( ) {
functionVariableUsage ( " struct IMAPARG { \n "
" void *text; \n "
" }; \n "
" \n "
" void fun() { \n "
" IMAPARG *args, aatt; \n "
" args = &aatt; \n "
" aatt.text = tmp; \n "
" dostuff(args); \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2021-05-13 20:21:02 +02:00
// extracttests.start: void dostuff(int*);
2018-12-15 11:54:00 +01:00
functionVariableUsage ( " struct ARG { \n "
2021-05-13 20:21:02 +02:00
" int a; \n "
" int b; \n "
2018-12-15 11:54:00 +01:00
" }; \n "
" \n "
" void fun() { \n "
" ARG aatt; \n "
" int *p = &aatt.b; \n "
" aatt.a = 123; \n "
" dostuff(p); \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:9]: (style) Variable 'aatt.a' is assigned a value that is never used. \n " , errout . str ( ) ) ;
functionVariableUsage ( " struct AB { \n "
" int a; \n "
" int b; \n "
" }; \n "
" \n "
" void fun() { \n "
" AB ab; \n "
" int &a = ab.a; \n "
" ab.a = 123; \n "
" dostuff(a); \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2019-12-20 18:31:44 +01:00
void localvarStruct8 ( ) {
functionVariableUsage ( " struct s { \n "
" union { \n "
" struct { \n "
" int fld1 : 16; \n "
" int fld2 : 16; \n "
" }; \n "
" int raw; \n "
" }; \n "
" }; \n "
" \n "
" void foo() { \n "
" struct s test; \n "
" test.raw = 0x100; \n "
" dostuff(test.fld1, test.fld2); \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2020-02-15 16:43:06 +01:00
void localvarStruct9 ( ) {
functionVariableUsage ( " struct XY { int x; int y; }; \n "
" \n "
" void foo() { \n "
" struct XY xy(get()); \n "
" return xy.x + xy.y; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2021-05-09 20:09:10 +02:00
void localvarStruct10 ( ) { // #6766
functionVariableUsage ( " struct S { int x; }; \n "
" \n "
2021-05-13 20:21:02 +02:00
" void foo(const struct S s2) { \n "
2021-05-09 20:09:10 +02:00
" struct S s; \n "
" s.x = 3; \n "
" memcpy (&s, &s2, sizeof (S)); \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:5]: (style) Variable 's.x' is assigned a value that is never used. \n " , errout . str ( ) ) ;
}
2021-08-27 17:37:30 +02:00
void localvarStruct11 ( ) { // #10095
functionVariableUsage ( " struct Point { int x; int y; }; \n "
" Point scale(Point *p); \n "
" \n "
" int foo() { \n "
" Point p; \n "
" p.x = 42; \n "
" return scale(&p).y; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2021-09-24 07:30:17 +02:00
void localvarStruct12 ( ) { // #10495
functionVariableUsage ( " struct S { bool& Ref(); }; \n "
" \n "
" void Set() { \n "
" S s; \n "
" s.Ref() = true; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2022-01-25 22:05:54 +01:00
void localvarStruct13 ( ) { // #10398
functionVariableUsage ( " int f() { \n "
" std::vector<std::string> Mode; \n "
" Info Block = { \n "
" { \n "
" { &Mode }, \n "
" { &Level } \n "
" } \n "
" }; \n "
" Mode.resize(N); \n "
" for (int i = 0; i < N; ++i) \n "
" Mode[i] = \" abc \" ; \n "
" return Save(&Block); \n "
" } \n " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2014-11-20 14:20:09 +01:00
void localvarStructArray ( ) {
2021-05-13 20:21:02 +02:00
// extracttests.start: struct X {int a;};
2012-02-26 08:29:02 +01:00
// #3633 - detect that struct array is assigned a value
functionVariableUsage ( " void f() { \n "
" struct X x[10]; \n "
2018-12-13 18:52:56 +01:00
" x[0].a = 5; \n "
2012-02-26 08:29:02 +01:00
" } " ) ;
2018-12-13 18:52:56 +01:00
ASSERT_EQUALS ( " [test.cpp:3]: (style) Variable 'x[0].a' is assigned a value that is never used. \n " , errout . str ( ) ) ;
2012-02-26 08:29:02 +01:00
}
2020-10-02 20:22:09 +02:00
void localvarUnion1 ( ) {
// #9707
functionVariableUsage ( " static short read(FILE *fp) { \n "
" typedef union { short s; unsigned char c[2]; } u; \n "
" u x; \n "
" x.c[0] = fgetuc(fp); \n "
" x.c[1] = fgetuc(fp); \n "
" return x.s; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2014-11-20 14:20:09 +01:00
void localvarOp ( ) {
2010-02-18 18:45:13 +01:00
const char op [ ] = " +-*/%&|^ " ;
2011-10-13 20:53:06 +02:00
for ( const char * p = op ; * p ; + + p ) {
2010-02-18 18:45:13 +01:00
std : : string code ( " int main() \n "
" { \n "
" int tmp = 10; \n "
" return 123 " + std : : string ( 1 , * p ) + " tmp; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2010-02-18 18:45:13 +01:00
functionVariableUsage ( code . c_str ( ) ) ;
2010-06-18 07:19:26 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2010-02-18 18:45:13 +01:00
}
}
2014-11-20 14:20:09 +01:00
void localvarInvert ( ) {
2010-02-18 18:45:13 +01:00
functionVariableUsage ( " int main() \n "
" { \n "
" int tmp = 10; \n "
" return ~tmp; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2010-06-18 07:19:26 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2010-02-18 18:45:13 +01:00
}
2014-11-20 14:20:09 +01:00
void localvarIf ( ) {
2010-02-18 18:45:13 +01:00
functionVariableUsage ( " int main() \n "
" { \n "
" int tmp = 10; \n "
" if ( tmp ) \n "
" return 1; \n "
" return 0; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2010-06-18 07:19:26 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2010-02-18 18:45:13 +01:00
}
2014-11-20 14:20:09 +01:00
void localvarIfElse ( ) {
2010-02-18 18:45:13 +01:00
functionVariableUsage ( " int foo() \n "
" { \n "
" int tmp1 = 1; \n "
" int tmp2 = 2; \n "
" int tmp3 = 3; \n "
" return tmp1 ? tmp2 : tmp3; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2010-06-18 07:19:26 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2010-02-18 18:45:13 +01:00
}
2021-04-26 07:38:03 +02:00
void localvarDeclaredInIf ( ) {
functionVariableUsage ( " int foo(int x) \n "
" { \n "
" if (int y = x % 2) \n "
" return 2; \n "
" else \n "
" return 1; \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:3]: (style) Variable 'y' is assigned a value that is never used. \n " , errout . str ( ) ) ;
functionVariableUsage ( " int foo(int x) \n "
" { \n "
" if (int y = x % 2) \n "
" return y; \n "
" else \n "
" return 1; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
functionVariableUsage ( " int foo(int x) \n "
" { \n "
" if (int y = x % 2) \n "
" return 2; \n "
" else \n "
" return y; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2014-11-20 14:20:09 +01:00
void localvarOpAssign ( ) {
2010-02-18 18:45:13 +01:00
functionVariableUsage ( " void foo() \n "
" { \n "
" int a = 1; \n "
" int b = 2; \n "
" a |= b; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2018-12-27 17:27:51 +01:00
ASSERT_EQUALS ( " [test.cpp:3]: (style) Variable 'a' is assigned a value that is never used. \n "
" [test.cpp:5]: (style) Variable 'a' is assigned a value that is never used. \n " , errout . str ( ) ) ;
2011-05-06 21:16:01 +02:00
functionVariableUsage ( " void foo() { \n "
" int a = 1; \n "
" (b).x += a; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2011-05-06 21:16:01 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2015-12-31 01:15:49 +01:00
functionVariableUsage ( " void foo() { \n "
" int a=1, b[10]; \n "
" b[0] = x; \n "
" a += b[0]; \n "
" return a; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
functionVariableUsage ( " void f(int *start, int *stop) { \n "
" int length = *start - *stop; \n "
" if (length < 10000) \n "
" length = 10000; \n "
" *stop -= length; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
functionVariableUsage ( " void f(int a) { \n "
" int x = 3; \n "
" a &= ~x; \n "
" return a; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2015-12-31 15:30:33 +01:00
2021-05-13 20:21:02 +02:00
// extracttests.disable
2019-11-17 12:08:21 +01:00
functionVariableUsage ( " void f() { \n " // unknown class => library configuration is needed
2015-12-31 15:30:33 +01:00
" Fred fred; \n "
" int *a; a = b; \n "
" fred += a; \n "
" } " ) ;
2019-11-17 12:08:21 +01:00
ASSERT_EQUALS ( " [test.cpp:4]: (information) --check-library: Provide <type-checks><unusedvar> configuration for Fred \n " , errout . str ( ) ) ;
2021-05-13 20:21:02 +02:00
// extracttests.enable
2019-11-17 12:08:21 +01:00
2021-05-13 20:21:02 +02:00
functionVariableUsage ( " void f(std::pair<int,int> x) { \n "
2019-11-17 12:08:21 +01:00
" std::pair<int,int> fred; \n " // class with library configuration
" fred = x; \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:3]: (style) Variable 'fred' is assigned a value that is never used. \n " , errout . str ( ) ) ;
2010-02-18 18:45:13 +01:00
}
2014-11-20 14:20:09 +01:00
void localvarFor ( ) {
2010-02-18 18:45:13 +01:00
functionVariableUsage ( " void foo() \n "
" { \n "
" int a = 1; \n "
" for (;a;); \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2010-06-18 07:19:26 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2011-12-18 20:15:41 +01:00
functionVariableUsage ( " void foo() { \n "
" for (int i = 0; (pci = cdi_list_get(pciDevices, i)); i++) \n "
" {} \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2010-02-18 18:45:13 +01:00
}
2014-11-20 14:20:09 +01:00
void localvarForEach ( ) { // #4155 - foreach
2012-12-17 17:07:56 +01:00
functionVariableUsage ( " void foo() { \n "
" int i = -1; \n "
" int a[] = {1,2,3}; \n "
" FOREACH_X (int x, a) { \n "
" if (i==x) return x; \n "
" i = x; \n "
" } \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-12-17 17:07:56 +01:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2012-12-17 18:19:05 +01:00
2013-12-17 06:34:27 +01:00
// #5154 - MSVC 'for each'
functionVariableUsage ( " void f() { \n "
" std::map<int,int> ints; \n "
" ints[0]= 1; \n "
" for each(std::pair<int,int> i in ints) { x += i.first; } \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2012-12-17 17:07:56 +01:00
}
2014-11-20 14:20:09 +01:00
void localvarShift1 ( ) {
2010-02-18 18:45:13 +01:00
functionVariableUsage ( " int foo() \n "
" { \n "
" int var = 1; \n "
" return 1 >> var; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2010-06-18 07:19:26 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2010-02-18 19:55:47 +01:00
}
2014-11-20 14:20:09 +01:00
void localvarShift3 ( ) { // #3509
2012-01-23 08:02:59 +01:00
functionVariableUsage ( " int foo() \n "
" { \n "
" QList<int *> ints; \n "
" ints << 1; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-01-23 08:02:59 +01:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2012-12-18 19:02:30 +01:00
functionVariableUsage ( " int foo() { \n " // #4320
" int x; \n "
" x << 1; \n "
" return x; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-12-18 19:02:30 +01:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2012-01-23 08:02:59 +01:00
}
2014-11-20 14:20:09 +01:00
void localvarCast ( ) {
2010-05-09 07:15:40 +02:00
functionVariableUsage ( " int foo() \n "
" { \n "
" int a = 1; \n "
" int b = static_cast<int>(a); \n "
" return b; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2010-06-18 07:19:26 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2010-05-09 07:15:40 +02:00
}
2014-11-20 14:20:09 +01:00
void localvarClass ( ) {
2010-06-10 07:21:47 +02:00
functionVariableUsage ( " int foo() \n "
" { \n "
" class B : public A { \n "
" int a; \n "
" int f() { return a; } \n "
" } b; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2010-06-18 07:19:26 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2010-06-10 07:21:47 +02:00
}
2010-06-14 15:46:57 +02:00
2014-11-20 14:20:09 +01:00
void localvarUnused ( ) {
2010-06-14 15:46:57 +02:00
functionVariableUsage ( " int foo() \n "
" { \n "
" bool test __attribute__((unused)); \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2010-06-18 07:19:26 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2010-06-14 15:46:57 +02:00
functionVariableUsage ( " int foo() \n "
" { \n "
" bool test __attribute__((unused)) = true; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2010-06-18 07:19:26 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2010-06-16 18:04:31 +02:00
functionVariableUsage ( " int foo() \n "
" { \n "
" bool __attribute__((unused)) test; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2010-06-18 07:19:26 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2010-06-16 18:04:31 +02:00
functionVariableUsage ( " int foo() \n "
" { \n "
" bool __attribute__((unused)) test = true; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2010-06-18 07:19:26 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2014-08-06 11:13:58 +02:00
functionVariableUsage ( " int foo() \n "
" { \n "
" bool test __attribute__((used)); \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
functionVariableUsage ( " int foo() \n "
" { \n "
" bool __attribute__((used)) test; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2010-06-14 15:46:57 +02:00
}
2010-06-21 18:12:01 +02:00
2014-11-20 14:20:09 +01:00
void localvarFunction ( ) {
2010-06-21 18:12:01 +02:00
functionVariableUsage ( " void check_dlsym(void*& h) \n "
" { \n "
" typedef void (*function_type) (void); \n "
" function_type fn; \n "
" fn = reinterpret_cast<function_type>(dlsym(h, \" try_allocation \" )); \n "
" fn(); \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2010-06-24 17:00:32 +02:00
2014-11-20 14:20:09 +01:00
void localvarstatic ( ) {
2010-06-24 17:00:32 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
" static int i; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2018-12-13 18:52:56 +01:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2010-06-24 17:00:32 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
" static int i = 0; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2022-01-18 22:03:52 +01:00
TODO_ASSERT_EQUALS ( " [test.cpp:3]: (style) Variable 'i' is assigned a value that is never used. \n " ,
" " ,
errout . str ( ) ) ;
2010-06-24 17:00:32 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
" static int i(0); \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2022-01-18 22:03:52 +01:00
TODO_ASSERT_EQUALS ( " [test.cpp:3]: (style) Variable 'i' is assigned a value that is never used. \n " ,
" " ,
errout . str ( ) ) ;
2010-06-24 17:00:32 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
" static int j = 0; \n "
" static int i(j); \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2022-01-18 22:03:52 +01:00
TODO_ASSERT_EQUALS ( " [test.cpp:4]: (style) Variable 'i' is assigned a value that is never used. \n " ,
" " ,
errout . str ( ) ) ;
2010-06-24 17:00:32 +02:00
functionVariableUsage ( " int * foo(int x) \n "
" { \n "
" static int a[] = { 3, 4, 5, 6 }; \n "
" static int b[] = { 4, 5, 6, 7 }; \n "
" static int c[] = { 5, 6, 7, 8 }; \n "
" b[1] = 1; \n "
" return x ? a : c; \n "
" } " ) ;
2022-01-18 22:03:52 +01:00
TODO_ASSERT_EQUALS ( " [test.cpp:6]: (style) Variable 'b' is assigned a value that is never used. \n " ,
" " ,
errout . str ( ) ) ;
2012-09-11 14:14:35 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
" static int i = 0; \n "
" if(i < foo()) \n "
" i += 5; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2016-10-10 21:27:40 +02:00
functionVariableUsage ( " void foo() { \n "
" static int x = 0; \n "
" print(x); \n "
" if(x > 5) \n "
" x = 0; \n "
" else \n "
" x++; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2019-11-04 17:59:16 +01:00
functionVariableUsage ( " void foo(int value) { \n "
" static int array[16] = {0}; \n "
" if(array[value]) {} \n "
" array[value] = 1; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2010-06-24 17:00:32 +02:00
}
2010-11-15 02:37:36 +01:00
2014-11-20 14:20:09 +01:00
void localvarextern ( ) {
2012-06-28 17:22:56 +02:00
functionVariableUsage ( " void foo() { \n "
" extern int i; \n "
" i = 0; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-06-28 17:22:56 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2014-11-20 14:20:09 +01:00
void localvardynamic1 ( ) {
2010-11-15 02:37:36 +01:00
functionVariableUsage ( " void foo() \n "
" { \n "
" void* ptr = malloc(16); \n "
" free(ptr); \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-11-01 18:40:20 +01:00
ASSERT_EQUALS ( " [test.cpp:3]: (style) Variable 'ptr' is allocated memory that is never used. \n " , errout . str ( ) ) ;
2010-11-15 02:37:36 +01:00
functionVariableUsage ( " void foo() \n "
" { \n "
" char* ptr = new char[16]; \n "
" delete[] ptr; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-11-01 18:40:20 +01:00
ASSERT_EQUALS ( " [test.cpp:3]: (style) Variable 'ptr' is allocated memory that is never used. \n " , errout . str ( ) ) ;
2010-11-15 02:37:36 +01:00
2021-05-13 20:21:02 +02:00
// extracttests.disable
2011-08-31 12:39:39 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
" char* ptr = new ( nothrow ) char[16]; \n "
" delete[] ptr; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-11-01 18:40:20 +01:00
ASSERT_EQUALS ( " [test.cpp:3]: (style) Variable 'ptr' is allocated memory that is never used. \n " , errout . str ( ) ) ;
2011-08-31 12:39:39 +02:00
functionVariableUsage ( " void foo() \n "
" { \n "
" char* ptr = new ( std::nothrow ) char[16]; \n "
" delete[] ptr; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-11-01 18:40:20 +01:00
ASSERT_EQUALS ( " [test.cpp:3]: (style) Variable 'ptr' is allocated memory that is never used. \n " , errout . str ( ) ) ;
2011-08-31 12:39:39 +02:00
2021-05-13 20:21:02 +02:00
// extracttests.enable
2010-11-15 02:37:36 +01:00
functionVariableUsage ( " void foo() \n "
" { \n "
" char* ptr = new char; \n "
" delete ptr; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-11-01 18:40:20 +01:00
ASSERT_EQUALS ( " [test.cpp:3]: (style) Variable 'ptr' is allocated memory that is never used. \n " , errout . str ( ) ) ;
2010-11-15 02:37:36 +01:00
functionVariableUsage ( " void foo() \n "
" { \n "
" void* ptr = malloc(16); \n "
" ptr[0] = 123; \n "
" free(ptr); \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2010-11-15 02:37:36 +01:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
functionVariableUsage ( " void foo() \n "
" { \n "
" char* ptr = new char[16]; \n "
" ptr[0] = 123; \n "
" delete[] ptr; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2010-11-15 02:37:36 +01:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
functionVariableUsage ( " void foo() \n "
" { \n "
2010-12-21 08:13:40 +01:00
" Fred* fred = new Fred; \n "
" std::cout << \" test \" << std::endl; \n "
" delete fred; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2010-12-21 08:13:40 +01:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
functionVariableUsage ( " struct Fred { int a; }; \n "
" void foo() \n "
" { \n "
" Fred* fred = new Fred; \n "
" std::cout << \" test \" << std::endl; \n "
" delete fred; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-11-01 18:40:20 +01:00
ASSERT_EQUALS ( " [test.cpp:4]: (style) Variable 'fred' is allocated memory that is never used. \n " , errout . str ( ) ) ;
2010-12-21 08:13:40 +01:00
functionVariableUsage ( " struct Fred { int a; Fred() : a(0) {} }; \n "
" void foo() \n "
" { \n "
2010-12-20 18:31:16 +01:00
" Fred* fred = new Fred; \n "
2010-11-15 02:37:36 +01:00
" std::cout << \" test \" << std::endl; \n "
2010-12-20 18:31:16 +01:00
" delete fred; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2020-10-25 07:11:45 +01:00
ASSERT_EQUALS ( " [test.cpp:4]: (style) Variable 'fred' is allocated memory that is never used. \n " , errout . str ( ) ) ;
2010-12-20 18:31:16 +01:00
functionVariableUsage ( " void foo() \n "
" { \n "
" Fred* fred = malloc(sizeof(Fred)); \n "
" std::cout << \" test \" << std::endl; \n "
" free(fred); \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-11-01 18:40:20 +01:00
ASSERT_EQUALS ( " [test.cpp:3]: (style) Variable 'fred' is allocated memory that is never used. \n " , errout . str ( ) ) ;
2010-11-15 02:37:36 +01:00
functionVariableUsage ( " void foo() \n "
" { \n "
" char* ptr = names[i]; \n "
" delete[] ptr; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2010-11-15 02:37:36 +01:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2011-05-11 18:58:25 +02:00
}
2010-11-15 02:37:36 +01:00
2014-11-20 14:20:09 +01:00
void localvardynamic2 ( ) {
2011-07-15 01:15:59 +02:00
functionVariableUsage ( " struct Fred { int i; }; \n "
" void foo() \n "
" { \n "
2021-05-13 20:21:02 +02:00
" Fred* ptr = (Fred*)malloc(sizeof(Fred)); \n "
2011-07-15 01:15:59 +02:00
" free(ptr); \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-11-01 18:40:20 +01:00
ASSERT_EQUALS ( " [test.cpp:4]: (style) Variable 'ptr' is allocated memory that is never used. \n " , errout . str ( ) ) ;
2011-07-15 01:15:59 +02:00
functionVariableUsage ( " struct Fred { int i; }; \n "
" void foo() \n "
" { \n "
2021-05-13 20:21:02 +02:00
" Fred* ptr = (Fred*)malloc(sizeof(Fred)); \n "
2011-07-15 01:15:59 +02:00
" ptr->i = 0; \n "
" free(ptr); \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2011-07-15 01:15:59 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
functionVariableUsage ( " struct Fred { int i; }; \n "
" void foo() \n "
" { \n "
2021-05-13 20:21:02 +02:00
" struct Fred* ptr = (Fred*)malloc(sizeof(Fred)); \n "
2011-07-15 01:15:59 +02:00
" free(ptr); \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-11-01 18:40:20 +01:00
ASSERT_EQUALS ( " [test.cpp:4]: (style) Variable 'ptr' is allocated memory that is never used. \n " , errout . str ( ) ) ;
2011-07-15 01:15:59 +02:00
functionVariableUsage ( " struct Fred { int i; }; \n "
" void foo() \n "
" { \n "
2021-05-13 20:21:02 +02:00
" struct Fred* ptr = (Fred*)malloc(sizeof(Fred)); \n "
2011-07-15 01:15:59 +02:00
" ptr->i = 0; \n "
" free(ptr); \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2011-07-15 01:15:59 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
functionVariableUsage ( " struct Fred { int i; }; \n "
" void foo() \n "
" { \n "
" Fred* ptr = new Fred(); \n "
" delete ptr; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-11-01 18:40:20 +01:00
ASSERT_EQUALS ( " [test.cpp:4]: (style) Variable 'ptr' is allocated memory that is never used. \n " , errout . str ( ) ) ;
2011-07-15 01:15:59 +02:00
2021-05-13 20:21:02 +02:00
// extracttests.disable
2011-08-31 12:39:39 +02:00
functionVariableUsage ( " struct Fred { int i; }; \n "
" void foo() \n "
" { \n "
" Fred* ptr = new (nothrow ) Fred(); \n "
" delete ptr; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-11-01 18:40:20 +01:00
ASSERT_EQUALS ( " [test.cpp:4]: (style) Variable 'ptr' is allocated memory that is never used. \n " , errout . str ( ) ) ;
2011-08-31 12:39:39 +02:00
functionVariableUsage ( " struct Fred { int i; }; \n "
" void foo() \n "
" { \n "
" Fred* ptr = new (std::nothrow) Fred(); \n "
" delete ptr; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-11-01 18:40:20 +01:00
ASSERT_EQUALS ( " [test.cpp:4]: (style) Variable 'ptr' is allocated memory that is never used. \n " , errout . str ( ) ) ;
2011-08-31 12:39:39 +02:00
2021-05-13 20:21:02 +02:00
// extracttests.enable
2011-07-15 01:15:59 +02:00
functionVariableUsage ( " struct Fred { int i; }; \n "
" void foo() \n "
" { \n "
" Fred* ptr = new Fred(); \n "
" ptr->i = 0; \n "
" delete ptr; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2011-07-15 01:15:59 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
functionVariableUsage ( " struct Fred { int i; }; \n "
" void foo() \n "
" { \n "
" struct Fred* ptr = new Fred(); \n "
2021-05-14 14:01:39 +02:00
" delete ptr; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-11-01 18:40:20 +01:00
ASSERT_EQUALS ( " [test.cpp:4]: (style) Variable 'ptr' is allocated memory that is never used. \n " , errout . str ( ) ) ;
2011-07-15 01:15:59 +02:00
functionVariableUsage ( " struct Fred { int i; }; \n "
" void foo() \n "
" { \n "
" struct Fred* ptr = new Fred(); \n "
" ptr->i = 0; \n "
" free(ptr); \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2011-07-15 01:15:59 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
functionVariableUsage ( " class Fred { public: int i; }; \n "
" void foo() \n "
" { \n "
2021-05-13 20:21:02 +02:00
" Fred* ptr = (Fred*)malloc(sizeof(Fred)); \n "
2011-07-15 01:15:59 +02:00
" free(ptr); \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-11-01 18:40:20 +01:00
ASSERT_EQUALS ( " [test.cpp:4]: (style) Variable 'ptr' is allocated memory that is never used. \n " , errout . str ( ) ) ;
2011-07-15 01:15:59 +02:00
functionVariableUsage ( " class Fred { public: int i; }; \n "
" void foo() \n "
" { \n "
2021-05-13 20:21:02 +02:00
" Fred* ptr = (Fred*)malloc(sizeof(Fred)); \n "
2011-07-15 01:15:59 +02:00
" ptr->i = 0; \n "
" free(ptr); \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2011-07-15 01:15:59 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
functionVariableUsage ( " class Fred { public: int i; }; \n "
" void foo() \n "
" { \n "
" Fred* ptr = new Fred(); \n "
" delete ptr; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-11-01 18:40:20 +01:00
ASSERT_EQUALS ( " [test.cpp:4]: (style) Variable 'ptr' is allocated memory that is never used. \n " , errout . str ( ) ) ;
2011-07-15 01:15:59 +02:00
functionVariableUsage ( " class Fred { public: int i; }; \n "
" void foo() \n "
" { \n "
" Fred* ptr = new Fred(); \n "
" ptr->i = 0; \n "
" delete ptr; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-01-08 08:31:00 +01:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2014-11-20 14:20:09 +01:00
void localvardynamic3 ( ) {
2016-10-10 21:27:40 +02:00
// Ticket #3467 - False positive that 'data' is not assigned a value
2012-01-08 08:31:00 +01:00
functionVariableUsage ( " void foo() { \n "
" int* data = new int[100]; \n "
" int* p = data; \n "
" for ( int i = 0; i < 10; ++i ) \n "
" p++; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2022-01-18 22:03:52 +01:00
TODO_ASSERT_EQUALS ( " [test.cpp:5]: (style) Variable 'p' is modified but its new value is never used. \n " ,
" " ,
errout . str ( ) ) ;
2011-07-15 01:15:59 +02:00
}
2014-11-20 14:20:09 +01:00
void localvararray1 ( ) {
2011-05-11 18:58:25 +02:00
functionVariableUsage ( " void foo() { \n "
" int p[5]; \n "
" *p = 0; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2011-05-11 18:58:25 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2010-11-15 02:37:36 +01:00
}
2011-07-03 01:25:10 +02:00
2014-11-20 14:20:09 +01:00
void localvararray2 ( ) {
2011-12-26 08:12:23 +01:00
functionVariableUsage ( " int foo() { \n "
" int p[5][5]; \n "
" p[0][0] = 0; \n "
" return p[0][0]; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2011-12-26 08:12:23 +01:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2014-11-20 14:20:09 +01:00
void localvararray3 ( ) {
2012-08-25 13:07:33 +02:00
functionVariableUsage ( " int foo() { \n "
" int p[5][5]; \n "
" *((int*)p[0]) = 0; \n "
" return p[0][0]; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-08-25 13:07:33 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2016-05-17 16:03:55 +02:00
void localvararray4 ( ) {
functionVariableUsage ( " void foo() { \n "
" int p[1]; \n "
" int *pp[0]; \n "
" p[0] = 1; \n "
" *pp[0] = p[0]; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2017-06-03 15:31:29 +02:00
void localvararray5 ( ) {
functionVariableUsage ( " int foo() { \n "
" int p[5][5]; \n "
" dostuff(*p); \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2014-11-20 14:20:09 +01:00
void localvarstring1 ( ) { // ticket #1597
2011-07-03 01:25:10 +02:00
functionVariableUsage ( " void foo() { \n "
" std::string s; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2011-07-03 01:25:10 +02:00
ASSERT_EQUALS ( " [test.cpp:2]: (style) Unused variable: s \n " , errout . str ( ) ) ;
functionVariableUsage ( " void foo() { \n "
" std::string s; \n "
" s = \" foo \" ; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-11-01 18:40:20 +01:00
ASSERT_EQUALS ( " [test.cpp:3]: (style) Variable 's' is assigned a value that is never used. \n " , errout . str ( ) ) ;
2011-07-03 01:25:10 +02:00
functionVariableUsage ( " void foo() { \n "
" std::string s = \" foo \" ; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-11-01 18:40:20 +01:00
ASSERT_EQUALS ( " [test.cpp:2]: (style) Variable 's' is assigned a value that is never used. \n " , errout . str ( ) ) ;
2011-07-03 01:25:10 +02:00
2018-12-16 19:01:05 +01:00
functionVariableUsage ( " void foo() { \n " // #8901
" const std::string s = \" foo \" ; \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:2]: (style) Variable 's' is assigned a value that is never used. \n " , errout . str ( ) ) ;
2011-07-03 01:25:10 +02:00
functionVariableUsage ( " std::string foo() { \n "
2014-05-07 23:39:32 +02:00
" std::string s; \n " // Class instances are initialized. Assignment is not necessary
2011-07-03 01:25:10 +02:00
" return s; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-07-25 09:34:27 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2011-07-03 01:25:10 +02:00
functionVariableUsage ( " std::string foo() { \n "
" std::string s = \" foo \" ; \n "
" return s; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2011-07-03 01:25:10 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2022-01-10 07:36:49 +01:00
functionVariableUsage ( " void f() { \n "
" std::string s( \" foo \" ); \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:2]: (style) Variable 's' is assigned a value that is never used. \n " , errout . str ( ) ) ;
functionVariableUsage ( " void f() { \n "
" std::string s{ \" foo \" }; \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:2]: (style) Variable 's' is assigned a value that is never used. \n " , errout . str ( ) ) ;
2011-07-03 01:25:10 +02:00
}
2011-07-22 00:37:37 +02:00
2014-11-20 14:20:09 +01:00
void localvarstring2 ( ) { // ticket #2929
2011-07-22 00:37:37 +02:00
functionVariableUsage ( " void foo() { \n "
" std::string s; \n "
" int i; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2011-07-22 00:37:37 +02:00
ASSERT_EQUALS ( " [test.cpp:2]: (style) Unused variable: s \n "
" [test.cpp:3]: (style) Unused variable: i \n " , errout . str ( ) ) ;
}
2011-07-24 18:09:59 +02:00
2014-11-20 14:20:09 +01:00
void localvarconst1 ( ) {
2011-07-24 18:09:59 +02:00
functionVariableUsage ( " void foo() { \n "
" const bool b = true; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-11-01 18:40:20 +01:00
ASSERT_EQUALS ( " [test.cpp:2]: (style) Variable 'b' is assigned a value that is never used. \n " , errout . str ( ) ) ;
2011-07-24 18:09:59 +02:00
}
2011-09-11 08:19:35 +02:00
2014-11-20 14:20:09 +01:00
void localvarconst2 ( ) {
2012-02-25 12:56:33 +01:00
functionVariableUsage ( " void foo() { \n "
" const int N = 10; \n "
" struct X { int x[N]; }; \n "
2013-03-20 15:36:16 +01:00
" } " ) ;
2012-02-25 12:56:33 +01:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2019-07-03 08:17:06 +02:00
void localvarreturn ( ) { // ticket #9167
functionVariableUsage ( " void foo() { \n "
" const int MyInt = 1; \n "
" class bar { \n "
2019-07-03 08:29:47 +02:00
" public: \n "
2019-07-03 08:17:06 +02:00
" bool operator()(const int &uIndexA, const int &uIndexB) const { \n "
2019-07-03 08:29:47 +02:00
" return true; \n "
" } \n "
2019-07-03 08:17:06 +02:00
" bar() {} \n "
" }; \n "
" return MyInt; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2020-04-12 20:35:54 +02:00
void localvarmaybeunused ( ) {
functionVariableUsage ( " int main() { \n "
" [[maybe_unused]] int x; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
functionVariableUsage ( " [[nodiscard]] int getX() { return 4; } \n "
" int main() { \n "
" [[maybe_unused]] int x = getX(); \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
functionVariableUsage ( " [[nodiscard]] int getX() { return 4; } \n "
" int main() { \n "
" [[maybe_unused]] int x = getX(); \n "
" x = getX(); \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
functionVariableUsage ( " [[nodiscard]] int getX() { return 4; } \n "
" int main() { \n "
" [[maybe_unused]] int x = getX(); \n "
" x = getX(); \n "
" std::cout << x; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
functionVariableUsage ( " int main() { \n "
" [[maybe_unused]] const int x = getX(); \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
functionVariableUsage ( " int main() { \n "
" [[maybe_unused]] const int& x = getX(); \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
functionVariableUsage ( " int main() { \n "
" [[maybe_unused]] const int* x = getX(); \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
functionVariableUsage ( " int main() { \n "
" [[maybe_unused]] int& x = getX(); \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
functionVariableUsage ( " int main() { \n "
" [[maybe_unused]] int* x = getX(); \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
functionVariableUsage ( " int main() { \n "
" [[maybe_unused]] auto x = getX(); \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
functionVariableUsage ( " int main() { \n "
" [[maybe_unused]] auto&& x = getX(); \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
functionVariableUsage ( " int main() { \n "
" [[maybe_unused]] int x[] = getX(); \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
functionVariableUsage ( " int main() { \n "
" [[maybe_unused]] constexpr volatile static int x = 1; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
functionVariableUsage ( " [[maybe_unused]] inline int x = 1; " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
functionVariableUsage ( " int main() { \n "
" [[maybe_unused]] [[anotherattribute]] const int* = 1; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2014-11-20 14:20:09 +01:00
void localvarthrow ( ) { // ticket #3687
2012-03-26 21:19:42 +02:00
functionVariableUsage ( " void foo() { \n "
" try {} "
" catch(Foo& bar) {} \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2014-11-20 14:20:09 +01:00
void localVarStd ( ) {
2021-05-13 20:21:02 +02:00
// extracttests.start: struct MyClass {int x;}; std::string foo();
2012-07-24 20:47:29 +02:00
functionVariableUsage ( " void f() { \n "
" std::string x = foo(); \n "
" } " ) ;
2012-11-01 18:40:20 +01:00
ASSERT_EQUALS ( " [test.cpp:2]: (style) Variable 'x' is assigned a value that is never used. \n " , errout . str ( ) ) ;
2012-07-24 20:47:29 +02:00
functionVariableUsage ( " void f() { \n "
" std::vector<int> x; \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:2]: (style) Unused variable: x \n " , errout . str ( ) ) ;
functionVariableUsage ( " void f() { \n "
" std::vector<int> x(100); \n "
" } " ) ;
2019-07-14 09:44:30 +02:00
ASSERT_EQUALS ( " [test.cpp:2]: (style) Variable 'x' is assigned a value that is never used. \n " , errout . str ( ) ) ;
2012-07-24 20:47:29 +02:00
functionVariableUsage ( " void f() { \n "
" std::vector<MyClass> x; \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:2]: (style) Unused variable: x \n " , errout . str ( ) ) ;
2013-01-07 20:28:43 +01:00
functionVariableUsage ( " void f() { \n "
" std::lock_guard<MyClass> lock(mutex_); \n " // Has a side-effect #4385
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2013-02-28 17:02:58 +01:00
2014-08-31 19:18:02 +02:00
functionVariableUsage ( " void f() { \n "
" pLocker = std::shared_ptr<jfxLocker>(new jfxLocker(m_lock, true)); \n " // Could have side-effects (#4355)
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2013-02-28 17:02:58 +01:00
functionVariableUsage ( " void f() { \n "
" std::mutex m; \n "
" std::unique_lock<std::mutex> lock(m); \n " // #4624
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2022-01-13 08:05:05 +01:00
functionVariableUsage ( " void f() { \n " // #7732
" const std::pair<std::string, std::string> p( \" a \" , \" b \" ); \n "
" std::pair<std::string, std::string> q{ \" a \" , \" b \" }; \n "
" auto r = std::pair<std::string, std::string>( \" a \" , \" b \" ); \n "
" auto s = std::pair<std::string, std::string>{ \" a \" , \" b \" }; \n "
" } \n " ) ;
ASSERT_EQUALS ( " [test.cpp:2]: (style) Variable 'p' is assigned a value that is never used. \n "
" [test.cpp:3]: (style) Variable 'q' is assigned a value that is never used. \n "
" [test.cpp:4]: (style) Variable 'r' is assigned a value that is never used. \n "
" [test.cpp:5]: (style) Variable 's' is assigned a value that is never used. \n " , errout . str ( ) ) ;
2012-07-24 20:47:29 +02:00
}
2019-07-14 16:20:45 +02:00
void localVarClass ( ) {
functionVariableUsage ( " void f() { \n "
" Fred f; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
functionVariableUsage ( " class C { int x; }; \n "
" void f() { \n "
" C c; \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:3]: (style) Unused variable: c \n " , errout . str ( ) ) ;
functionVariableUsage ( " class C { public: C(int); ~C(); }; \n "
" void f() { \n "
" C c(12); \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2020-09-27 19:15:15 +02:00
void localVarSmartPtr ( ) {
// handling of smart pointers (#9680)
functionVariableUsage ( " static int s_i = 0; \n "
" \n "
" class A { \n "
" public: \n "
" ~A() { \n "
" ++s_i; \n "
" } \n "
" }; \n "
" \n "
" static void func() { \n "
" auto a = std::make_shared<A>(); \n "
" auto a2 = std::unique_ptr<A>(new A()); \n "
" } \n " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
functionVariableUsage ( " class A { \n "
" public: \n "
" std::string x; \n "
" }; \n "
" \n "
" static void func() { \n "
" auto a = std::make_shared<A>(); \n "
" auto a2 = std::unique_ptr<A>(new A()); \n "
" } \n " ) ;
ASSERT_EQUALS ( " [test.cpp:7]: (style) Variable 'a' is assigned a value that is never used. \n "
" [test.cpp:8]: (style) Variable 'a2' is assigned a value that is never used. \n " , errout . str ( ) ) ;
}
2011-09-11 08:19:35 +02:00
// ticket #3104 - false positive when variable is read with "if (NOT var)"
2014-11-20 14:20:09 +01:00
void localvarIfNOT ( ) {
2011-09-11 08:19:35 +02:00
functionVariableUsage ( " void f() { \n "
" bool x = foo(); \n "
" if (NOT x) { } \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2012-03-21 18:40:32 +01:00
2014-11-20 14:20:09 +01:00
void localvarAnd ( ) { // #3672
2012-03-21 18:40:32 +01:00
functionVariableUsage ( " int main() { \n "
" unsigned flag = 0x1 << i; \n "
" if (m_errorflags & flag) { \n "
" return 1; \n "
" } \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2012-04-28 15:43:42 +02:00
2014-11-20 14:20:09 +01:00
void localvarSwitch ( ) { // #3744 - false positive when used in switch
2012-04-28 15:43:42 +02:00
functionVariableUsage ( " const char *f(int x) { \n "
" const char a[] = \" abc \" ; \n "
" const char def[] = \" def \" ; \n "
" const char *ptr; \n "
" switch(x) { \n "
" case 1: ptr=a; break; \n "
" default: ptr=def; break; \n "
" } \n "
" return ptr; \n "
" } " ) ;
2016-07-07 18:27:31 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ; // Don't write an error that "a" is not used
functionVariableUsage ( " void x() { \n "
" unsigned char* pcOctet = NULL; \n "
" float fValeur; \n "
" switch (pnodeCurrent->left.pnode->usLen) { \n "
" case 4: \n "
" fValeur = (float)pevalDataLeft->data.fd; \n "
" pcOctet = (unsigned char*)&fValeur; \n "
" break; \n "
" case 8: \n "
" pcOctet = (unsigned char*)&pevalDataLeft->data.fd; \n "
" break; \n "
" } \n "
" for (iIndice = 1; iIndice <= (pnodeCurrent->usLen / 2); iIndice++) { \n "
" *pcData = gacHexChar[(*pcOctet >> 4) & 0x0F]; \n "
" } \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ; // Don't write an error that "fValeur" is not used
2012-04-28 15:43:42 +02:00
}
2012-08-10 12:36:08 +02:00
2014-11-20 14:20:09 +01:00
void localvarNULL ( ) { // #4203 - Setting NULL value is not redundant - it is safe
2012-09-30 17:22:35 +02:00
functionVariableUsage ( " void f() { \n "
" char *p = malloc(100); \n "
" foo(p); \n "
" free(p); \n "
" p = NULL; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2018-12-13 21:01:33 +01:00
functionVariableUsage ( " void f(Foo *p) { \n "
" free(p); \n "
" p = (Foo *)NULL; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2013-03-28 06:44:37 +01:00
}
2014-11-20 14:20:09 +01:00
void localvarUnusedGoto ( ) {
2013-03-29 17:55:09 +01:00
// #4447
2013-03-28 06:44:37 +01:00
functionVariableUsage ( " bool f(const int &i) { \n "
2014-03-17 08:40:01 +01:00
" int X = i; \n "
2013-03-28 06:44:37 +01:00
" label: \n "
2014-03-17 08:40:01 +01:00
" if ( X == 0 ) { \n "
2013-03-28 06:44:37 +01:00
" X -= 101; \n "
" return true; \n "
2014-03-17 08:40:01 +01:00
" } \n "
" if ( X < 1001 ) { \n "
2013-03-28 06:44:37 +01:00
" X += 1; \n "
" goto label; \n "
2014-03-17 08:40:01 +01:00
" } \n "
" return false; \n "
2021-02-20 12:58:42 +01:00
" } " ) ;
2018-12-13 18:52:56 +01:00
ASSERT_EQUALS ( " [test.cpp:5]: (style) Variable 'X' is assigned a value that is never used. \n " , errout . str ( ) ) ;
2013-03-28 06:44:37 +01:00
2013-03-29 17:55:09 +01:00
// #4558
2013-03-28 06:44:37 +01:00
functionVariableUsage ( " int f() { \n "
2014-03-17 08:40:01 +01:00
" int i,j=0; \n "
" start: \n "
" i=j; \n "
" i++; \n "
" j=i; \n "
" if (i<3) \n "
" goto start; \n "
" return i; \n "
2013-03-28 06:44:37 +01:00
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2016-01-01 16:04:13 +01:00
}
2019-01-22 21:16:27 +01:00
void localvarLambda ( ) {
2019-01-20 13:20:23 +01:00
functionVariableUsage ( " int foo() { \n "
" auto f = []{return 1}; \n "
" return f(); \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2019-01-22 21:16:27 +01:00
functionVariableUsage ( " int foo() { \n "
" auto f = []{return 1}; \n "
" auto g = []{return 1}; \n "
" return f() + g(); \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2019-01-26 21:43:44 +01:00
functionVariableUsage ( " void foo(std::vector<int>& v) { \n "
" int n = 0; \n "
" std::generate(v.begin(), v.end(), [&n] { \n "
" int r = n; \n "
" n += 2; \n "
" return r; \n "
" }); \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2019-01-20 13:20:23 +01:00
}
2016-01-01 16:04:13 +01:00
void localvarCppInitialization ( ) {
functionVariableUsage ( " void foo() { \n "
" int buf[6]; \n "
" Data data(buf); \n "
" } " ) ;
2022-01-13 08:05:05 +01:00
ASSERT_EQUALS ( " [test.cpp:3]: (information) --check-library: Provide <type-checks><unusedvar> configuration for Data \n " , errout . str ( ) ) ;
2012-09-30 17:22:35 +02:00
}
2014-11-20 14:20:09 +01:00
void localvarCpp11Initialization ( ) {
2014-09-30 12:39:27 +02:00
// #6160
functionVariableUsage ( " void foo() { \n "
" int myNewValue{ 3u }; \n "
" myManager.theDummyTable.addRow(UnsignedIndexValue{ myNewValue }, DummyRowData{ false }); \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2015-10-27 14:46:58 +01:00
void localvarRangeBasedFor ( ) {
// #7075
functionVariableUsage ( " void reset() { \n "
" for (auto & e : array) \n "
" e = 0; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2016-01-01 12:14:18 +01:00
void localvarAssignInWhile ( ) {
functionVariableUsage ( " void foo() { \n "
" int a = 0; \n "
" do { \n "
" dostuff(a); \n "
" } while((a + = x) < 30); \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
functionVariableUsage ( " int foo() { \n "
" int var = 1; \n "
" while (var = var >> 1) { } \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2016-01-30 16:49:39 +01:00
void localvarTemplate ( ) {
functionVariableUsage ( " template<int A> void f() {} \n "
" void foo() { \n "
" const int x = 0; \n "
" f<x>(); \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2016-01-31 12:39:43 +01:00
functionVariableUsage ( " void f() { \n "
" constexpr std::size_t ArraySize(5); \n "
" std::array<int, ArraySize> X; X.dostuff(); \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2022-01-10 07:36:49 +01:00
functionVariableUsage ( " void f() { \n " // #10686
" std::array<int, 1> a; \n "
" } \n " ) ;
ASSERT_EQUALS ( " [test.cpp:2]: (style) Unused variable: a \n " , errout . str ( ) ) ;
2022-02-01 17:15:27 +01:00
functionVariableUsage ( " class A {}; \n " // #9471
" namespace std { \n "
" template<> \n "
" struct hash<A> {}; \n "
" } \n "
" char f() { \n "
" std::string hash = \" - \" ; \n "
" return hash[0]; \n "
" } \n " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2016-01-30 16:49:39 +01:00
}
2016-01-30 20:59:32 +01:00
void localvarFuncPtr ( ) {
functionVariableUsage ( " int main() { \n "
" void(*funcPtr)(void)(x); \n "
" } " ) ;
TODO_ASSERT_EQUALS ( " [test.cpp:2]: (style) Variable 'funcPtr' is assigned a value never used. \n " , " " , errout . str ( ) ) ;
functionVariableUsage ( " int main() { \n "
" void(*funcPtr)(void); \n "
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:2]: (style) Unused variable: funcPtr \n " , errout . str ( ) ) ;
functionVariableUsage ( " int main() { \n "
" void(*funcPtr)(void)(x); \n "
" funcPtr(); \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
functionVariableUsage ( " int main() { \n "
" void(*funcPtr)(void) = x; \n "
" funcPtr(); \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2016-09-03 20:38:36 +02:00
void localvarAddr ( ) { // #7747
functionVariableUsage ( " void f() { \n "
" int x = 0; \n "
" dostuff(&x); \n "
" x = 1; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
functionVariableUsage ( " void f() { \n "
" int x = 0; \n "
" dostuff(std::ref(x)); \n "
" x = 1; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2018-11-14 17:04:14 +01:00
void localvarDelete ( ) { // #8339
functionVariableUsage ( " void reassign(char*& data, int size) "
" { "
" char* buf = new char[size]; "
" "
" char* tmp = data; "
" data = buf; "
" buf = tmp; "
" "
" delete [] buf; "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2014-11-20 14:20:09 +01:00
void chainedAssignment ( ) {
2014-08-31 19:46:30 +02:00
// #5466
functionVariableUsage ( " void NotUsed(double* pdD, int n) { \n "
" double sum = 0.0; \n "
" for (int i = 0; i<n; ++i) \n "
" pdD[i] = (sum += pdD[i]); \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2014-11-20 14:20:09 +01:00
void crash1 ( ) {
2012-08-10 12:36:08 +02:00
functionVariableUsage ( " SAL_WNODEPRECATED_DECLARATIONS_PUSH \n "
" void convertToTokenArray() { \n "
" } \n "
" SAL_WNODEPRECATED_DECLARATIONS_POP " ) ; // #4033
}
2013-02-14 06:31:41 +01:00
2014-11-20 14:20:09 +01:00
void crash2 ( ) {
2013-04-01 12:41:14 +02:00
functionVariableUsage ( " template<unsigned dim> \n "
" struct Y: Y<dim-1> { }; \n "
" template<> \n "
" struct Y<0> {}; \n "
" void f() { \n "
" Y y; \n "
" } " ) ; // #4695
}
2014-11-20 14:20:09 +01:00
void usingNamespace ( ) {
2013-02-14 06:31:41 +01:00
functionVariableUsage ( " int foo() { \n "
" using namespace ::com::sun::star::i18n; \n "
" bool b = false; \n "
" int j = 0; \n "
" for (int i = 0; i < 3; i++) { \n "
" if (!b) { \n "
" j = 3; \n "
" b = true; \n "
" } \n "
" } \n "
" return j; \n "
2013-03-20 15:36:16 +01:00
" } " ) ; // #4585
2013-02-14 06:31:41 +01:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2016-05-26 18:07:56 +02:00
void lambdaFunction ( ) {
// #7026
functionVariableUsage ( " void f() { \n "
" bool first = true; \n "
" \n "
" auto do_something = [&first]() { \n "
" if (first) { \n "
" first = false; \n "
" } else { \n "
" dostuff(); \n "
" } \n "
" }; \n "
" do_something(); \n "
" do_something(); \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
// #4956 - assignment in for_each
functionVariableUsage ( " void f(std::vector<int> ints) { \n "
" int x = 0; \n "
" std::for_each(ints.begin(), ints.end(), [&x](int i){ dostuff(x); x = i; }); \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
functionVariableUsage ( " void f(std::vector<int> ints) { \n "
" int x = 0; \n "
" std::for_each(ints.begin(), ints.end(), [&x](int i){ x += i; }); \n "
" } " ) ;
TODO_ASSERT_EQUALS ( " [test.cpp:3]: (style) Variable 'x' is assigned a value that is never used. \n " , " " , errout . str ( ) ) ;
}
2016-10-01 21:21:07 +02:00
void namespaces ( ) { // #7557
functionVariableUsage ( " namespace t { namespace g { \n "
" typedef std::pair<BoostBox, size_t> value; \n "
" } } \n "
" namespace t { namespace g {} } \n "
" namespace t { \n "
" inline double getTime() const { \n "
" iterator it=find(); \n "
" double& value=it->second.values[index]; \n "
" if(isnan(value)) { \n "
" value=get(); \n "
" } \n "
" return value; \n "
" } \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2017-01-22 10:16:40 +01:00
void bracesInitCpp11 ( ) {
functionVariableUsage (
2017-01-31 16:22:31 +01:00
" int fun() { \n "
" static int fpUnread{0}; \n "
" const int var{fpUnread++}; \n "
" return var; \n "
2021-02-20 12:58:42 +01:00
" } " ) ;
2017-01-22 10:16:40 +01:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2018-12-13 18:52:56 +01:00
void argument ( ) {
functionVariableUsage (
" void fun(Value value) { \n "
" value[10] = 123; \n "
2021-02-20 12:58:42 +01:00
" } " ) ;
2018-12-13 18:52:56 +01:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
functionVariableUsage (
" void fun(std::string s) { \n "
" s[10] = 123; \n "
2021-02-20 12:42:48 +01:00
" } " ) ;
ASSERT_EQUALS ( " [test.cpp:2]: (style) Variable 's[10]' is assigned a value that is never used. \n " , errout . str ( ) ) ;
2018-12-13 21:08:18 +01:00
functionVariableUsage (
" void fun(short data[2]) { \n "
" data[2] = 1; \n "
" } "
2021-08-07 20:51:18 +02:00
) ;
2018-12-13 21:08:18 +01:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2018-12-13 21:37:21 +01:00
2018-12-19 19:42:55 +01:00
// Unknown argument type
2018-12-13 21:37:21 +01:00
functionVariableUsage (
" void A::b(Date& result) { "
" result = 12; \n "
" } "
2021-08-07 20:51:18 +02:00
) ;
2018-12-13 21:37:21 +01:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
2018-12-17 15:40:15 +01:00
2018-12-19 19:42:55 +01:00
{
// #8914
functionVariableUsage ( // assume unknown argument type is reference
" void fun(Date result) { "
" result.x = 12; \n "
" } "
2021-08-07 20:51:18 +02:00
) ;
2018-12-19 19:42:55 +01:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
functionVariableUsage ( // there is no reference type in C
" void fun(Date result) { "
" result.x = 12; \n "
" } " ,
" test.c "
2021-08-07 20:51:18 +02:00
) ;
2018-12-19 19:42:55 +01:00
ASSERT_EQUALS ( " [test.c:1]: (style) Variable 'result.x' is assigned a value that is never used. \n " , errout . str ( ) ) ;
functionVariableUsage (
" struct Date { int x; }; \n "
" void fun(Date result) { "
" result.x = 12; \n "
" } "
2021-08-07 20:51:18 +02:00
) ;
2018-12-19 19:42:55 +01:00
ASSERT_EQUALS ( " [test.cpp:2]: (style) Variable 'result.x' is assigned a value that is never used. \n " , errout . str ( ) ) ;
}
2018-12-17 15:40:15 +01:00
// Unknown struct type
functionVariableUsage (
" void fun() { "
" struct FOO foo; \n "
" foo.x = 123; \n "
" } "
2021-08-07 20:51:18 +02:00
) ;
2018-12-17 15:40:15 +01:00
ASSERT_EQUALS ( " [test.cpp:2]: (style) Variable 'foo.x' is assigned a value that is never used. \n " , errout . str ( ) ) ;
2018-12-13 18:52:56 +01:00
}
2019-05-31 08:06:36 +02:00
2019-11-16 19:49:43 +01:00
void argumentClass ( ) {
functionVariableUsage (
" void foo(std::insert_iterator<C> it) { \n "
" it = 123; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2019-05-31 08:06:36 +02:00
void escapeAlias ( ) {
functionVariableUsage (
" struct A { \n "
" std::map<int, int> m; \n "
" void f(int key, int number) { \n "
" auto pos = m.find(key); \n "
" if (pos == m.end()) \n "
" m.insert(std::map<int, int>::value_type(key, number)); \n "
" else \n "
" (*pos).second = number; \n "
" } \n "
2021-02-20 12:58:42 +01:00
" }; " ) ;
2019-05-31 08:06:36 +02:00
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2020-02-15 17:18:21 +01:00
void volatileData ( ) {
functionVariableUsage (
" struct Data { unsigned int n; }; \n "
" int main() { \n "
" (*(volatile struct Data*)0x4200).n = 1; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2021-05-18 20:35:00 +02:00
void globalData ( ) {
// #10276
functionVariableUsage (
" void f(void) { \n "
" ((uint8_t *) (uint16_t)0x1000)[0] = 0x42; \n "
" } " ) ;
ASSERT_EQUALS ( " " , errout . str ( ) ) ;
}
2008-12-18 22:28:57 +01:00
} ;
2009-01-05 16:49:57 +01:00
REGISTER_TEST ( TestUnusedVar )