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(); };");
}
