TEST_F(LongClassRuleTest, CXXClass) { testRuleOnCXXCode(new LongClassRule(), "class c {};", 0, 1, 1, 1, 10, "C++ class with 1 lines exceeds limit of 0"); testRuleOnCXXCode(new LongClassRule(), "class c {\nvoid m();\n};", 0, 1, 1, 3, 1, "C++ class with 3 lines exceeds limit of 0"); }
TEST(EmptyCatchStatementRuleTest, MultipleEmptyCXXCatchStmts) { testRuleOnCXXCode(new EmptyCatchStatementRule(), "void m() { try { ; } catch (int i) {} catch(...) {} }", 0, 1, 36, 1, 37); testRuleOnCXXCode(new EmptyCatchStatementRule(), "void m() { try { ; } catch (int i) {} catch(...) {} }", 1, 1, 50, 1, 51); }
TEST(UnnecessaryNullCheckForCXXDeallocRuleTest, DeleteArray) { const char* code1 = "void m(char* c) { " VIOLATION_START "if (c != 0) delete [] " VIOLATION_END "c; }"; const char* code2 = "struct S {~S();}; void m(S* s) { " VIOLATION_START "if (s) delete[]" VIOLATION_END "s;}"; testRuleOnCXXCode(new UnnecessaryNullCheckForCXXDeallocRule(), code1); testRuleOnCXXCode(new UnnecessaryNullCheckForCXXDeallocRule(), code2); }
TEST(UnnecessaryNullCheckForCXXDeallocRuleTest, Comparator) { const char* code1 = "void m(char* c) { " VIOLATION_START "if (c != 0) delete " VIOLATION_END "c; }"; const char* code2 = "void m(char* c) { " VIOLATION_START "if (c != (void*)0) delete " VIOLATION_END "c; }"; const char* code3 = "void m(char* c) { " VIOLATION_START "if (c != nullptr) delete " VIOLATION_END "c; }"; testRuleOnCXXCode(new UnnecessaryNullCheckForCXXDeallocRule(), code1); testRuleOnCXXCode(new UnnecessaryNullCheckForCXXDeallocRule(), code2); testRuleOnCXX11Code(new UnnecessaryNullCheckForCXXDeallocRule(), code3); }
TEST(UnnecessaryNullCheckForCXXDeallocRuleTest, CorrectCode) { const char* code1 = "void m(char* c) { if (c) { delete c; } else ; }"; const char* code2 = "void m(char* c) { if (c) delete c; else ; }"; const char* code3 = "void m(char* c) { if (c) { delete c; c = 0; ++c; } }"; const char* code4 = "void m(char* c, char* b) { if (c) { delete c; c = b; } }"; testRuleOnCXXCode(new UnnecessaryNullCheckForCXXDeallocRule(), code1); testRuleOnCXXCode(new UnnecessaryNullCheckForCXXDeallocRule(), code2); testRuleOnCXXCode(new UnnecessaryNullCheckForCXXDeallocRule(), code3); testRuleOnCXXCode(new UnnecessaryNullCheckForCXXDeallocRule(), code4); }
TEST(BaseClassDestructorShouldBeVirtualOrProtectedRuleTest, PublicImplicitBaseDestructor) { testRuleOnCXXCode(new BaseClassDestructorShouldBeVirtualOrProtectedRule(), VIOLATION_START "class Base {" VIOLATION_END "};\n" "class C : public Base { virtual ~C(); };", {"~Base() should be protected or virtual according to class C"}); }
TEST(DestructorOfVirtualClassRuleTest, FixedDerivatedFromBrokenVirtualClass) { testRuleOnCXXCode(new DestructorOfVirtualClassRule(), VIOLATION_START "class Base { public: virtual void f(); " VIOLATION_END "};\n" "class C : public Base { public: virtual ~C(); };", {"class Base should have a virtual destructor ~Base()"}); }
TEST(BaseClassDestructorShouldBeVirtualOrProtectedRuleTest, NotVirtualChildClass) { // Don't report when not virtual class is used, // to avoid false positive with 'type traits' classes. testRuleOnCXXCode(new BaseClassDestructorShouldBeVirtualOrProtectedRule(), "class Base { public: ~Base(); };\n" "class C : public Base {};"); }
TEST(AvoidDefaultArgumentsOnVirtualMethodsRuleTest, VirtualWithDefaultArg) { // 1 2 3 4 // 1234567890123456789012345678901234567890123 std::string code = "class Test { virtual void test(int a=0); };"; testRuleOnCXXCode(new AvoidDefaultArgumentsOnVirtualMethodsRule(), code, 0, 1, 14, 1, 39); }
TEST(UnnecessaryNullCheckForCXXDeallocRuleTest, ResetDeleteBlock) { const char* code1 = "void m(char* c) { " VIOLATION_START "if (c) { delete c; c = 0; " VIOLATION_END "} }"; const char* code2 = "void m(char* c) { " VIOLATION_START "if (c) { delete c; c = nullptr; " VIOLATION_END "} }"; testRuleOnCXXCode(new UnnecessaryNullCheckForCXXDeallocRule(), code1); testRuleOnCXX11Code(new UnnecessaryNullCheckForCXXDeallocRule(), code2); }
TEST(BaseClassDestructorShouldBeVirtualOrProtectedRuleTest, ReportOnlyOnce) { testRuleOnCXXCode(new BaseClassDestructorShouldBeVirtualOrProtectedRule(), VIOLATION_START "class Base {" VIOLATION_END "};\n" "class Intermediate : public Base { public: virtual ~Intermediate(); };\n" "class Child : public Intermediate { public: virtual ~Child(); };\n", {"~Base() should be protected or virtual according to class Intermediate"} ); }
TEST(BaseClassDestructorShouldBeVirtualOrProtectedRuleTest, MultiplePublicBaseClasses) { testRuleOnCXXCode(new BaseClassDestructorShouldBeVirtualOrProtectedRule(), VIOLATION_START "class Base1 {" VIOLATION_END "};\n" VIOLATION_START "class Base2 {" VIOLATION_END "};\n" "class C : public Base1, public Base2 { virtual ~C(); };", { "~Base1() should be protected or virtual according to class C", "~Base2() should be protected or virtual according to class C" } ); }
TEST(BaseClassDestructorShouldBeVirtualOrProtectedRuleTest, DiamondBaseClasses) { // TODO: remove duplicated message in diamond testRuleOnCXXCode(new BaseClassDestructorShouldBeVirtualOrProtectedRule(), VIOLATION_START VIOLATION_START "class Base {" VIOLATION_END VIOLATION_END "};\n" VIOLATION_START "class Left : public virtual Base {" VIOLATION_END "};\n" VIOLATION_START "class Right : public virtual Base {" VIOLATION_END "};\n" "class C : public Left, public Right { virtual ~C(); };", { "~Base() should be protected or virtual according to class C", "~Base() should be protected or virtual according to class C", "~Left() should be protected or virtual according to class C", "~Right() should be protected or virtual according to class C" } ); }
TEST(BaseClassDestructorShouldBeVirtualOrProtectedRuleTest, MultipleKindBaseClasses) { testRuleOnCXXCode(new BaseClassDestructorShouldBeVirtualOrProtectedRule(), VIOLATION_START "class PublicBase {" VIOLATION_END "};\n" "class ProtectedBase {};\n" "class PrivatedBase {};\n" VIOLATION_START "class PublicVBase {" VIOLATION_END "};\n" "class ProtectedVBase {};\n" "class PrivatedVBase {};\n" "class C : public PublicBase, protected ProtectedBase, private PrivatedBase,\n" " public virtual PublicVBase,\n" " protected virtual ProtectedVBase,\n" " private PrivatedVBase\n" "{ virtual ~C(); };", { "~PublicBase() should be protected or virtual according to class C", "~PublicVBase() should be protected or virtual according to class C" } ); }
TEST(DestructorOfVirtualClassRuleTest, VirtualDestructor) { testRuleOnCXXCode(new DestructorOfVirtualClassRule(), "class C { public: virtual ~C(); virtual void f(); };"); }
TEST(UnnecessaryNullCheckForCXXDeallocRuleTest, IfDelete) { testRuleOnCXXCode(new UnnecessaryNullCheckForCXXDeallocRule(), "void m(char* c) { " VIOLATION_START "if (c) delete " VIOLATION_END "c; }"); }
TEST_F(NestedBlockDepthRuleTest, CXXTryCatch) { testRuleOnCXXCode(new NestedBlockDepthRule(), "void m() { try { int a = 1; } catch (...) { int b = 2; {{}}} }", 0, 1, 10, 1, 62, "Block depth of 4 exceeds limit of 1"); }
TEST(UnusedMethodParameterRuleTest, CppParameterHasNoNameShouldBeIgnored) { testRuleOnCXXCode(new UnusedMethodParameterRule(), "void aMethod(int) {}"); }
TEST(RedundantIfStatementRuleTest, CPPBooleanDeclaration) { testRuleOnCXXCode(new RedundantIfStatementRule(), "void aMethod() { bool b; " VIOLATION_START "if (1) { b = true; } else b = " VIOLATION_END "false; }"); }
TEST(RedundantIfStatementRuleTest, CPPFalseThenAndTrueElse) { testRuleOnCXXCode(new RedundantIfStatementRule(), "bool aMethod() { " VIOLATION_START "if (1) return false; else { return true; " VIOLATION_END "} }"); }
TEST(EmptyTryStatementRuleTest, NonEmptyCXXTryStmt) { testRuleOnCXXCode(new EmptyTryStatementRule(), "void m() { try { ; } catch(...) { ; } }"); }
TEST_F(LongClassRuleTest, CXXClassIgnoreOtherMethods) { testRuleOnCXXCode(new LongClassRule(), "void m(); class c {};\nvoid n();", 0, 1, 11, 1, 20, "C++ class with 1 lines exceeds limit of 0"); }
TEST(EmptyTryStatementRuleTest, EmptyCXXTryWithEmptyCompoundStmt) { testRuleOnCXXCode(new EmptyTryStatementRule(), "void m() { try {} catch(...) { ; } }", 0, 1, 16, 1, 17); }
TEST(BaseClassDestructorShouldBeVirtualOrProtectedRuleTest, SkipCheckingOnForwardDeclarations) { testRuleOnCXXCode(new BaseClassDestructorShouldBeVirtualOrProtectedRule(), "namespace a {class aa;}"); }
TEST(DestructorOfVirtualClassRuleTest, NoDestructor) { testRuleOnCXXCode(new DestructorOfVirtualClassRule(), VIOLATION_START "class C { public: virtual void f(); " VIOLATION_END "};", {"class C should have a virtual destructor ~C()"}); }
TEST(BaseClassDestructorShouldBeVirtualOrProtectedRuleTest, ProtectedBaseDestructor) { testRuleOnCXXCode(new BaseClassDestructorShouldBeVirtualOrProtectedRule(), "class Base { protected: ~Base(); };\n" "class C : public Base {};"); }
TEST(DestructorOfVirtualClassRuleTest, NonVirtualClass) { testRuleOnCXXCode(new DestructorOfVirtualClassRule(), "class C { public: ~C(); void f(); };"); }
TEST(RedundantIfStatementRuleTest, CPPTrueThenAndFalseElse) { testRuleOnCXXCode(new RedundantIfStatementRule(), "bool aMethod() { " VIOLATION_START "if (1) { return true; } else return " VIOLATION_END "false; }"); }
TEST(RedundantConditionalOperatorRuleTest, CppTrueExprIsFalseAndFalseExprIsTrue) { testRuleOnCXXCode(new RedundantConditionalOperatorRule(), "void m(int a, int b) { bool c = a > b ? false : true; }", 0, 1, 33, 1, 49); }
TEST(DestructorOfVirtualClassRuleTest, ImplicitVirtualDestructor) { testRuleOnCXXCode(new DestructorOfVirtualClassRule(), "class Base { public: virtual ~Base(); };\n" "class C : public Base { public: ~C(); virtual void f(); };"); }