StaticAnalyzers/test/class_checker.cpp

0001 #include "FWCore/Utilities/interface/thread_safety_macros.h"
0002
0003 // is ok, because const-qualified
0004 const static int g_staticConst = 23;
0005 static int const &g_ref_staticConst = g_staticConst;
0006 static int const *g_ptr_staticConst = &g_staticConst;
0007
0008 // results in a warning by GlobalStaticChecker
0009 CMS_THREAD_SAFE static int g_static;
0010 static int *g_ptr_static = &g_static;
0011
0012 class ClassTest {
0013 public:
0014   explicit ClassTest();
0015   ~ClassTest();
0016   mutable int m_pubMutable;
0017
0018   void testConst() const;
0019
0020 private:
0021   mutable int m_testMutable;
0022   int *m_testPointer;
0023   int m_testInteger;
0024 };
0025
0026 void ClassTest::testConst() const {
0027   // 1) reported by class checker
0028   m_testMutable = 23;
0029
0030   // 2) compiles, not reported
0031   (*m_testPointer) = 23;
0032
0033   // 3) compiles, not reported
0034   int *localPtr = m_testPointer;
0035   (*localPtr) = 23;
0036
0037   // 4) will not compile
0038   // error: invalid conversion from 'const int*' to 'int*'
0039   //int * localPtrToInt = &m_testInteger;
0040 }
0041
0042 class Thing {
0043 private:
0044   int num;
0045
0046 public:
0047   Thing() : num{0} {}
0048   int getnum() { return num; }
0049   void putnum(int x) { num = x; }
0050 };
0051
0052 class Foo {
0053 private:
0054   int Var_;
0055   int &RVar_ = Var_;
0056   int *PVar_ = &RVar_;
0057   Thing *T_p;
0058
0059 public:
0060   Foo() : Var_{0} { T_p = new Thing; }
0061   void func1(int x) { return; }         //OK
0062   void func2(int &x) { return; }        // cound be bad
0063   void func3(int *x) { return; }        // could be bad
0064   void func4(int const *x) { return; }  //  OK
0065   void func5(int *const x) { return; }  // could be bad
0066   void func6(int const &x) { return; }  //OK
0067   void nonConstFunc() { Var_ = 5; }
0068   void constFunc() const { return; }
0069   int *nonConstAccess() const { return PVar_; }        //bad
0070   int &nonConstRefAccess() const { return RVar_; }     //bad ?
0071   int const *constAccess() const { return PVar_; }     //OK
0072   int const &constRefAccess() const { return RVar_; }  //OK ?
0073   Thing *getThing() { return T_p; }
0074 };
0075
0076 class Bar {
0077   CMS_THREAD_SAFE static int si_;
0078   static void const modifyStatic(int &x) { si_ = x; }
0079
0080 private:
0081   Bar() : ci_{0}, ipc_{&i_}, icp_{&i_}, ir_{i_}, icr_{ci_} {}
0082   const int ci_;
0083   int i_;
0084   int const *icp_;
0085   int *ip_;
0086   int *const ipc_;
0087   int &ir_;
0088   int const &icr_;
0089   Foo foo_;
0090
0091 public:
0092   void modifyMember() { i_ = 5; }
0093   void indirectModifyMember() { modifyMember(); }
0094   void recursiveCaller(int i) {
0095     if (i == 0)
0096       return;
0097     recursiveCaller(--i);
0098   }
0099
0100   void method1(int &x) { return; }
0101   void method2(const int &x) const { return; }
0102
0103   void produce() {
0104     Foo *foo = new Foo;
0105     int I = 0;
0106     int *PI;
0107     int const *CPI;
0108     foo->func1(i_);
0109     foo->func1(ci_);
0110     foo->func1(ir_);
0111     foo->func1(icr_);
0112     foo->func1(I);
0113     foo->func2(i_);
0114     foo->func2(ir_);
0115     foo->func2(I);
0116     foo->func6(i_);
0117     foo->func6(ir_);
0118     foo->func6(I);
0119     foo->nonConstFunc();
0120     foo_.nonConstFunc();  //should fail member data (object) call non const functions
0121     foo_.constFunc();     //OK because const won't modify self
0122     foo->getThing()->getnum();
0123     foo_.getThing()->getnum();
0124     method1(i_);
0125     method1(I);
0126     modifyStatic(I);
0127     modifyMember();
0128     indirectModifyMember();
0129     recursiveCaller(1);
0130     PI = foo_.nonConstAccess();  //should fail returns pointer to member data that is non const qualified
0131     CPI = foo_.constAccess();    // OK because returns pointer to member data that is const qualified
0132     if (*PI == *CPI)
0133       I++;
0134   }
0135
0136   void method3() const {
0137     Foo foo;
0138     int I = 0;
0139     Bar bar;
0140     foo.func1(i_);
0141     foo.func1(ci_);
0142     foo.func1(ir_);
0143     foo.func1(icr_);
0144     foo.func1(I);
0145     foo.func2(ir_);
0146     foo.func2(I);
0147     foo.func6(i_);
0148     foo.func6(ir_);
0149     foo.func6(I);
0150     foo_.nonConstRefAccess();
0151     foo_.constRefAccess();
0152     //  foo_.nonConstFunc();
0153     foo_.nonConstAccess();
0154     foo_.constAccess();
0155     if (i_)
0156       method2(i_);
0157     bar.produce();
0158     // will produce a warning only by ConstCastAwayChecker
0159     int &ir = (int &)(icr_);
0160     int &cir = const_cast<int &>(icr_);
0161     int *ip = (int *)(icp_);
0162     int *cip = const_cast<int *>(icp_);
0163     // must not produce a warning
0164     int const &ira = (int const &)(icr_);
0165     // will produce a warning by StaticLocalChecker
0166     CMS_THREAD_SAFE static int evilStaticLocal = 0;
0167     static int &intRef = evilStaticLocal;
0168     static int *intPtr = &evilStaticLocal;
0169     // no warnings here
0170     static const int c_evilStaticLocal = 0;
0171     static int const &c_intRef = evilStaticLocal;
0172     static int const *c_intPtr = &evilStaticLocal;
0173     static const int *c_intPtr_equivalent = &evilStaticLocal;
0174     static int const *const *c_intPtrPtr = &(c_intPtr);
0175     g_static = 23;
0176     si_ = 23;
0177     modifyStatic(I);
0178   }
0179 };
0180
0181 int main() { return 0; }