CAST Appmarq
  • Benchmark Analytics
  • Demographics
  • CRASH Reports
  • Signin Register

Health Factors

  Total Quality Index (TQI)

3786 rules

Total Quality Index measures the general maintainability level of the application based on hundreds of metrics provided by CAST.

  Robustness

1426 rules

Robustness measures the level of risk and the likelihood of having application failures and defects resulting from modifications.

  Security

1418 rules

Security measures the likelihood of potential security breaches linked to coding practices and application source code.

  Efficiency

535 rules

Efficiency measures the likelihood of potential performance bottlenecks and the potential future scalability issues linked to coding practices.

  Changeability

1292 rules

Changeability measures how easily applications can be modified in order to implement new features, correct errors, or change the applications environment.

  Transferability

1284 rules

Transferability measures how easily applications can be moved across teams or team members including in-house and outsourced development teams.
Want more stats? Register now!

Quality Rules

A base class shall be declared virtual only if it is used in a diamond hierarchy
Abstract Classes should be non copy-assignable
CRITICAL  A Class that has pointer data members must provide a copy Constructor
CRITICAL  Action Artifacts should not directly call a JSP page
CRITICAL  Action Artifacts should not directly use database objects
Action Classes should have only one public method
Action Classes should only be called by Action Mappings tag (for Struts 1.x) or Action tag (for Struts 2.x)
Action Classes should only call Business Classes
Action Mappings should have few forwards
Add @Override on methods overriding or implementing a method declared in a super type
All ALLOCATE statements in Fortran-90 Functions must use the return code STAT (Fortran)
All ALLOCATE statements in Fortran-90 Modules must use the return code STAT (Fortran)
All ALLOCATE statements in Fortran-90 Programs must use the return code STAT (Fortran)
All ALLOCATE statements in Fortran-90 Subroutines must use the return code STAT (Fortran)
All constructors that are callable with a single argument of fundamental type shall be declared explicit.
All if … else if constructs shall be terminated with an else clause (C/C++)
All Read and Write statements in Functions must use the return code IOSTAT (Fortran)
All Read and Write statements in Modules must use the return code IOSTAT (Fortran)
All Read and Write statements in Programs must use the return code IOSTAT (Fortran)
All Read and Write statements in Subroutines must use the return code IOSTAT (Fortran)
All types of a serializable class must be serializable
All types of a serializable Class must be serializable
CRITICAL  Always define column names when inserting values
Always favour pipable operators in RxJS
Always handle errors when using ajax with RxJS
Always implement done, fail and/or always callbacks for $.ajax calls when using jQuery 3.0 (and latest)
CRITICAL  Always implement the success/error/complete or done/fail/always callbacks when using jQuery ajax call
Always mark Windows Forms starting point as STAThread
Always override 'Equals' and Comparison operators with IComparable implementation
Always pass optional parameters too, when making 'base' calls
Always prefer set Array designators '[]' on the type and not at variable
Always provide error callbacks when subscribing to HttpClient observables
Always separate service contracts from service implementation.
Always use ConfigureAwait(false) in library code awaited tasks
Always use JSON.parse & JSON.stringify with try/catch block (Javascript)
Always use JSON.parse & JSON.stringify with try/catch block (TypeScript)
Always use LAContext canEvaluatePolicy: before using evaluatePolicy:
Always use LAContext canEvaluatePolicy: before using evaluatePolicy:
Always use LAContext canEvaluatePolicy before using evaluatePolicy (Swift)
An event handler MUST contain at least one onEvent or onAlarm element.
An event handler MUST contain at least one onEvent or onAlarm element.
An unconditional 'throw', 'return' or 'break' shall terminate every non-empty switch-clause
Any Data must be declared, use IMPLICIT NONE in Functions (Fortran)
Any Data must be declared, use IMPLICIT NONE in Modules (Fortran)
Any Data must be declared, use IMPLICIT NONE in Programs (Fortran)
Any Data must be declared, use IMPLICIT NONE in Subroutines (Fortran)
A partnerLink MUST specify the myRole or the partnerRole, or both.
CRITICAL  A pointer to a base Class shall only be cast to a pointer to a derived Class by means of 'dynamic_cast'
A pointer to a derived Class shall only be cast implicitly to a pointer to base Class
Architecture Check: CACEIS:Avoid deprecated programs (Error)
Architecture Check: CACEIS:Avoid deprecated programs (Warning)
Architecture Check: Clarity Allowed
Architecture Check: Database Access Validation Architecture Model
Arguments to a function-like macro shall not contain tokens that look like preprocessing directives.
Assignment operator should assign all non-static members of the target object
Avoid accessing data by using the position and length
CRITICAL  Avoid accessing SAP standard Tables in modification from custom code
Avoid Action artifacts that call packages that reference database
CRITICAL  Avoid Activities using "Group By" statement (TIBCO BW)
Avoid Activities using ROWNUM (TIBCO BW)
CRITICAL  Avoid Activities using "UNION" instead of "Union all" (TIBCO BW)
Avoid Activities With Queries on more than 4 Tables (TIBCO BW)
CRITICAL  Avoid Activities with "SELECT *" queries (TIBCO BW)
CRITICAL  Avoid addEventListener containing hard coded strings (Flex)
CRITICAL  Avoid AE Schema with Target namespace not defined (TIBCO BW)
CRITICAL  Avoid * and use strongly typed objects instead in fields (Flex)
CRITICAL  Avoid * and use strongly typed objects instead in variables (Flex)
Avoid any non-static data members not initialized in constructor
CRITICAL  Avoid ArrayElementType metadata not specified for the array-type field (Flex)
Avoid artifacts having db.collection.ensureIndex() to create new indexes
Avoid artifacts having Incorrect Type Conversion or Cast
Avoid artifacts having recursive calls
Avoid artifacts having recursive calls (PHP)
Avoid Artifacts with a Complex SELECT Clause
Avoid Artifacts with a Complex SELECT Clause (ABAP)
Avoid Artifacts with a complex SELECT clause (JEE)
Avoid Artifacts with a Complex SELECT Clause (PowerBuilder)
Avoid Artifacts with a Complex SELECT Clause (SQL)
Avoid Artifacts with a Complex SELECT Clause (Visual Basic)
Avoid Artifacts with High Cyclomatic Complexity
Avoid Artifacts with High Cyclomatic Complexity (ABAP)
Avoid Artifacts with High Cyclomatic Complexity (ASP)
Avoid Artifacts with High Cyclomatic Complexity (C++)
Avoid Artifacts with High Cyclomatic Complexity (C Lang.)
Avoid Artifacts with High Cyclomatic Complexity (C# .Net)
Avoid Artifacts with High Cyclomatic Complexity (DB2 Server)
Avoid Artifacts with High Cyclomatic Complexity (Forms)
Avoid Artifacts with High Cyclomatic Complexity (Go)
Avoid Artifacts with High Cyclomatic Complexity (HTML5/Javascript)
Avoid Artifacts with High Cyclomatic Complexity (HTML5/Javascript)
Avoid Artifacts with High Cyclomatic Complexity (JEE)
Avoid Artifacts with High Cyclomatic Complexity (JSP)
Avoid Artifacts with High Cyclomatic Complexity (PL/SQL Oracle)
Avoid Artifacts with High Cyclomatic Complexity (PowerBuilder)
Avoid Artifacts with High Cyclomatic Complexity (Python)
Avoid Artifacts with High Cyclomatic Complexity (SQL Server)
Avoid Artifacts with High Cyclomatic Complexity (Swift)
Avoid Artifacts with High Cyclomatic Complexity (Visual Basic)
Avoid Artifacts with High Depth of Code
Avoid Artifacts with High Depth of Code
Avoid Artifacts with High Depth of Code (ABAP)
Avoid Artifacts with High Depth of Code (ASP)
Avoid Artifacts with High Depth of Code (C++)
Avoid Artifacts with High Depth of Code (C Lang.)
Avoid Artifacts with High Depth of Code (C# .Net)
Avoid Artifacts with High Depth of Code (DB2 Server)
Avoid Artifacts with High Depth of Code (Forms)
Avoid Artifacts with High Depth of Code (JEE)
Avoid Artifacts with High Depth of Code (JSP)
Avoid Artifacts with High Depth of Code (PL/SQL Oracle)
Avoid Artifacts with High Depth of Code (PowerBuilder)
Avoid Artifacts with High Depth of Code (SQL Server)
Avoid Artifacts with High Depth of Code (Visual Basic)
Avoid Artifacts with High Essential Complexity
Avoid Artifacts with High Essential Complexity (ABAP)
Avoid Artifacts with High Essential Complexity (ASP)
Avoid Artifacts with High Essential Complexity (C++)
Avoid Artifacts with High Essential Complexity (C Lang.)
Avoid Artifacts with High Essential Complexity (C# .Net)
Avoid Artifacts with High Essential Complexity (DB2 Server)
Avoid Artifacts with High Essential Complexity (Forms)
Avoid Artifacts with High Essential Complexity (JEE)
Avoid Artifacts with High Essential Complexity (JSP)
Avoid Artifacts with High Essential Complexity (PL/SQL Oracle)
Avoid Artifacts with High Essential Complexity (PowerBuilder)
Avoid Artifacts with High Essential Complexity (SQL Server)
Avoid Artifacts with High Essential Complexity (Visual Basic)
Avoid Artifacts with High Fan-In
Avoid Artifacts with High Fan-In (ABAP)
Avoid Artifacts with High Fan-In (ASP)
Avoid Artifacts with High Fan-In (C++)
Avoid Artifacts with High Fan-In (C Lang.)
Avoid Artifacts with High Fan-In (C# .Net)
Avoid Artifacts with High Fan-In (DB2 Server)
Avoid Artifacts with High Fan-In (Forms)
Avoid Artifacts with High Fan-In (JEE)
Avoid Artifacts with High Fan-In (JSP)
Avoid Artifacts with High Fan-In (PL/SQL Oracle)
Avoid Artifacts with High Fan-In (PowerBuilder)
Avoid Artifacts with High Fan-In (SQL Server)
Avoid Artifacts with High Fan-In (Visual Basic)
Avoid Artifacts with High Fan-Out
Avoid Artifacts with High Fan-Out (ABAP)
Avoid Artifacts with High Fan-Out (ASP)
Avoid Artifacts with High Fan-Out (C++)
Avoid Artifacts with High Fan-Out (C Lang.)
Avoid Artifacts with High Fan-Out (C# .Net)
Avoid Artifacts with High Fan-Out (DB2 Server)
Avoid Artifacts with High Fan-Out (Forms)
Avoid Artifacts with High Fan-Out (JEE)
Avoid Artifacts with High Fan-Out (JSP)
Avoid Artifacts with High Fan-Out (PL/SQL Oracle)
Avoid Artifacts with High Fan-Out (PowerBuilder)
Avoid Artifacts with High Fan-Out (SQL Server)
Avoid Artifacts with High Fan-Out (Visual Basic)
Avoid Artifacts with High integration complexity
Avoid Artifacts with High Integration Complexity
Avoid Artifacts with High integration complexity (ABAP)
Avoid Artifacts with High Integration Complexity (ASP)
Avoid Artifacts with High Integration Complexity (C++)
Avoid Artifacts with High Integration Complexity (C Lang.)
Avoid Artifacts with High Integration Complexity (C# .Net)
Avoid Artifacts with High Integration Complexity (DB2 Server)
Avoid Artifacts with High Integration Complexity (Forms)
Avoid Artifacts with High Integration Complexity (JEE)
Avoid Artifacts with High Integration Complexity (JSP)
Avoid Artifacts with High Integration Complexity (PL/SQL Oracle)
Avoid Artifacts with High Integration Complexity (SQL Server)
Avoid Artifacts with High Integration Complexity (Visual Basic)
Avoid Artifacts with High RAW SQL Complexity
Avoid Artifacts with High RAW SQL Complexity (ABAP)
Avoid Artifacts with High RAW SQL Complexity (PowerBuilder)
Avoid Artifacts with High RAW SQL Complexity (Visual Basic)
Avoid Artifacts with more than 5 parameters (PowerBuilder)
Avoid Artifacts with too many parameters
Avoid Artifacts with too many parameters
Avoid artifacts with too many parameters (ASP)
Avoid artifacts with too many parameters (C++)
Avoid artifacts with too many parameters (C Lang.)
Avoid artifacts with too many parameters (C# .Net)
Avoid artifacts with too many parameters (DB2 Server)
Avoid artifacts with too many parameters (Forms)
Avoid Artifacts with too many parameters (Javascript)
Avoid artifacts with too many parameters (JEE)
Avoid artifacts with too many parameters (JSP)
Avoid artifacts with too many parameters (PL/SQL Oracle)
Avoid Artifacts with too many parameters (SQL Server)
Avoid Artifacts with too many parameters (Swift)
Avoid artifacts with too many parameters (Visual Basic)
Avoid base Classes without virtual Destructors
CRITICAL  Avoid BindingUtils class that uses hard coded strings (Flex)
Avoid blocking async methods (.NET, VB)
CRITICAL  Avoid Buffer Overruns when using ADD, SUBTRACT, MULTIPLY, DIVIDE & COMPUTE statement inside a loop
CRITICAL  Avoid CairngormEventDispatcher called explicitly (Flex)
CRITICAL  Avoid calling Alert.show directly (Flex)
Avoid calling blocking functions with an infinite timeout
CRITICAL  Avoid calling callLater explicitly (Flex specific) (Flex)
Avoid calling the same paragraph with PERFORM and GO TO statements
Avoid calls between JSP Pages
Avoid cascading Triggers
Avoid cascading Triggers (SQL)
Avoid casting and converting a pointer type to an integral type (C/C++)
Avoid catch-all except blocks with empty handlers
Avoid 'catch-all' statement
Avoid catch blocks with assertion
Avoid catching an exception of type Exception (C# .Net)
Avoid catching an exception of type Exception, RuntimeException, or Throwable
Avoid catching an exception of type Exception, RuntimeException, or Throwable (JEE)
CRITICAL  Avoid ChangeWatcher class that uses hard coded strings to specify the attribute name, to listen to. Prefer listening to events or setters (Flex)
Avoid changing parent properties from child components using $parent
Avoid circular references between header files
CRITICAL  Avoid class duplicated with a SDK class (Flex)
CRITICAL  Avoid Classes and Interfaces with a High Depth of Inheritance Tree (PHP)
CRITICAL  Avoid classes exceeding maximum length (PHP)
CRITICAL  Avoid classes exceeding number of weighted methods (PHP)
CRITICAL  Avoid classes having a number of public methods and attributes exceeds maximum (PHP)
CRITICAL  Avoid classes having too many children (PHP)
CRITICAL  Avoid classes having too many dependencies (PHP)
CRITICAL  Avoid classes having too many parents (PHP)
Avoid Classes implementing too many Interfaces
Avoid Classes implementing too many Interfaces
CRITICAL  Avoid classes overriding only equals() or only hashCode()
CRITICAL  Avoid Classes using "new" to allocate Instances but not defining a copy Constructor
Avoid Classes with a copy Constructor and the default Destructor or assignment operator
Avoid Classes with a High Depth of Inheritance Tree
Avoid Classes with a High Depth of Inheritance Tree (C++)
Avoid Classes with a High Depth of Inheritance Tree (C# .Net)
Avoid Classes with a High Depth of Inheritance Tree (JEE)
Avoid Classes with a High Depth of Inheritance Tree (Visual Basic)
Avoid Classes with a High Number Of Children
Avoid Classes with a High Number Of Children (C++)
Avoid Classes with a High Number Of Children (C# .Net)
Avoid Classes with a High Number Of Children (JEE)
Avoid Classes with a High Number Of Children (Visual Basic)
Avoid Classes with an assignment operator and the default Destructor or assignment operator
Avoid Classes with a non-empty Destructor and the default assignment operator or copy Constructor
Avoid Classes with at least one virtual Function and without a virtual Destructor
Avoid Classes with Destructor not explicitly virtual whenever one of its base Class has a virtual Destructor
Avoid Classes with High Coupling Between Objects
Avoid Classes with High Coupling Between Objects (C++)
Avoid Classes with High Coupling Between Objects (C# .Net)
Avoid Classes with High Coupling Between Objects (JEE)
CRITICAL  Avoid Classes with High Cyclomatic Complexity (PHP)
Avoid Classes with High Weighted Methods per Class
Avoid Classes with High Weighted Methods per Class (C++)
Avoid Classes with High Weighted Methods per Class (C# .Net)
Avoid Classes with High Weighted Methods per Class (JEE)
Avoid Classes with High Weighted Methods per Class (PowerBuilder)
Avoid Classes with High Weighted Methods per Class (Visual Basic)
CRITICAL  Avoid classes with misplaced metadata (Flex)
Avoid Classes with multiple inheritance
CRITICAL  Avoid classes with too many fields (PHP)
CRITICAL  Avoid classes with too many methods (PHP)
CRITICAL  Avoid classes with unknown metadata attribute (Flex)
CRITICAL  Avoid class that imports an internal class from another function area (Flex)
CRITICAL  Avoid clone event not overiden in a custom event (Flex)
Avoid comparing types of different widths in a loop
Avoid Constructors not supplying an initial value for all non-static data members
CRITICAL  Avoid constructor with a return type (Flex)
Avoid custom code with OSS notes
CRITICAL  Avoid cyclical calls and inheritances between namespaces content
CRITICAL  Avoid cyclical calls and inheritances between packages
Avoid cyclic calls between Event and its handled Method
Avoid cyclic calls with PERFORM statements
Avoid cyclic references in the definition of CDS views (S4/HAHA)
Avoid database tables associated to more than one Entity
Avoid data members that are never read
Avoid Datawindows accessing Database Procedures or Functions
Avoid Datawindows accessing Database Tables (PowerBuilder)
Avoid Datawindows that does not access a database data
Avoid debug code in the production system (PHP)
CRITICAL  Avoid declaring null arrays; prefer to set to empty (EGL)
Avoid declaring same OData model twice
Avoid declaring throwing an exception and not throwing it
Avoid declaring VB Variables without typing them
Avoid declaring VB Variables without typing them
Avoid #define or #undef macros anywhere other than global namespace
CRITICAL  Avoid defining File Disk if not used (RPG300)
CRITICAL  Avoid defining File Disk if not used (RPG400)
Avoid defining, redefining or undefining standard macros from standard library
Avoid defining singleton or factory when using Spring
Avoid delete operators to exit with an exception.
Avoid direct access to database Procedures/Functions (JSP)
Avoid direct access to Database Tables
CRITICAL  Avoid direct access to database Tables (ASP)
CRITICAL  Avoid direct access to Database Tables (C# .Net)
Avoid direct access to Database Tables in Javascript
CRITICAL  Avoid direct access to database Tables (JSP)
Avoid direct Class inheritance from java.lang.Throwable
Avoid direct definition of JavaScript Functions in a Web page
CRITICAL  Avoid direct definition of JavaScript Functions in a Web page (PHP)
CRITICAL  Avoid directly instantiating a Class used as a Spring bean
CRITICAL  Avoid direct usage of database tables (C++)
CRITICAL  Avoid direct usage of database Tables (C Lang.)
CRITICAL  Avoid Direct usage of database Tables (Visual Basic)
Avoid direct usage of EJB Entity from the client
Avoid direct use of database objects (ASP - JavaScript)
Avoid direct use of Database objects (JSP/ASP)
Avoid disabling custom errors mode to prevent exposure of exceptions and error data
Avoid disabling source code inspection
CRITICAL  Avoid DispatchEvent function not dispatching constant strings (Flex)
Avoid DISPLAY ... UPON CONSOLE
Avoid doing assignments in sub-expressions (C++)
Avoid domain model depending on other Java API
CRITICAL  Avoid double checked locking
CRITICAL  Avoid duplicated Main Procedures (PL1)
Avoid duplicate Programs in different files (PL1)
Avoid dynamic_cast to convert current object to its derived class from its constructor or destructor
CRITICAL  Avoid dynamic class (Flex)
Avoid EJBs using 'synchronized' qualifier, 'wait', 'notify' and 'notifyAll' Methods
CRITICAL  Avoid empty catch blocks
CRITICAL  Avoid empty catch blocks
CRITICAL  Avoid empty catch blocks
CRITICAL  Avoid empty CATCH blocks (ABAP)
CRITICAL  Avoid empty catch blocks (C# .Net)
Avoid empty catch blocks for methods with high fan-in
CRITICAL  Avoid empty catch blocks (JEE)
CRITICAL  Avoid empty catch blocks (PHP)
CRITICAL  Avoid empty catch statement (Flex)
Avoid empty componentDidCatch blocks
Avoid empty componentDidCatch blocks (Typescript)
Avoid empty finally block
Avoid empty finally block
Avoid empty finally blocks
Avoid empty finally blocks (C# .Net)
Avoid empty finally blocks (JEE)
Avoid Empty Finally Block When Calling Resource
CRITICAL  Avoid empty generic catch blocks (Swift)
CRITICAL  Avoid empty IF-ENDIF blocks
CRITICAL  Avoid empty if statements (Flex)
CRITICAL  Avoid empty jQuery ajax error/fail blocks
CRITICAL  Avoid event dispatched in a constructor (Flex)
Avoid excessive number of successive nested Procedure calls and limit it to two (PL1)
Avoid exporting namespaces
CRITICAL  Avoid Fields in Action Classes that are not final static
CRITICAL  Avoid Fields in Servlet Classes that are not final static
Avoid files that declare both symbols and execute logic with side effects (PHP)
Avoid flexible array members (C/C++)
CRITICAL  Avoid FOR loops which can be simplified to a WHILE loop (PHP)
CRITICAL  Avoid FrontController that adds all its commands within the Controller constructor (Flex)
Avoid Function pools with more than 20 functions
Avoid Functions and Procedures doing an Insert, Update or Delete without managing a transaction
Avoid Functions and Procedures doing an Insert, Update or Delete without managing a transaction (SQL)
Avoid Functions and Procedures having a SELECT without the default OTHERWISE clause (PL1)
Avoid Functions and Procedures having multiple statements on the same line (PL1)
Avoid Functions and Procedures not having variable declared on a separate line (PL1)
Avoid Functions and Procedures not testing the SQLCODE return code after each SQL statement (PL1)
Avoid Functions and Procedures using logical operators (or, and) in the "WHEN" clause of the SELECT statement (PL1)
Avoid Functions and Procedures using RETURN statements (PL1)
Avoid Functions and Procedures with DB2 SQL containing "UNION" clause without "ALL" option (PL1)
Avoid Functions and Procedures with "OR" logical operator in DB2 queries and in cursor definitions (PL1)
CRITICAL  Avoid functions having the optional parameters before the others (PHP)
Avoid Functions/Methods with a complex SELECT clause (C++)
Avoid Functions/Methods with High RAW SQL Complexity (C++)
Avoid functions overriding virtual functions without having the 'virtual' keyword
Avoid Functions/Procedures/Triggers with a complex SELECT clause (PL/SQL Oracle)
Avoid Functions/Procedures with a complex SELECT clause (DB2 Server)
Avoid Functions/Procedures with a complex SELECT clause (SQL Server)
Avoid Functions/Procedures with High RAW SQL Complexity (DB2 Server)
Avoid Functions/Procedures with High RAW SQL Complexity (SQL Server)
CRITICAL  Avoid Functions throwing exceptions and not having a @Throws tag (PHP)
Avoid Functions with a complex SELECT clause (C Lang.)
Avoid Functions with a high Fan-in (Fortran)
Avoid Functions with a high Fan-out (Fortran)
Avoid Functions with a High number of Paths (Fortran)
Avoid Functions with High Average size of Statements (AVGS) (Fortran)
Avoid Functions with High Cyclomatic Complexity (EGL)
Avoid Functions with High Cyclomatic Complexity (Fortran)
Avoid Functions with High Fan-In (EGL)
Avoid Functions with High Fan-Out (EGL)
Avoid Functions with High Program Length (PR_LGTH) (Fortran)
Avoid Functions with High RAW SQL Complexity (C Lang.)
Avoid Functions with High Vocabulary Frequency (VOCF) (Fortran)
Avoid Functions with more then 1 statement per line (Fortran)
Avoid functions without returning exit code (Shell)
CRITICAL  Avoid function with unused parameter (Flex)
Avoid getter functions of computed properties that do not return any value
CRITICAL  Avoid globally bindable classes. (Flex)
Avoid GOTO jumps out of PERFORM range
CRITICAL  Avoid hardcoded network resource names
Avoid hardcoded network resource names
Avoid hardcoded network resource names in Javascript
CRITICAL  Avoid hardcoded network resource names (Kotlin)
Avoid hardcoded network resource names (.NET, VB)
Avoid hard-coded network resource names (Swift)
Avoid hardcoded network resource names (Typescript)
CRITICAL  Avoid hardcoded timeout in Process Activities (TIBCO BW)
Avoid having a method call or additional expressions in a statement using "++" or "--" operators (C/C++)
Avoid having boolean operators with non-boolean operands (C/C++)
Avoid having call function return ignored (PHP)
Avoid having Classes implementing too many Interfaces
CRITICAL  Avoid having Classes implementing too many Interfaces (PHP)
CRITICAL  Avoid having class methods without scope modifiers - Symfony STD (PHP)
CRITICAL  Avoid having constructors with a return value (PHP)
Avoid having errors without throwing them
Avoid having expressions with bool type to be used as operands on operators other than =, &&, ||, !, ==, !=, the unary & operator, and the conditional operator
Avoid having functions with no return (PHP)
Avoid having handleHardIOErrors property enabled (EGL)
CRITICAL  Avoid having inline control statements (PHP)
Avoid having local forward with same name as global forward
Avoid having lock on this object
Avoid having lonely variables (PHP)
Avoid having MongoDB databases access without authentication activated
Avoid having multiple artifacts deleting data on the same SQL table
Avoid having multiple artifacts deleting data on the same SQL table (EGL)
CRITICAL  Avoid having multiple artifacts deleting data on the same SQL table (PLC)
CRITICAL  Avoid having multiple artifacts deleting data on the same SQL table (PLI)
Avoid having multiple Artifacts inserting data on the same SQL Table
Avoid having multiple artifacts inserting data on the same SQL table (EGL)
CRITICAL  Avoid having multiple artifacts inserting data on the same SQL table (PLC)
CRITICAL  Avoid having multiple artifacts inserting data on the same SQL table (PLI)
Avoid having multiple Artifacts updating data on the same SQL Table
Avoid having multiple artifacts updating data on the same SQL table (EGL)
CRITICAL  Avoid having multiple artifacts updating data on the same SQL table (PLC)
CRITICAL  Avoid having multiple artifacts updating data on the same SQL table (PLI)
CRITICAL  Avoid having multiple classes defined in a single file - Symfony STD (PHP)
CRITICAL  Avoid having object not instantiated using parenthesis - Symfony STD (PHP)
CRITICAL  Avoid having overrided record declaration with a duplicate declaration in the same application (EGL)
Avoid having properties with __get and no __set (PHP)
CRITICAL  Avoid having the assignment to "$this" (PHP)
Avoid having the same implementation in a conditional structure
Avoid having transaction with the Thread.Sleep method in a loop
Avoid having unmatched contracts for exported interfaces
Avoid having unreferenced code
Avoid having unused labels in your program (C/C++)
CRITICAL  Avoid having unused variables (PHP)
Avoid having V60ExceptionCompatibility property set to NO (EGL)
CRITICAL  Avoid having variables passed by reference when calling a function (PHP)
Avoid header files circular references
Avoid hiding attributes
Avoid hiding attributes (JEE)
CRITICAL  Avoid hiding static Methods
Avoid High Coupling Between Object Classes (PowerBuilder)
Avoid high depth of code in Functions (Fortran)
Avoid high depth of code in Programs (Fortran)
Avoid high depth of code in Subroutines (Fortran)
Avoid high level of Nesting in Functions (Fortran)
Avoid high level of Nesting in Programs (Fortran)
Avoid high level of Nesting in Subroutines (Fortran)
Avoid High Response for a Class (C++)
Avoid High Response for a Class (C# .Net)
Avoid High Response for a Class (JEE)
Avoid High Response for a Class (PowerBuilder)
Avoid High Response for Classes
CRITICAL  Avoid identical switch cases (Flex)
Avoid if … else if constructs not terminated with an else clause (.NET, VB)
Avoid if statements and blocks that are always TRUE or FALSE
Avoid implementing Action Classes inheriting directly from Struts Action
Avoid improper instantiation of argument exceptions
CRITICAL  Avoid improper processing of the execution status of data handling operations
Avoid Include Circular references
Avoid incoherent file accesses in Cobol programs and DISP clauses in JCL
Avoid inconsistent initialization when deriving a new exception
CRITICAL  Avoid incorrect signature of the message interceptor. (Flex)
CRITICAL  Avoid incrementer jumbling in loops (PHP)
Avoid inheritance down the Package path
Avoid instance attributes only differing by capitalization
Avoid instanceof in Methods that override or implement Object.equals(), Comparable.compareTo()
CRITICAL  Avoid invocation of virtual Methods of the declared Class in a Constructor or Destructor
Avoid invoking super more than once in constructor
Avoid iterator invalidation.
Avoid jump statements in finally
Avoid large Classes - too many Constructors
Avoid large Classes - too many Constructors
Avoid large Classes - too many Constructors
Avoid large Classes - too many Data Members
Avoid large Classes - too many Data Members
Avoid large Classes - too many Fields
Avoid large Classes - too many Methods
Avoid large Classes - too many Methods
Avoid large Classes - too many Methods
Avoid large Classes - too many Methods
Avoid large Classes - too many Methods (Kotlin)
Avoid large Interfaces - too many Methods
Avoid large Interfaces - too many Methods
Avoid large Interfaces - too many Methods
Avoid large Interfaces - too many Methods
CRITICAL  Avoid large Interfaces - too many Methods (PHP)
Avoid large JSP Pages - too many Scriptlets
Avoid large Programs - too many Sections
Avoid large Tables - too many columns
Avoid large Tables - too many columns (SQL)
CRITICAL  Avoid leaving temporary files in directory (JEE)
Avoid lines starting with "#" with invalid pre-processing directive
Avoid local variables that are not initialized at declaration time
CRITICAL  Avoid locking object by ALCOBJ command (CL400)
Avoid locking object by ALCOBJ command (CL400)
Avoid locking of Objects with weak identities
Avoid Logical File without associated Physical File (DB400)
CRITICAL  Avoid Logical File without associated Physical File (DDS400)
CRITICAL  Avoid long parameter list (Flex)
CRITICAL  Avoid long switch case (Flex)
Avoid loops with floating point counter (C/C++)
Avoid Main Procedures having LEAVE statement (PL1)
CRITICAL  Avoid Main Procedures not having an ON ERROR clause (PL1)
CRITICAL  Avoid Main procedures using the DATE builtin function (PL1)
CRITICAL  Avoid Main procedures using the DATE builtin Function via include PLC (PL1)
CRITICAL  Avoid managed events without matching [Event] metadata (Flex)
Avoid Managed type declaration for Win32 API using Overlapped IO
Avoid manipulating a list while iterating over it
Avoid many-to-many association
Avoid Menus, UserObjects and Windows that have no inheritance relations with other objects
Avoid menu with too high level of inheritance
CRITICAL  Avoid method invocation in a loop termination expression (PHP)
CRITICAL  Avoid method metadata argument redundant with the handler name (Flex)
CRITICAL  Avoid Methods and Functions directly access to database tables (PHP)
CRITICAL  Avoid Methods and Functions with High Cyclomatic Complexity (PHP)
CRITICAL  Avoid Methods and Functions with High Fan-In (PHP)
CRITICAL  Avoid Methods and Functions with High Fan-Out (PHP)
CRITICAL  Avoid methods having length exceeding the maximum (PHP)
CRITICAL  Avoid methods having too many parameters (PHP)
CRITICAL  Avoid method with more than one exit point (Flex)
Avoid missing default in switch statements
Avoid missing default in switch statements (JEE)
CRITICAL  Avoid missing WHEN OTHERS in CASE statements
CRITICAL  Avoid ModelLocator not only accessible from the main application file (Flex)
Avoid Modules with a High number of Paths (Fortran)
Avoid Modules with High Average size of Statements (AVGS) (Fortran)
Avoid Modules with High Cyclomatic Complexity (Fortran)
Avoid Modules with High Program Length (PR_LGTH) (Fortran)
Avoid Modules with High Vocabulary Frequency (VOCF) (Fortran)
Avoid Modules with more then 1 statement per line (Fortran)
CRITICAL  Avoid more than one reference of ModelLocator per class (Flex)
Avoid move constructor and move assignment operator to exit with an exception
Avoid mutable default parameter values
Avoid namespaces with High Afferent Coupling (CA)
Avoid Namespaces with High Efferent Coupling (CE)
CRITICAL  Avoid nested if statements (Flex)
CRITICAL  Avoid nested switch statements (Flex)
Avoid non-public custom exception types
Avoid non serializable Entities
Avoid non serializable Entity beans
CRITICAL  Avoid non thread safe singleton
Avoid non-void return type function without an explicit return of an expression (C/C++)
Avoid Not ... Is
Avoid NULL Pointer Dereference (C#, VB.NET)
CRITICAL  Avoid numerical data corruption during incompatible mutation
Avoid Objects with a High Depth of Inheritance Tree (PowerBuilder)
Avoid Objects with a High Number Of Children (PowerBuilder)
CRITICAL  Avoid obsolete E-spec (RPG400)
Avoid obsolete E-spec (RPG400)
Avoid obsolete E-spec (RPG_FP)
Avoid obsolete L-spec (RPG400)
CRITICAL  Avoid obsolete L-spec (RPG400)
Avoid obsolete L-spec (RPG_FP)
Avoid old VAGen Compatibility statements (EGL)
Avoid orphaned synonyms
Avoid orphaned synonyms in PL/SQL context
Avoid overriding event
CRITICAL  Avoid oversized processes Activities (1100x900) (TIBCO BW)
Avoid Packages with High Afferent Coupling (CA)
Avoid Packages with High Efferent Coupling (CE)
CRITICAL  Avoid packages with high number of imports (Flex)
CRITICAL  Avoid packages with misplaced metadata (Flex)
CRITICAL  Avoid packages with unknown metadata attribute (Flex)
CRITICAL  Avoid packages with view components referenced in a model class (Flex)
Avoid PB Function/Event/Method accessing Database Procedures or Functions
Avoid PB Function/Event/Method accessing Database Tables (PowerBuilder)
Avoid performing conversion from a function pointer to any other type (C/C++)
Avoid PHP Dangerous Feature (PHP)
CRITICAL  Avoid Physical files with fields defined locally (DDS400)
Avoid Physical files with more than X associated LF (DB400)
CRITICAL  Avoid Physical files with more than X associated LF (DDS400)
Avoid Physical files with more than X fields (DB400)
CRITICAL  Avoid Physical files with more than X fields (DDS400)
Avoid Physical File updated by multiple program (DB400)
Avoid PL1 Errors Blocks having ON ERROR SYSTEM blocks and not containing and displaying ONCODE and ONLOC (PL1)
Avoid PLC Copybook using GOTO statement (PL1)
Avoid PLC Copybook with High Cyclomatic Complexity (PL1)
CRITICAL  Avoid PLC Includes having recursive PLC procedures (PL1)
Avoid PLC Procedures & Functions with a High Fan-in (PL1)
Avoid PLC Procedures & Functions with a High Fan-out (PL1)
Avoid PLC Procedures & Functions with High Cyclomatic Complexity (PL1)
CRITICAL  Avoid PLI Functions and Procedures declared as RECURSIVE (PL1)
Avoid PLI Main procedures, PL1 function and PL1 Procedures using GOTO statement (PL1)
Avoid PLI Main Proc with High Cyclomatic Complexity (PL1)
Avoid PLI Procedures & Functions with a High Fan-in (PL1)
Avoid PLI Procedures & Functions with a High Fan-out (PL1)
Avoid PLI Procedures & Functions with High Cyclomatic Complexity (PL1)
Avoid PLI Programs with more then 500 LoC and less then 5 Procedures (PL1)
Avoid PLI Programs with more then 5 internal File structures (PL1)
Avoid PLI Programs with more then XX Procedures (PL1)
Avoid PL/SQL Artifacts with High RAW SQL Complexity (PL/SQL Oracle)
Avoid Procedures and Functions using the ITERATE statement (PL1)
CRITICAL  Avoid Procedures using an Insert, Update, Delete, Create Table or Select without including error management
CRITICAL  Avoid Procedures with High Cyclomatic Complexity (RPG400)
Avoid Procedures with High Cyclomatic Complexity (RPG400)
Avoid Procedures with High Cyclomatic Complexity (RPG_FP)
Avoid Procedures with High Fan-In (RPG400)
CRITICAL  Avoid Procedures with High Fan-In (RPG400)
Avoid Procedures with High Fan-In (RPG_FP)
Avoid Procedures with High Fan-Out (RPG400)
CRITICAL  Avoid Procedures with High Fan-Out (RPG400)
Avoid Procedures with High Fan-Out (RPG_FP)
CRITICAL  Avoid Processes using JDBC SQL Direct (TIBCO BW)
Avoid processing Google Sign In Client without catching error
CRITICAL  Avoid Process with too many Activities (TIBCO BW)
CRITICAL  Avoid program calls outside a try end block (EGL)
CRITICAL  Avoid Program calls without checking the return code (EGL)
Avoid Programs accessing directly to Physical Files (RPG300)
Avoid Programs accessing directly to Physical Files (RPG400)
Avoid Programs accessing directly to Physical Files (RPG_FP)
Avoid Programs accessing more than X physical files (RPG300)
Avoid Programs accessing more than X physical files (RPG400)
Avoid Programs accessing more than X physical files (RPG_FP)
Avoid Programs declaring STATIC variables (PL1)
Avoid Programs having cursors that doesn't contain the "FOR UPDATE" clause and not containing the "FOR READ ONLY" or "FOR FETCH ONLY" clause (PL1)
Avoid Programs having files declared and not having the ON UNDF or ON UNDEFINEDFILE statement except SYSPRINT and SYSIN (PL1)
Avoid Programs having files declared as RECORD INPUT or RECORD UPDATE and not having the ON EOF or ON ENDFILE statement (PL1)
Avoid Programs having FIXED without BIN or BINARY or DEC or DECIMAL.The character "(" is mandatory. (PL1)
Avoid Programs having modules declared as external entries and unused (PL1)
Avoid Programs/Includes with too many Forms
Avoid Programs not having localSQLScope property set to NO (EGL)
Avoid programs not having the property allowUnqualifiedItemReferences set to YES (EGL)
Avoid programs not having the property I4GLItemsNullable set to NO (EGL)
Avoid Programs not having the property includeReferencedFunctions set to YES (EGL)
Avoid Programs overriding the *PROCESS statement (PL1)
Avoid Programs with a Complex SELECT Clause (Cobol)
Avoid Programs with a high Fan-in (Fortran)
Avoid Programs with a high Fan-out (Fortran)
Avoid Programs with a High number of Paths (Fortran)
Avoid Programs with High Average size of Statements (AVGS) (Fortran)
Avoid Programs with High Cyclomatic Complexity (CL400)
CRITICAL  Avoid Programs with High Cyclomatic Complexity (CL400)
Avoid Programs with High Cyclomatic Complexity (Cobol)
Avoid Programs with High Cyclomatic Complexity (Fortran)
CRITICAL  Avoid Programs with High Cyclomatic Complexity (RPG300)
Avoid Programs with High Cyclomatic Complexity (RPG300)
CRITICAL  Avoid Programs with High Cyclomatic Complexity (RPG400)
Avoid Programs with High Cyclomatic Complexity (RPG400)
Avoid Programs with High Cyclomatic Complexity (RPG_FP)
Avoid Programs with High Depth of Code (Cobol)
Avoid Programs with High Essential Complexity (Cobol)
Avoid Programs with High Fan-In (Cobol)
Avoid Programs with High Fan-In (EGL)
CRITICAL  Avoid Programs with High Fan-In (RPG300)
Avoid Programs with High Fan-In (RPG300)
Avoid Programs with High Fan-In (RPG400)
CRITICAL  Avoid Programs with High Fan-In (RPG400)
Avoid Programs with High Fan-In (RPG_FP)
Avoid Programs with High Fan-Out (Cobol)
Avoid Programs with High Fan-Out (EGL)
Avoid Programs with High Fan-Out (RPG300)
CRITICAL  Avoid Programs with High Fan-Out (RPG300)
CRITICAL  Avoid Programs with High Fan-Out (RPG400)
Avoid Programs with High Fan-Out (RPG400)
Avoid Programs with High Fan-Out (RPG_FP)
Avoid Programs with High Integration Complexity (Cobol)
Avoid Programs with High Program Length (PR_LGTH) (Fortran)
Avoid Programs with High RAW SQL Complexity (Cobol)
Avoid Programs with High RAW SQL Complexity (RPG400)
Avoid Programs with High RAW SQL Complexity (RPG_FP)
Avoid Programs with High Vocabulary Frequency (VOCF) (Fortran)
CRITICAL  Avoid Programs with more than X Data Structures (RPG400)
Avoid Programs with more than X Data Structures (RPG400)
Avoid Programs with more than X Data Structures (RPG_FP)
Avoid Programs with more than X Functions (EGL)
Avoid Programs with more than X LoC and no Subroutines (RPG300)
CRITICAL  Avoid Programs with more than X LoC and no Subroutines (RPG300)
Avoid Programs with more than X LoC and no Subroutines (RPG400)
CRITICAL  Avoid Programs with more than X LoC and no Subroutines (RPG400)
Avoid Programs with more than X LoC and no Subroutines (RPG_FP)
Avoid Programs with more than X Procedures (RPG400)
Avoid Programs with more than X Procedures (RPG_FP)
CRITICAL  Avoid Programs with more than X Subroutines (RPG300)
Avoid Programs with more than X Subroutines (RPG300)
Avoid Programs with more than X Subroutines (RPG400)
CRITICAL  Avoid Programs with more than X Subroutines (RPG400)
Avoid Programs with more than X Subroutines (RPG_FP)
Avoid Programs with more then 1 statement per line (Fortran)
Avoid Programs with too many includes
Avoid public/protected setter for the generated identifier field
Avoid public/protected setter for the generated identifier field
Avoid queries using old style join convention instead of ANSI-Standard joins
Avoid raising an exception in a Web Dynpro Supply Function or in a Method called by a Supply Function
Avoid raising exceptions in unexpected location
CRITICAL  Avoid Record Column without having the same nullable requirement as the corresponding SQL Table column (EGL)
CRITICAL  Avoid recursive calls with PERFORM statements
Avoid recursive Triggers
Avoid redeclaring and overriding Methods with different default parameter values
Avoid rethrow exception explicitly
Avoid returning null from non-async Task/Task method
Avoid returning null from ToString()
Avoid return statement in @finally block
Avoid return statement in @finally block
Avoid return statement in finally block
Avoid return statement in finally block
Avoid return statements in finally blocks (JEE)
CRITICAL  Avoid Script Functions with High Fan-In (PHP)
CRITICAL  Avoid Script Functions with High Fan-Out (PHP)
Avoid scripts and functions using SQL static statements (Shell)
Avoid scripts and functions with SQL code in temporary files (Shell)
CRITICAL  Avoid scripts high number of imports (Flex)
CRITICAL  Avoid scripts with view components referenced in a model class (Flex)
Avoid script without interpretor access path (Shell)
CRITICAL  Avoid Sections directly access to database tables (PHP)
CRITICAL  Avoid Sections with High Cyclomatic Complexity (PHP)
Avoid "SELECT *" or "SELECT SINGLE *" queries
Avoid "SELECT *" queries
Avoid "SELECT *" queries (EGL)
Avoid 'Service Contract' without any 'Operation Contract'
CRITICAL  Avoid setting a pointer to the address of a local variable defined in a lower scope
Avoid shadowing class variables
Avoid SQL Artifacts with High RAW SQL Complexity (JEE)
CRITICAL  Avoid SQL query outside try-on block (EGL)
Avoid static Fields that are not final
Avoid STOP RUN (use GOBACK instead)
Avoid Stored Procedures not returning a status value
CRITICAL  Avoid storing Non-Serializable Object as HttpSessionState attributes.
Avoid String concatenation in loops for artifacts with high fan in
Avoid Subroutines with a high Fan-in (Fortran)
Avoid Subroutines with a high Fan-out (Fortran)
Avoid Subroutines with a High number of Paths (Fortran)
Avoid Subroutines with High Average size of Statements (AVGS) (Fortran)
Avoid Subroutines with High Cyclomatic Complexity (Fortran)
Avoid Subroutines with High Cyclomatic Complexity (RPG300)
CRITICAL  Avoid Subroutines with High Cyclomatic Complexity (RPG300)
CRITICAL  Avoid Subroutines with High Cyclomatic Complexity (RPG400)
Avoid Subroutines with High Cyclomatic Complexity (RPG400)
Avoid Subroutines with High Cyclomatic Complexity (RPG_FP)
CRITICAL  Avoid Subroutines with High Fan-In (RPG300)
Avoid Subroutines with High Fan-In (RPG300)
CRITICAL  Avoid Subroutines with High Fan-In (RPG400)
Avoid Subroutines with High Fan-In (RPG400)
Avoid Subroutines with High Fan-In (RPG_FP)
CRITICAL  Avoid Subroutines with High Fan-Out (RPG300)
Avoid Subroutines with High Fan-Out (RPG300)
Avoid Subroutines with High Fan-Out (RPG400)
CRITICAL  Avoid Subroutines with High Fan-Out (RPG400)
Avoid Subroutines with High Fan-Out (RPG_FP)
Avoid Subroutines with High Program Length (PR_LGTH) (Fortran)
Avoid Subroutines with High Vocabulary Frequency (VOCF) (Fortran)
Avoid Subroutines with more then 1 statement per line (Fortran)
Avoid Subroutines with nested if Statements (RPG300)
CRITICAL  Avoid Subroutines with nested if Statements (RPG300)
CRITICAL  Avoid Subroutines with nested IF statements (RPG400)
Avoid Subroutines with nested IF statements (RPG400)
Avoid Subroutines with nested IF statements (RPG_FP)
Avoid super class knowing sub-class
Avoid Superclass knowing Subclass
Avoid Superclass knowing Subclass (C# .Net)
Avoid Superclass knowing Subclass in Javascript
Avoid Superclass knowing Subclass (JEE)
Avoid Superclass knowing Subclass (Swift)
Avoid Superclass (or Interface) knowing Subclass (or Interface)
CRITICAL  Avoid switch statement without a default statement (Flex)
CRITICAL  Avoid switch statement with too few branches (Flex)
Avoid table and column names that are too long (portability)
Avoid Tables not using referential integrity
Avoid Tables with more than 20 columns on an OLTP system
Avoid Tables with more than 20 columns on an OLTP system (DB2 Server)
Avoid Tables with more than 20 columns on an OLTP system (SQL Server)
CRITICAL  Avoid Tables without Primary Key
CRITICAL  Avoid test containing a hard coded boolean value. (Flex)
CRITICAL  Avoid testing floating point numbers for equality
Avoid testing floating point numbers for equality
CRITICAL  Avoid test that does not contain at least one assertion (Flex)
Avoid