UnnecessarySafeNavigationOperator.description=Check for the safe navigation operator (?.) applied to constants and literals, which can never be null.
UnnecessarySafeNavigationOperator.description.html=Check for the <em>safe navigation operator</em> (?.) applied to constants and literals, which can never be null.

Instanceof.description=Checks for use of the instanceof operator. Use the ignoreTypeNames property to configure ignored type names.
Instanceof.description.html=Checks for use of the <em>instanceof</em> operator. Use the <em>ignoreTypeNames</em> property to configure ignored type names.

MultipleUnaryOperators.description=Checks for multiple consecutive unary operators. These are confusing, and are likely typos and bugs.
MultipleUnaryOperators.description.html=Checks for multiple consecutive unary operators. These are confusing, and are likely typos and bugs.

ToStringReturnsNull.description=Checks for toString() methods that return null.
ToStringReturnsNull.description.html=Checks for <em>toString()</em> methods that return null.

JUnitPublicProperty.description=Checks for public properties defined on JUnit test classes. There should be no need to expose a public property on a test class.
JUnitPublicProperty.description.html=Checks for public properties defined on JUnit test classes. There should be no need to expose a public property on a test class.

UnnecessaryToString.description=Checks for unnecessary calls to toString().
UnnecessaryToString.description.html=Checks for unnecessary calls to <em>toString()</em>.

IllegalSubclass.description=Checks for classes that extend one of the specified set of illegal superclasses configured in superclassNames.
IllegalSubclass.description.html=Checks for classes that extend one of the specified set of illegal superclasses configured in <em>superclassNames</em>.

UnnecessaryCast.description=Checks for unnecessary cast operations
UnnecessaryCast.description.html=Checks for unnecessary cast operations

ExceptionExtendsThrowable.description=Checks for classes that extend Throwable. Custom exception classes should subclass Exception or one of its descendants.
ExceptionExtendsThrowable.description.html=Checks for classes that extend <em>java.lang.Throwable</em>. Custom exception classes should subclass <em>java.lang.Exception</em> or one of its descendants.

ClosureStatementOnOpeningLineOfMultipleLineClosure.description=Checks for closure logic on first line (after ->) for a multi-line closure.
ClosureStatementOnOpeningLineOfMultipleLineClosure.description.html=Checks for closure logic on first line (after ->) for a multi-line closure.

SpaceAroundMapEntryColon.description=Check for configured formatting of whitespace around colons for literal Map entries. The characterBeforeColonRegex and characterAfterColonRegex properties specify a regular expression that must match the character before/after the colon.
SpaceAroundMapEntryColon.description.html=Check for configured formatting of whitespace around colons for literal Map entries. The <em>characterBeforeColonRegex</em> and <em>characterAfterColonRegex</em> properties specify a regular expression that must match the character before/after the colon.

IllegalString.description=Checks for a specified illegal string within the source code.
IllegalString.description.html=Checks for a specified illegal string within the source code.

LocaleSetDefault.description=Checks for calls to Locale.setDefault(), which sets the Locale across the entire JVM.
LocaleSetDefault.description.html=Checks for calls to <em>Locale.setDefault()</em>, which sets the Locale across the entire JVM.

SpaceAroundClosureArrow.description=Checks that there is whitespace around the closure arrow (->) symbol
SpaceAroundClosureArrow.description.html=Checks that there is whitespace around the closure arrow (->) symbol

EnumCustomSerializationIgnored.description=Checks for enums that define writeObject() or writeReplace() methods, or declare serialPersistentFields or serialVersionUID fields, all of which are ignored for enums.
EnumCustomSerializationIgnored.description.html=Checks for enums that define writeObject() or writeReplace() methods, or declare serialPersistentFields or serialVersionUID fields, all of which are ignored for enums.

IllegalClassMember.description=Checks for classes containing fields/properties/methods matching configured illegal member modifiers or not matching any of the configured allowed member modifiers.
IllegalClassMember.description.html=Checks for classes containing fields/properties/methods matching configured illegal member modifiers or not matching any of the configured allowed member modifiers.

GStringExpressionWithinString.description=Check for regular (single quote) strings containing a GString-type expression (\\${...}).
GStringExpressionWithinString.description.html=Check for regular (single quote) strings containing a GString-type expression (\\${...}).

JUnitPublicField.description=Checks for public field on a JUnit test class
JUnitPublicField.description.html=Checks for public field on a JUnit test class

FactoryMethodName.description=A factory method is a method that creates objects, and they are typically named either buildFoo(), makeFoo(), or createFoo(). This rule enforces that only one naming convention is used. It defaults to makeFoo(), but that can be changed using the property 'regex'.
FactoryMethodName.description.html=A factory method is a method that creates objects, and they are typically named either buildFoo(), makeFoo(), or createFoo(). This rule enforces that only one naming convention is used. It defaults to makeFoo(), but that can be changed using the property 'regex'.

BuilderMethodWithSideEffects.description=A builder method is defined as one that creates objects. As such, they should never be of void return type. If a method is named build, create, or make, then it should always return a value.
BuilderMethodWithSideEffects.description.html=A builder method is defined as one that creates objects. As such, they should never be of void return type. If a method is named build, create, or make, then it should always return a value.

UnusedMethodParameter.description=This rule finds instances of method parameters not being used. It does not analyze private methods (that is done by the UnusedPrivateMethodParameter rule) or methods marked @Override.
UnusedMethodParameter.description.html=This rule finds instances of method parameters not being used. It does not analyze private methods (that is done by the UnusedPrivateMethodParameter rule) or methods marked @Override. 

UnnecessaryDefInFieldDeclaration.description=If a field has a visibility modifier or a type declaration, then the def keyword is unneeded. For instance, 'static def constraints = {}' is redundant and can be simplified to 'static constraints = {}.
UnnecessaryDefInFieldDeclaration.description.html=If a field has a visibility modifier or a type declaration, then the def keyword is unneeded. For instance, 'static def constraints = {}' is redundant and can be simplified to 'static constraints = {}.

GetterMethodCouldBeProperty.description=If a class defines a public method that follows the Java getter notation, and returns a constant, then it is cleaner to provide a Groovy property for the value rather than a Groovy method.
GetterMethodCouldBeProperty.description.html=If a class defines a public method that follows the Java getter notation, and returns a constant, then it is cleaner to provide a Groovy property for the value rather than a Groovy method.

ConfusingMultipleReturns.description=Multiple return values can be used to set several variables at once. To use multiple return values, the left hand side of the assignment must be enclosed in parenthesis. If not, then you are not using multiple return values, you're only assigning the last element.
ConfusingMultipleReturns.description.html=Multiple return values can be used to set several variables at once. To use multiple return values, the left hand side of the assignment must be enclosed in parenthesis. If not, then you are not using multiple return values, you're only assigning the last element.

LongLiteralWithLowerCaseL.description=In Java and Groovy, you can specify long literals with the L or l character, for instance 55L or 24l. It is best practice to always use an uppercase L and never a lowercase l. This is because 11l rendered in some fonts may look like 111 instead of 11L.
LongLiteralWithLowerCaseL.description.html=In Java and Groovy, you can specify long literals with the L or l character, for instance 55L or 24l. It is best practice to always use an uppercase L and never a lowercase l. This is because 11l rendered in some fonts may look like 111 instead of 11L.

CouldBeElvis.description=Catch an if block that could be written as an elvis expression.
CouldBeElvis.description.html=Catch an if block that could be written as an elvis expression.

ClassJavadoc.description=Makes sure each class and interface definition is preceded by javadoc. Enum definitions are not checked, due to strange behavior in the Groovy AST.
ClassJavadoc.description.html=Makes sure each class and interface definition is preceded by javadoc. Enum definitions are not checked, due to strange behavior in the Groovy AST.

BlankLineBeforePackage.description=Makes sure there are no blank lines before the package declaration of a source code file.
BlankLineBeforePackage.description.html=Makes sure there are no blank lines before the package declaration of a source code file.

BracesForTryCatchFinally.description=Checks the location of the opening brace ({) for try statements. By default, requires them on the line, but the sameLine property can be set to false to override this.
BracesForTryCatchFinally.description.html=Checks the location of the opening brace ({) for try statements. By default, requires them on the line, but the sameLine property can be set to false to override this.

BracesForMethod.description=Checks the location of the opening brace ({) for constructors and methods. By default, requires them on the same line, but the sameLine property can be set to false to override this.
BracesForMethod.description.html=Checks the location of the opening brace ({) for constructors and methods. By default, requires them on the same line, but the sameLine property can be set to false to override this.

BracesForIfElse.description=Checks the location of the opening brace ({) for if statements. By default, requires them on the same line, but the sameLine property can be set to false to override this.
BracesForIfElse.description.html=Checks the location of the opening brace ({) for if statements. By default, requires them on the same line, but the sameLine property can be set to false to override this.

BracesForForLoop.description=Checks the location of the opening brace ({) for for loops. By default, requires them on the same line, but the sameLine property can be set to false to override this.
BracesForForLoop.description.html=Checks the location of the opening brace ({) for for loops. By default, requires them on the same line, but the sameLine property can be set to false to override this.

FileEndsWithoutNewline.description=Makes sure the source code file ends with a newline character.
FileEndsWithoutNewline.description.html=Makes sure the source code file ends with a newline character.

LineLength.description=Checks the maximum length for each line of source code. It checks for number of characters, so lines that include tabs may appear longer than the allowed number when viewing the file. The maximum line length can be configured by setting the length property, which defaults to 120.
LineLength.description.html=Checks the maximum length for each line of source code. It checks for number of characters, so lines that include tabs may appear longer than the allowed number when viewing the file. The maximum line length can be configured by setting the length property, which defaults to 120.

MissingBlankLineAfterPackage.description=Makes sure there is a blank line after the package statement of a source code file.
MissingBlankLineAfterPackage.description.html=Makes sure there is a blank line after the package statement of a source code file.

ConsecutiveBlankLines.description=Makes sure there are no consecutive lines that are either blank or whitespace only.
ConsecutiveBlankLines.description.html=Makes sure there are no consecutive lines that are either blank or whitespace only.

MissingBlankLineAfterImports.description=Makes sure there is a blank line after the imports of a source code file.
MissingBlankLineAfterImports.description.html=Makes sure there is a blank line after the imports of a source code file.

GrailsDomainHasToString.description=Checks that Grails domain classes redefine toString()
GrailsDomainHasToString.description.html=Checks that Grails domain classes redefine toString()

GrailsDomainHasEquals.description=Checks that Grails domain classes redefine equals().
GrailsDomainHasEquals.description.html=Checks that Grails domain classes redefine equals().

GrailsDomainWithServiceReference.description=Checks that Grails domain classes do not have service classes injected.
GrailsDomainWithServiceReference.description.html=Checks that Grails domain classes do not have service classes injected.

GrailsDomainReservedSqlKeywordName.description=Forbids usage of SQL reserved keywords as class or field names in Grails domain classes. Naming a domain class (or its field) with such a keyword causes SQL schema creation errors and/or redundant table/column name mappings.
GrailsDomainReservedSqlKeywordName.description.html=Forbids usage of SQL reserved keywords as class or field names in Grails domain classes. Naming a domain class (or its field) with such a keyword causes SQL schema creation errors and/or redundant table/column name mappings.

BracesForClass.description=Checks the location of the opening brace ({) for classes. By default, requires them on the same line, but the sameLine property can be set to false to override this.
BracesForClass.description.html=Checks the location of the opening brace ({) for classes. By default, requires them on the same line, but the sameLine property can be set to false to override this.

RandomDoubleCoercedToZero.description=The Math.random() method returns a double result greater than or equal to 0.0 and less than 1.0. If you coerce this result into an Integer or int, then it is coerced to zero. Casting the result to int, or assigning it to an int field is probably a bug.
RandomDoubleCoercedToZero.description.html=The Math.random() method returns a double result greater than or equal to 0.0 and less than 1.0. If you coerce this result into an Integer or int, then it is coerced to zero. Casting the result to int, or assigning it to an int field is probably a bug.

HardCodedWindowsFileSeparator.description=This rule finds usages of a Windows file separator within the constructor call of a File object. It is better to use the Unix file separator or use the File.separator constant.
HardCodedWindowsFileSeparator.description.html=This rule finds usages of a Windows file separator within the constructor call of a File object. It is better to use the Unix file separator or use the File.separator constant.

HardCodedWindowsRootDirectory.description=This rule find cases where a File object is constructed with a windows-based path. This is not portable, and using the File.listRoots() method is a better alternative.
HardCodedWindowsRootDirectory.description.html=This rule find cases where a <em>File</em> object is constructed with a windows-based path. This is not portable, and using the <em>File.listRoots()</em> method is a better alternative.

UnnecessarySubstring.description=This rule finds usages of String.substring(int) and String.substring(int, int) that can be replaced by use of the subscript operator. For instance, var.substring(5) can be replaced with var[5..-1].
UnnecessarySubstring.description.html=This rule finds usages of String.substring(int) and String.substring(int, int) that can be replaced by use of the subscript operator. For instance, var.substring(5) can be replaced with var[5..-1].

UnnecessaryInstanceOfCheck.description=This rule finds instanceof checks that cannot possibly evaluate to true. For instance, checking that (!variable instanceof String) will never be true because the result of a not expression is always a boolean.
UnnecessaryInstanceOfCheck.description.html=This rule finds instanceof checks that cannot possibly evaluate to true. For instance, checking that (!variable instanceof String) will never be true because the result of a not expression is always a boolean.

BitwiseOperatorInConditional.description=Checks for bitwise operations in conditionals, if you need to do a bitwise operation then it is best practive to extract a temp variable.
BitwiseOperatorInConditional.description.html=Checks for bitwise operations in conditionals, if you need to do a bitwise operation then it is best practive to extract a temp variable.

AssignCollectionSort.description=The Collections.sort() method mutates the list and returns the list as a value. If you are assigning the result of sort() to a variable, then you probably don't realize that you're also modifying the original list as well. This is frequently the cause of subtle bugs.
AssignCollectionSort.description.html=The Collections.sort() method mutates the list and returns the list as a value. If you are assigning the result of sort() to a variable, then you probably don't realize that you're also modifying the original list as well. This is frequently the cause of subtle bugs.

AssignCollectionUnique.description=The Collections.unique() method mutates the list and returns the list as a value. If you are assigning the result of unique() to a variable, then you probably don't realize that you're also modifying the original list as well. This is frequently the cause of subtle bugs.
AssignCollectionUnique.description.html=The Collections.unique() method mutates the list and returns the list as a value. If you are assigning the result of unique() to a variable, then you probably don't realize that you're also modifying the original list as well. This is frequently the cause of subtle bugs.

UnnecessaryDotClass.description=To make a reference to a class, it is unnecessary to specify the '.class' identifier. For instance String.class can be shortened to String.
UnnecessaryDotClass.description.html=To make a reference to a class, it is unnecessary to specify the '.class' identifier. For instance String.class can be shortened to String.

ClassForName.description=Using Class.forName(...) is a common way to add dynamic behavior to a system. However, using this method can cause resource leaks because the classes can be pinned in memory for long periods of time.
ClassForName.description.html=Using Class.forName(...) is a common way to add dynamic behavior to a system. However, using this method can cause resource leaks because the classes can be pinned in memory for long periods of time.

IllegalClassReference.description=Checks for reference to any of the classes configured in classNames.
IllegalClassReference.description.html=Checks for reference to any of the classes configured in <em>classNames</em>.

IllegalPackageReference.description=Checks for reference to any of the packages configured in packageNames.
IllegalPackageReference.description.html=Checks for reference to any of the packages configured in <em>packageNames</em>.

StaticSimpleDateFormatField.description=SimpleDateFormat objects should not be used as static fields. SimpleDateFormat are inherently unsafe for multi-threaded use. Sharing a single instance across thread boundaries without proper synchronization will result in erratic behavior of the application.
StaticSimpleDateFormatField.description.html=<em>SimpleDateFormat</em> objects should not be used as <em>static</em> fields. <em>SimpleDateFormat</em> are inherently unsafe for multi-threaded use. Sharing a single instance across thread boundaries without proper synchronization will result in erratic behavior of the application.

AbstractClassWithPublicConstructor.description=Checks for abstract classes that define a public constructor, which is useless and confusing.
AbstractClassWithPublicConstructor.description.html=Checks for <em>abstract</em> classes that define a public constructor, which is useless and confusing.

UnnecessaryPackageReference.description=Checks for explicit package reference for classes that Groovy imports by default, such as java.lang.String, java.util.Map and groovy.lang.Closure.
UnnecessaryPackageReference.description.html=Checks for explicit package reference for classes that Groovy imports by default, such as <em>java.lang.String</em>, <em>java.util.Map</em> and <em>groovy.lang.Closure</em>.

StaticConnection.description=Creates violations when a java.sql.Connection object is used as a static field. Database connections stored in static fields will be shared between threads, which is unsafe and can lead to race conditions.
StaticConnection.description.html=Creates violations when a java.sql.Connection object is used as a static field. Database connections stored in static fields will be shared between threads, which is unsafe and can lead to race conditions.

SerialPersistentFields.description=To use a Serializable object's serialPersistentFields correctly, it must be declared private, static, and final.
SerialPersistentFields.description.html=To use a Serializable object's serialPersistentFields correctly, it must be declared private, static, and final.

NonFinalPublicField.description=Finds code that violates secure coding principles for mobile code by declaring a member variable public but not final.
NonFinalPublicField.description.html=Finds code that violates secure coding principles for mobile code by declaring a member variable public but not final.

UnsafeImplementationAsMap.description=Reports incomplete interface implementations created by map-to-interface coercions. Example: [hasNext: { ... }] as Iterator (Not all Iterator methods are implemented. An UnsupportedOperationException will be thrown upon call to e.g. next().) By default, this rule does not apply to test files.
UnsafeImplementationAsMap.description.html=Reports incomplete interface implementations created by map-to-interface coercions. Example: [hasNext: { ... }] as Iterator (Not all Iterator methods are implemented. An UnsupportedOperationException will be thrown upon call to e.g. next().) By default, this rule does not apply to test files.

PublicInstanceField.description=Using public fields is considered to be a bad design. Use properties instead.
PublicInstanceField.description.html=Using public fields is considered to be a bad design. Use properties instead.

PublicFinalizeMethod.description=Creates a violation when the program violates secure coding principles by declaring a finalize() method public.
PublicFinalizeMethod.description.html=Creates a violation when the program violates secure coding principles by declaring a finalize() method public.

UnsafeArrayDeclaration.description=Triggers a violation when an array is declared public, final, and static. Secure coding principles state that, in most cases, an array declared public, final and static is a bug because arrays are mutable objects.
UnsafeArrayDeclaration.description.html=Triggers a violation when an array is declared public, final, and static. Secure coding principles state that, in most cases, an array declared public, final and static is a bug because arrays are mutable objects.

JavaIoPackageAccess.description=This rule reports violations of the Enterprise JavaBeans specification by using the java.io package to access files or the file system.
JavaIoPackageAccess.description.html=This rule reports violations of the Enterprise JavaBeans specification by using the java.io package to access files or the file system.

ObjectFinalize.description=The finalize() method should only be called by the JVM after the object has been garbage collected.
ObjectFinalize.description.html=The finalize() method should only be called by the JVM after the object has been garbage collected.

SystemExit.description=Web applications should never call System.exit(). A call to System.exit() is probably part of leftover debug code or code imported from a non-J2EE application.
SystemExit.description.html=Web applications should never call System.exit(). A call to System.exit() is probably part of leftover debug code or code imported from a non-J2EE application.

FileCreateTempFile.description=The File.createTempFile() method is insecure, and has been deprecated by the ESAPI secure coding library. It has been replaced by the ESAPI Randomizer.getRandomFilename(String) method.
FileCreateTempFile.description.html=The File.createTempFile() method is insecure, and has been deprecated by the ESAPI secure coding library. It has been replaced by the ESAPI Randomizer.getRandomFilename(String) method.

ComparisonOfTwoConstants.description=Checks for expressions where a comparison operator or equals() or compareTo() is used to compare two constants to each other or two literals that contain only constant values, e.g.: 23 == 67, Boolean.FALSE != false, 0.17 <= 0.99, "abc" > "ddd", [a:1] <=> [a:2], [1,2].equals([3,4]) or [a:false, b:true].compareTo(['a':34.5, b:Boolean.TRUE], where x is a variable.
ComparisonOfTwoConstants.description.html=Checks for expressions where a comparison operator or <em>equals()</em> or <em>compareTo()</em> is used to compare two constants to each other or two literals that contain only constant values., e.g.: <em>23 == 67, Boolean.FALSE != false, 0.17 &lt;= 0.99, "abc" &gt; "ddd", [a:1] &lt;=&gt; [a:2], [1,2].equals([3,4]) or [a:false, b:true].compareTo(['a':34.5, b:Boolean.TRUE]</em>.

ComparisonWithSelf.description=Checks for expressions where a comparison operator or equals() or compareTo() is used to compare a variable to itself, e.g.: x == x, x != x, x <=> x, x < x, x >= x, x.equals(x) or x.compareTo(x), where x is a variable.
ComparisonWithSelf.description.html=Checks for expressions where a comparison operator or <em>equals()</em> or <em>compareTo()</em> is used to compare a variable to itself, e.g.: <em>x == x, x != x, x &lt;=&gt; x, x &lt; x, x =&gt;= x, x.equals(x) or x.compareTo(x)</em>, where <em>x</em> is a variable.

DirectConnectionManagement.description=The J2EE standard requires that applications use the container's resource management facilities to obtain connections to resources. Every major web application container provides pooled database connection management as part of its resource management framework. Duplicating this functionality in an application is difficult and error prone, which is part of the reason it is forbidden under the J2EE standard.
DirectConnectionManagement.description.html=The J2EE standard requires that applications use the container's resource management facilities to obtain connections to resources. Every major web application container provides pooled database connection management as part of its resource management framework. Duplicating this functionality in an application is difficult and error prone, which is part of the reason it is forbidden under the J2EE standard.

JdbcConnectionReference.description=Check for direct use of java.sql.Connection, which is discouraged and almost never necessary in application code.
JdbcConnectionReference.description.html=Check for direct use of <em>java.sql.Connection</em>, which is discouraged and almost never necessary in application code.

JdbcResultSetReference.description=Check for direct use of java.sql.ResultSet, which is not necessary if using the Groovy Sql facility or an ORM framework such as Hibernate.
JdbcResultSetReference.description.html=Check for direct use of <em>java.sql.ResultSet</em>, which is not necessary if using the Groovy <em>Sql</em> facility or an ORM framework such as Hibernate.

JdbcStatementReference.description=Check for direct use of java.sql.Statement, java.sql.PreparedStatement, or java.sql.CallableStatement, which is not necessary if using the Groovy Sql facility or an ORM framework such as Hibernate.
JdbcStatementReference.description.html=Check for direct use of <em>java.sql.Statement</em>, <em>java.sql.PreparedStatement</em>, or <em>java.sql.CallableStatement</em>, which is not necessary if using the Groovy <em>Sql</em> facility or an ORM framework such as Hibernate.

InsecureRandom.description=Reports usages of java.util.Random, which can produce very predictable results. If two instances of Random are created with the same seed and sequence of method calls, they will generate the exact same results. Use java.security.SecureRandom instead, which provides a cryptographically strong random number generator. SecureRandom uses PRNG, which means they are using a deterministic algorithm to produce a pseudo-random number from a true random seed. SecureRandom produces non-deterministic output.
InsecureRandom.description.html=Reports usages of java.util.Random, which can produce very predictable results. If two instances of Random are created with the same seed and sequence of method calls, they will generate the exact same results. Use java.security.SecureRandom instead, which provides a cryptographically strong random number generator. SecureRandom uses PRNG, which means they are using a deterministic algorithm to produce a pseudo-random number from a true random seed. SecureRandom produces non-deterministic output.

UnnecessaryFinalOnPrivateMethod.description=A private method is marked final. Private methods cannot be overridden, so marking it final is unnecessary.
UnnecessaryFinalOnPrivateMethod.description.html=A private method is marked final. Private methods cannot be overridden, so marking it final is unnecessary.

ImportFromSunPackages.description=Avoid importing anything from the 'sun.*' packages. These packages are not portable and are likely to change.
ImportFromSunPackages.description.html=Avoid importing anything from the 'sun.*' packages. These packages are not portable and are likely to change.

DuplicateSetValue.description=A Set literal is created with duplicate constant value. A set cannot contain two elements with the same value.
DuplicateSetValue.description.html=A Set literal is created with duplicate constant value. A set cannot contain two elements with the same value.

NonFinalSubclassOfSensitiveInterface.description=The permissions classes such as java.security.Permission and java.security.BasicPermission are designed to be extended. Classes that derive from these permissions classes, however, must prohibit extension. This prohibition ensures that malicious subclasses cannot change the properties of the derived class. Classes that implement sensitive interfaces such as java.security.PrivilegedAction and java.security.PrivilegedActionException must also be declared final for analogous reasons.
NonFinalSubclassOfSensitiveInterface.description.html=The permissions classes such as java.security.Permission and java.security.BasicPermission are designed to be extended. Classes that derive from these permissions classes, however, must prohibit extension. This prohibition ensures that malicious subclasses cannot change the properties of the derived class. Classes that implement sensitive interfaces such as java.security.PrivilegedAction and java.security.PrivilegedActionException must also be declared final for analogous reasons.

DuplicateMapKey.description=A map literal is created with duplicated key. The map entry will be overwritten.
DuplicateMapKey.description.html=A map literal is created with duplicated key. The map entry will be overwritten.

EqualsOverloaded.description=The class has an equals method, but the parameter of the method is not of type Object. It is not overriding equals but instead overloading it.
EqualsOverloaded.description.html=The class has an equals method, but the parameter of the method is not of type Object. It is not overriding equals but instead overloading it.

UnnecessaryGString.description=String objects should be created with single quotes, and GString objects created with double quotes. Creating normal String objects with double quotes is confusing to readers.
UnnecessaryGString.description.html=String objects should be created with single quotes, and GString objects created with double quotes. Creating normal String objects with double quotes is confusing to readers.

UnnecessarySemicolon.description=Semicolons as line terminators are not required in Groovy: remove them. Do not use a semicolon as a replacement for empty braces on for and while loops; this is a confusing practice.
UnnecessarySemicolon.description.html=Semicolons as line terminators are not required in Groovy: remove them. Do not use a semicolon as a replacement for empty braces on for and while loops; this is a confusing practice.

UnnecessaryDefInMethodDeclaration.description=If a method has a visibility modifier or a type declaration, then the def keyword is unneeded. For instance 'def private method() {}' is redundant and can be simplified to 'private method() {}'.
UnnecessaryDefInMethodDeclaration.description.html=If a method has a visibility modifier or a type declaration, then the def keyword is unneeded. For instance 'def private method() {}' is redundant and can be simplified to 'private method() {}'.

UnnecessaryDefInVariableDeclaration.description=If a variable has a visibility modifier or a type declaration, then the def keyword is unneeded. For instance 'def private n = 2' is redundant and can be simplified to 'private n = 2'.
UnnecessaryDefInVariableDeclaration.description.html=If a variable has a visibility modifier or a type declaration, then the def keyword is unneeded. For instance 'def private n = 2' is redundant and can be simplified to 'private n = 2'.

UnnecessaryPublicModifier.description=The 'public' modifier is not required on methods or classes.
UnnecessaryPublicModifier.description.html=The 'public' modifier is not required on methods or classes.

SpockIgnoreRestUsed.description=If Spock's @IgnoreRest appears on any method, all non-annotated test methods are not executed. This behaviour is almost always unintended. It's fine to use @IgnoreRest locally during development, but when committing code, it should be removed.
SpockIgnoreRestUsed.description.html=If Spock's @IgnoreRest appears on any method, all non-annotated test methods are not executed. This behaviour is almost always unintended. It's fine to use @IgnoreRest locally during development, but when committing code, it should be removed.

CoupledTestCase.description=This rule finds test cases that are coupled to other test cases, either by invoking static methods on another test case or by creating instances of another test case. If you require shared logic in test cases then extract that logic to a new class where it can properly be reused.
CoupledTestCase.description.html=This rule finds test cases that are coupled to other test cases, either by invoking static methods on another test case or by creating instances of another test case. If you require shared logic in test cases then extract that logic to a new class where it can properly be reused.

ChainedTest.description=A test method that invokes another test method is a chained test; the methods are dependent on one another. Tests should be isolated, and not be dependent on one another.
ChainedTest.description.html=A test method that invokes another test method is a chained test; the methods are dependent on one another. Tests should be isolated, and not be dependent on one another.

IntegerGetInteger.description=This rule catches usages of java.lang.Integer.getInteger(String, ...) which reads an Integer from the System properties. It is often mistakenly used to attempt to read user input or parse a String into an Integer. It is a poor piece of API to use; replace it with System.properties['prop'].
IntegerGetInteger.description.html=This rule catches usages of java.lang.Integer.getInteger(String, ...) which reads an Integer from the System properties. It is often mistakenly used to attempt to read user input or parse a String into an Integer. It is a poor piece of API to use; replace it with System.properties['prop'].

BooleanGetBoolean.description=This rule catches usages of java.lang.Boolean.getBoolean(String) which reads a boolean from the System properties. It is often mistakenly used to attempt to read user input or parse a String into a boolean. It is a poor piece of API to use; replace it with System.properties['prop'].
BooleanGetBoolean.description.html=This rule catches usages of java.lang.Boolean.getBoolean(String) which reads a boolean from the System properties. It is often mistakenly used to attempt to read user input or parse a String into a boolean. It is a poor piece of API to use; replace it with System.properties['prop'].

GroovyLangImmutable.description=The groovy.lang.Immutable annotation has been deprecated and replaced by groovy.transform.Immutable. Do not use the Immutable in groovy.lang.
GroovyLangImmutable.description.html=The groovy.lang.Immutable annotation has been deprecated and replaced by groovy.transform.Immutable. Do not use the Immutable in groovy.lang.

UnnecessaryFail.description=In a unit test, catching an exception and immediately calling Assert.fail() is pointless and hides the stack trace. It is better to rethrow the exception or not catch the exception at all.
UnnecessaryFail.description.html=In a unit test, catching an exception and immediately calling Assert.fail() is pointless and hides the stack trace. It is better to rethrow the exception or not catch the exception at all.

DoubleCheckedLocking.description=This rule detects double checked locking, where a 'lock hint' is tested for null before initializing an object within a synchronized block. Double checked locking does not guarantee correctness and is an anti-pattern.
DoubleCheckedLocking.description.html=This rule detects double checked locking, where a 'lock hint' is tested for null before initializing an object within a synchronized block. Double checked locking does not guarantee correctness and is an anti-pattern.

BusyWait.description=Busy waiting (forcing a Thread.sleep() while waiting on a condition) should be avoided. Prefer using the gate and barrier objects in the java.util.concurrent package.
BusyWait.description.html=Busy waiting (forcing a Thread.sleep() while waiting on a condition) should be avoided. Prefer using the gate and barrier objects in the java.util.concurrent package.

AssignmentInConditional.description=An assignment operator (=) was used in a conditional test. This is usually a typo, and the comparison operator (==) was intended.
AssignmentInConditional.description.html=An assignment operator (=) was used in a conditional test. This is usually a typo, and the comparison operator (==) was intended.

SynchronizedOnReentrantLock.description=Synchronizing on a ReentrantLock field is almost never the intended usage. A ReentrantLock should be obtained using the lock() method and released in a finally block using the unlock() method.
SynchronizedOnReentrantLock.description.html=Synchronizing on a ReentrantLock field is almost never the intended usage. A ReentrantLock should be obtained using the lock() method and released in a finally block using the unlock() method.

StaticMatcherField.description=Matcher objects should not be used as static fields. Matcher instances are inherently unsafe for multithreaded use. Sharing a single instance across thread boundaries without proper synchronization will result in erratic behavior of the application.
StaticMatcherField.description.html=<em>Matcher</em> objects should not be used as static fields. <em>Matcher</em> instances are inherently unsafe for multithreaded use. Sharing a single instance across thread boundaries without proper synchronization will result in erratic behavior of the application.

VolatileArrayField.description=Volatile array fields are unsafe because the contents of the array are not treated as volatile. Changing the entire array reference is visible to other threads, but changing an array element is not.
VolatileArrayField.description.html=Volatile array fields are unsafe because the contents of the array are not treated as volatile. Changing the entire array reference is visible to other threads, but changing an array element is not.

SynchronizedOnBoxedPrimitive.description=The code synchronizes on a boxed primitive constant, such as an Integer. Since Integer objects can be cached and shared, this code could be synchronizing on the same object as other, unrelated code, leading to unresponsiveness and possible deadlock
SynchronizedOnBoxedPrimitive.description.html=The code synchronizes on a boxed primitive constant, such as an Integer. Since Integer objects can be cached and shared, this code could be synchronizing on the same object as other, unrelated code, leading to unresponsiveness and possible deadlock

InconsistentPropertyLocking.description=Class contains similarly-named get and set methods where one method of the pair is marked either @WithReadLock or @WithWriteLock and the other is not locked at all.
InconsistentPropertyLocking.description.html=Class contains similarly-named get and set methods where one method of the pair is marked either @WithReadLock or @WithWriteLock and the other is not locked at all.

InconsistentPropertySynchronization.description=Class contains similarly-named get and set methods where the set method is synchronized and the get method is not, or the get method is synchronized and the set method is not.
InconsistentPropertySynchronization.description.html=Class contains similarly-named get and set methods where the set method is synchronized and the get method is not, or the get method is synchronized and the set method is not.

UnnecessaryTransientModifier.description=The field is marked as transient, but the class isn't Serializable, so marking it as transient has no effect.
UnnecessaryTransientModifier.description.html=The field is marked as transient, but the class isn't Serializable, so marking it as transient has no effect.

UnnecessarySelfAssignment.description=Method contains a pointless self-assignment to a variable or property.
UnnecessarySelfAssignment.description.html=Method contains a pointless self-assignment to a variable or property.

SynchronizedReadObjectMethod.description=Catches Serializable classes that define a synchronized readObject method. By definition, an object created by deserialization is only reachable by one thread, and thus there is no need for readObject() to be synchronized. If the readObject() method itself is causing the object to become visible to another thread, that is an example of very dubious coding style.
SynchronizedReadObjectMethod.description.html=Catches Serializable classes that define a synchronized readObject method. By definition, an object created by deserialization is only reachable by one thread, and thus there is no need for readObject() to be synchronized. If the readObject() method itself is causing the object to become visible to another thread, that is an example of very dubious coding style.

SynchronizedOnString.description=Synchronization on a String field can lead to deadlock because Strings are interned by the JVM and can be shared.
SynchronizedOnString.description.html=Synchronization on a String field can lead to deadlock because Strings are interned by the JVM and can be shared.

UnnecessaryCallToSubstring.description=Calling String.substring(0) always returns the original string. This code is meaningless.
UnnecessaryCallToSubstring.description.html=Calling String.substring(0) always returns the original string. This code is meaningless.

BrokenOddnessCheck.description=The code uses x % 2 == 1 to check to see if a value is odd, but this won't work for negative numbers (e.g., (-5) % 2 == -1). If this code is intending to check for oddness, consider using x & 1 == 1, or x % 2 != 0.
BrokenOddnessCheck.description.html=The code uses x % 2 == 1 to check to see if a value is odd, but this won't work for negative numbers (e.g., (-5) % 2 == -1). If this code is intending to check for oddness, consider using x &amp; 1 == 1, or x % 2 != 0.

StaticDateFormatField.description=DateFormat objects should not be used as static fields. DateFormat are inherently unsafe for multithreaded use. Sharing a single instance across thread boundaries without proper synchronization will result in erratic behavior of the application.
StaticDateFormatField.description.html=<em>DateFormat</em> objects should not be used as static fields. <em>DateFormat</em> are inherently unsafe for multithreaded use. Sharing a single instance across thread boundaries without proper synchronization will result in erratic behavior of the application.

StaticCalendarField.description=Calendar objects should not be used as static fields. Calendars are inherently unsafe for multihtreaded use. Sharing a single instance across thread boundaries without proper synchronization will result in erratic behavior of the application.
StaticCalendarField.description.html=<em>Calendar</em> objects should not be used as static fields. <em>Calendars</em> are inherently unsafe for multihtreaded use. Sharing a single instance across thread boundaries without proper synchronization will result in erratic behavior of the application.

UnnecessaryModOne.description=Any expression mod 1 (exp % 1) is guaranteed to always return zero. This code is probably an error, and should be either (exp & 1) or (exp % 2).
UnnecessaryModOne.description.html=Any expression mod 1 (exp % 1) is guaranteed to always return zero. This code is probably an error, and should be either (exp &amp; 1) or (exp % 2).

AddEmptyString.description=Finds empty string literals which are being added. This is an inefficient way to convert any type to a String.
AddEmptyString.description.html=Finds empty string literals which are being added. This is an inefficient way to convert any type to a String.

ConsecutiveStringConcatenation.description=Catches concatenation of two string literals on the same line. These can safely by joined.
ConsecutiveStringConcatenation.description.html=Catches concatenation of two string literals on the same line. These can safely by joined.

ConsecutiveLiteralAppends.description=Violations occur when method calls to append(Object) are chained together with literals as parameters. The chained calls can be joined into one invocation.
ConsecutiveLiteralAppends.description.html=Violations occur when method calls to append(Object) are chained together with literals as parameters. The chained calls can be joined into one invocation.

EmptyMethod.description=A method was found without an implementation. If the method is overriding or implementing a parent method, then mark it with the @Override annotation.
EmptyMethod.description.html=A method was found without an implementation. If the method is overriding or implementing a parent method, then mark it with the @Override annotation.

EmptyStaticInitializer.description=An empty static initializer was found. It is safe to remove it.
EmptyStaticInitializer.description.html=An empty static initializer was found. It is safe to remove it.

EmptyInstanceInitializer.description=An empty class instance initializer was found. It is safe to remove it.
EmptyInstanceInitializer.description.html=An empty class instance initializer was found. It is safe to remove it.

SerializableClassMustDefineSerialVersionUID.description=Classes that implement Serializable should define a serialVersionUID. If you don't define serialVersionUID, the system will make one by hashing most of your class's features. Then if you change anything, the UID will change and Java won't let you reload old data.
SerializableClassMustDefineSerialVersionUID.description.html=Classes that implement Serializable should define a serialVersionUID. If you don't define serialVersionUID, the system will make one by hashing most of your class's features. Then if you change anything, the UID will change and Java won't let you reload old data. 

ThisReferenceEscapesConstructor.description=Reports constructors passing the 'this' reference to other methods. This equals exposing a half-baked objects and can lead to race conditions during initialization. For reference, see 'Java Concurrency Gotchas' by Alex Miller (http://www.slideshare.net/alexmiller/java-concurrency-gotchas-3666977/38) and 'Java theory and practice: Safe construction techniques' by Brian Goetz (http://www.ibm.com/developerworks/java/library/j-jtp0618/index.html).
ThisReferenceEscapesConstructor.description.html=Reports constructors passing the 'this' reference to other methods. This equals exposing a half-baked objects and can lead to race conditions during initialization. For reference, see <a href='http://www.slideshare.net/alexmiller/java-concurrency-gotchas-3666977/38'>Java Concurrency Gotchas</a> by Alex Miller and <a href='http://www.ibm.com/developerworks/java/library/j-jtp0618/index.html'>Java theory and practice: Safe construction techniques</a> by Brian Goetz.

ThreadGroup.description=Avoid using ThreadGroup; although it is intended to be used in a threaded environment it contains methods that are not thread safe.
ThreadGroup.description.html=Avoid using ThreadGroup; although it is intended to be used in a threaded environment it contains methods that are not thread safe.

BigDecimalInstantiation.description=Checks for calls to the BigDecimal constructors that take a double parameter, which may result in an unexpected BigDecimal value.
BigDecimalInstantiation.description.html=Checks for calls to the <em>BigDecimal</em> constructors that take a <em>double</em> parameter, which may result in an unexpected <em>BigDecimal</em> value.

BooleanMethodReturnsNull.description=Method with Boolean return type returns explicit null. A method that returns either Boolean.TRUE, Boolean.FALSE or null is an accident waiting to happen. This method can be invoked as though it returned a value of type boolean, and the compiler will insert automatic unboxing of the Boolean value. If a null value is returned, this will result in a NullPointerException.
BooleanMethodReturnsNull.description.html=Method with Boolean return type returns explicit null. A method that returns either Boolean.TRUE, Boolean.FALSE or null is an accident waiting to happen. This method can be invoked as though it returned a value of type boolean, and the compiler will insert automatic unboxing of the Boolean value. If a null value is returned, this will result in a NullPointerException.

CloneableWithoutClone.description=A class that implements java.lang.Cloneable should define a clone() method.
CloneableWithoutClone.description.html=A class that implements <em>java.lang.Cloneable</em> should define a <em>clone()</em> method.

CloneWithoutCloneable.description=The method clone() should only be declared if the class implements the Cloneable interface.
CloneWithoutCloneable.description.html=The method clone() should only be declared if the class implements the Cloneable interface.

CollectAllIsDeprecated.description=collectAll{} is deprecated since Groovy 1.8.1. Use collectNested instead{}.
CollectAllIsDeprecated.description.html=collectAll{} is deprecated since Groovy 1.8.1. Use collectNested instead{}.

CompareToWithoutComparable.description=If you implement a compareTo method then you should also implement the Comparable interface. If you don't then you could possibly get an exception if the Groovy == operator is invoked on your object. This is an issue fixed in Groovy 1.8 but present in previous versions.
CompareToWithoutComparable.description.html=If you implement a compareTo method then you should also implement the Comparable interface. If you don't then you could possibly get an exception if the Groovy == operator is invoked on your object. This is an issue fixed in Groovy 1.8 but present in previous versions.

ConfusingTernary.description=In a ternary expression avoid negation in the test. For example, rephrase: "(x != y) ? diff : same" as: "(x == y) ? same : diff". Consistent use of this rule makes the code easier to read. Also, this resolves trivial ordering problems, such as "does the error case go first?" or "does the common case go first?".
ConfusingTernary.description.html=In a ternary expression avoid negation in the test. For example, rephrase: "(x != y) ? diff : same" as: "(x == y) ? same : diff". Consistent use of this rule makes the code easier to read. Also, this resolves trivial ordering problems, such as "does the error case go first?" or "does the common case go first?".

ConstantIfExpression.description=Checks for if statements with a constant value for the if expression, such as true, false, null, or a literal constant value.
ConstantIfExpression.description.html=Checks for <em>if</em> statements with a constant value for the if expression, such as <em>true</em>, <em>false</em>, <em>null</em>, or a literal constant value.

ConstantTernaryExpression.description=Checks for ternary expressions with a constant value for the boolean expression, such as true, false, null, or a literal constant value.
ConstantTernaryExpression.description.html=Checks for ternary expressions with a constant value for the boolean expression, such as <em>true</em>, <em>false</em>, <em>null</em>, or a literal constant value.

DeadCode.description=Dead code appears after a return statement or an exception is thrown. If code appears after one of these statements then it will never be executed and can be safely deleted.
DeadCode.description.html=Dead code appears after a return statement or an exception is thrown. If code appears after one of these statements then it will never be executed and can be safely deleted.

DoubleNegative.description=There is no point in using a double negative, it is always positive. For instance !!x can always be simplified to x. And !(!x) can as well.
DoubleNegative.description.html=There is no point in using a double negative, it is always positive. For instance <em>!!x</em> can always be simplified to x. And <em>!(!x)</em> can as well.

NestedForLoop.description=Reports classes with nested for loops.
NestedForLoop.description.html=Reports classes with nested for loops.

DuplicateCaseStatement.description=Check for duplicate case statements in a switch block, such as two equal integers or strings.
DuplicateCaseStatement.description.html=Check for duplicate <em>case</em> statements in a <em>switch</em> block, such as two equal integers or strings.

EmptyCatchBlock.description=In most cases, exceptions should not be caught and ignored (swallowed).
EmptyCatchBlock.description.html=In most cases, exceptions should not be caught and ignored (swallowed).

EmptyClass.description=Reports classes without methods, fields or properties. Why would you need a class like this?
EmptyClass.description.html=Reports classes without methods, fields or properties. Why would you need a class like this?

EmptyTryBlock.description=Empty try blocks are confusing and serve no purpose.
EmptyTryBlock.description.html=Empty <em>try</em> blocks are confusing and serve no purpose.

EmptyFinallyBlock.description=Empty finally blocks are confusing and serve no purpose.
EmptyFinallyBlock.description.html=Empty <em>finally</em> blocks are confusing and serve no purpose.

EmptyIfStatement.description=Empty if statements are confusing and serve no purpose.
EmptyIfStatement.description.html=Empty <em>if</em> statements are confusing and serve no purpose.

EmptyElseBlock.description=Empty else blocks are confusing and serve no purpose.
EmptyElseBlock.description.html=Empty <em>else</em> blocks are confusing and serve no purpose.

EmptyForStatement.description=Empty for statements are confusing and serve no purpose.
EmptyForStatement.description.html=Empty <em>for</em> statements are confusing and serve no purpose.

EmptySwitchStatement.description=Empty switch statements are confusing and serve no purpose.
EmptySwitchStatement.description.html=Empty <em>switch</em> statements are confusing and serve no purpose.

EmptyWhileStatement.description=Empty while statements are confusing and serve no purpose.
EmptyWhileStatement.description.html=Empty <em>while</em> statements are confusing and serve no purpose.

EmptySynchronizedStatement.description=Empty synchronized statements are confusing and serve no purpose.
EmptySynchronizedStatement.description.html=Empty <em>synchronized</em> statements are confusing and serve no purpose.

EqualsAndHashCode.description=If either the equals(Object) or the hashCode() methods are overridden within a class, then both must be overridden.
EqualsAndHashCode.description.html=If either the <em>boolean equals(Object)</em> or the <em>int hashCode()</em> methods are overridden within a class, then both must be overridden.

ExplicitArrayListInstantiation.description=This rule checks for the explicit instantiation of a ArrayList using the no-arg constructor. In Groovy, it is best to write "new ArrayList()" as "[]", which creates the same object.
ExplicitArrayListInstantiation.description.html=This rule checks for the explicit instantiation of an <em>ArrayList</em> using the no-arg constructor. In Groovy, it is best to write <em>new ArrayList()</em> as <em>[]</em>, which creates the same object.

ExplicitCallToModMethod.description=This rule detects when the mod(Object) method is called directly in code instead of using the % operator. A groovier way to express this: a.mod(b) is this: a % b
ExplicitCallToModMethod.description.html=This rule detects when the <em>mod(Object)</em> method is called directly in code instead of using the % operator. A groovier way to express this: <em>a.mod(b)</em> is this: <em>a % b</em>

ExplicitCallToPowerMethod.description=This rule detects when the power(Object) method is called directly in code instead of using the ** operator. A groovier way to express this: a.power(b) is this: a ** b
ExplicitCallToPowerMethod.description.html=This rule detects when the <em>power(Object)</em> method is called directly in code instead of using the ** operator. A groovier way to express this: <em>a.power(b)</em> is this: <em>a ** b</em>

ExplicitCallToDivMethod.description=This rule detects when the div(Object) method is called directly in code instead of using the / operator. A groovier way to express this: a.div(b) is this: a / b
ExplicitCallToDivMethod.description.html=This rule detects when the <em>div(Object)</em> method is called directly in code instead of using the / operator. A groovier way to express this: <em>a.div(b)</em> is this: <em>a / b</em>

ExplicitCallToMultiplyMethod.description=This rule detects when the minus(Object) method is called directly in code instead of using the * operator. A groovier way to express this: a.multiply(b) is this: a * b
ExplicitCallToMultiplyMethod.description.html=This rule detects when the <em>minus(Object)</em> method is called directly in code instead of using the * operator. A groovier way to express this: <em>a.multiply(b)</em> is this: <em>a * b</em>

ExplicitCallToMinusMethod.description=This rule detects when the minus(Object) method is called directly in code instead of using the - operator. A groovier way to express this: a.minus(b) is this: a - b
ExplicitCallToMinusMethod.description.html=This rule detects when the <em>minus(Object)</em> method is called directly in code instead of using the - operator. A groovier way to express this: <em>a.minus(b)</em> is this: <em>a - b</em>

ExplicitCallToRightShiftMethod.description=This rule detects when the rightShift(Object) method is called directly in code instead of using the >> operator. A groovier way to express this: a.rightShift(b) is this: a >> b
ExplicitCallToRightShiftMethod.description.html=This rule detects when the <em>rightShift(Object)</em> method is called directly in code instead of using the >> operator. A groovier way to express this: <em>a.rightShift(b)</em> is this: <em>a >> b</em>

ExplicitCallToLeftShiftMethod.description=This rule detects when the leftShift(Object) method is called directly in code instead of using the << operator. A groovier way to express this: a.leftShift(b) is this: a << b
ExplicitCallToLeftShiftMethod.description.html=This rule detects when the <em>leftShift(Object)</em> method is called directly in code instead of using the &lt;&lt; operator. A groovier way to express this: <em>a.leftShift(b)</em> is this: <em>a &lt;&lt; b</em>

ExplicitCallToGetAtMethod.description=This rule detects when the getAt(Object) method is called directly in code instead of using the [] index operator. A groovier way to express this: a.getAt(b) is this: a[b]
ExplicitCallToGetAtMethod.description.html=This rule detects when the <em>getAt(Object)</em> method is called directly in code instead of using the [] index operator. A groovier way to express this: <em>a.getAt(b)</em> is this: <em>a[b]</em>

ExplicitCallToXorMethod.description=This rule detects when the xor(Object) method is called directly in code instead of using the ^ operator. A groovier way to express this: a.xor(b) is this: a ^ b
ExplicitCallToXorMethod.description.html=This rule detects when the <em>xor(Object)</em> method is called directly in code instead of using the ^ operator. A groovier way to express this: <em>a.xor(b)</em> is this: <em>a ^ b</em>

ExplicitCallToAndMethod.description=This rule detects when the and(Object) method is called directly in code instead of using the & operator. A groovier way to express this: a.and(b) is this: a & b
ExplicitCallToAndMethod.description.html=This rule detects when the <em>and(Object)</em> method is called directly in code instead of using the &amp; operator. A groovier way to express this: <em>a.and(b)</em> is this: <em>a &amp; b</em>

ExplicitCallToOrMethod.description=This rule detects when the or(Object) method is called directly in code instead of using the | operator. A groovier way to express this: a.or(b) is this: a | b
ExplicitCallToOrMethod.description.html=This rule detects when the <em>or(Object)</em> method is called directly in code instead of using the | operator. A groovier way to express this: <em>a.or(b)</em> is this: <em>a | b</em>

ExplicitCallToPlusMethod.description=This rule detects when the plus(Object) method is called directly in code instead of using the + operator. A groovier way to express this: a.plus(b) is this: a + b
ExplicitCallToPlusMethod.description.html=This rule detects when the <em>plus(Object)</em> method is called directly in code instead of using the + operator. A groovier way to express this: <em>a.plus(b)</em> is this: <em>a + b</em>

ExplicitCallToEqualsMethod.description=This rule detects when the equals(Object) method is called directly in code instead of using the == or != operator. A groovier way to express this: a.equals(b) is this: a == b and a groovier way to express : !a.equals(b) is : a != b
ExplicitCallToEqualsMethod.description.html=This rule detects when the <em>equals(Object)</em> method is called directly in code instead of using the == or != operator. A groovier way to express this: <em>a.equals(b)</em> is this: <em>a == b</em> and a groovier way to express : <em>!a.equals(b)</em> is : <em>a != b</em>

ExplicitCallToCompareToMethod.description=This rule detects when the compareTo(Object) method is called directly in code instead of using the <=>, >, >=, <, and <= operators. A groovier way to express this: a.compareTo(b) is this: a <=> b, or using the other operators.
ExplicitCallToCompareToMethod.description.html=This rule detects when the <em>compareTo(Object)</em> method is called directly in code instead of using the &lt;=&gt;, &gt;, &gt;=, &lt;, and &lt;= operators. A groovier way to express this: <em>a.compareTo(b)</em> is this: <em>a &lt;=&gt; b</em>, or using the other operators.

ExplicitGarbageCollection.description=Calls to System.gc(), Runtime.getRuntime().gc(), and System.runFinalization() are not advised. Code should have the same behavior whether the garbage collection is disabled using the option -Xdisableexplicitgc or not. Moreover, "modern" jvms do a very good job handling garbage collections. If memory usage issues unrelated to memory leaks develop within an application, it should be dealt with JVM options rather than within the code itself.
ExplicitGarbageCollection.description.html=Calls to System.gc(), Runtime.getRuntime().gc(), and System.runFinalization() are not advised. Code should have the same behavior whether the garbage collection is disabled using the option -Xdisableexplicitgc or not. Moreover, "modern" jvms do a very good job handling garbage collections. If memory usage issues unrelated to memory leaks develop within an application, it should be dealt with JVM options rather than within the code itself.

ExplicitHashMapInstantiation.description=This rule checks for the explicit instantiation of a HashMap using the no-arg constructor. In Groovy, it is best to write "new HashMap()" as "[:]", which creates the same object.
ExplicitHashMapInstantiation.description.html=This rule checks for the explicit instantiation of a <em>HashMap</em> using the no-arg constructor. In Groovy, it is best to write <em>new HashMap()</em> as <em>[:]</em>, which creates the same object.

ExplicitLinkedHashMapInstantiation.description=This rule checks for the explicit instantiation of a LinkedHashMap using the no-arg constructor. In Groovy, it is best to write "new LinkedHashMap()" as "[:]", which creates the same object.
ExplicitLinkedHashMapInstantiation.description.html=This rule checks for the explicit instantiation of a <em>LinkedHashMap</em> using the no-arg constructor. In Groovy, it is best to write <em>new LinkedHashMap()</em> as <em>[:]</em>, which creates the same object.

ExplicitHashSetInstantiation.description=This rule checks for the explicit instantiation of a HashSet using the no-arg constructor. In Groovy, it is best to write "new HashSet()" as "[] as Set", which creates the same object.
ExplicitHashSetInstantiation.description.html=This rule checks for the explicit instantiation of a <em>HashSet</em> using the no-arg constructor. In Groovy, it is best to write <em>new HashSet()</em> as <em>[] as Set</em>, which creates the same object.

ExplicitLinkedListInstantiation.description=This rule checks for the explicit instantiation of a LinkedList using the no-arg constructor. In Groovy, it is best to write "new LinkedList()" as "[] as Queue", which creates the same object.
ExplicitLinkedListInstantiation.description.html=This rule checks for the explicit instantiation of a <em>LinkedList</em> using the no-arg constructor. In Groovy, it is best to write <em>new LinkedList()</em> as <em>[] as Queue</em>, which creates the same object.

ExplicitStackInstantiation.description=This rule checks for the explicit instantiation of a Stack using the no-arg constructor. In Groovy, it is best to write "new Stack()" as "[] as Stack", which creates the same object.
ExplicitStackInstantiation.description.html=This rule checks for the explicit instantiation of a <em>Stack</em> using the no-arg constructor. In Groovy, it is best to write <em>new Stack()</em> as <em>[] as Stack</em>, which creates the same object.

ExplicitTreeSetInstantiation.description=This rule checks for the explicit instantiation of a TreeSet using the no-arg constructor. In Groovy, it is best to write "new TreeSet()" as "[] as SortedSet", which creates the same object.
ExplicitTreeSetInstantiation.description.html=This rule checks for the explicit instantiation of a <em>TreeSet</em> using the no-arg constructor. In Groovy, it is best to write <em>new TreeSet()</em> as <em>[] as SortedSet</em>, which creates the same object.

ForLoopShouldBeWhileLoop.description=A for loop without an init and update statement can be simplified to a while loop.
ForLoopShouldBeWhileLoop.description.html=A for loop without an init and update statement can be simplified to a while loop.

GStringAsMapKey.description=A GString should not be used as a map key since its hashcode is not guaranteed to be stable. Consider calling key.toString().
GStringAsMapKey.description.html=A GString should not be used as a map key since its hashcode is not guaranteed to be stable. Consider calling <em>key.toString()</em>.

InvertedIfElse.description=An inverted if-else statement is one in which there is a single if statement with a single else branch and the boolean test of the if is negated. For instance "if (!x) false else true". It is usually clearer to write this as "if (x) true else false".
InvertedIfElse.description.html=An inverted if-else statement is one in which there is a single <em>if</em> statement with a single <em>else</em> branch and the boolean test of the if is negated. For instance <em>if (!x) false else true</em>. It is usually clearer to write this as <em>if (x) true else false</em>.

RemoveAllOnSelf.description=Don't use removeAll to clear a collection. If you want to remove all elements from a collection c, use c.clear, not c.removeAll(c). Calling c.removeAll(c) to clear a collection is less clear, susceptible to errors from typos, less efficient and for some collections, might throw a ConcurrentModificationException.
RemoveAllOnSelf.description.html=Don't use <em>removeAll</em> to clear a collection. If you want to remove all elements from a collection c, use c.clear, not c.removeAll(c). Calling <em>c.removeAll(c)</em> to clear a collection is less clear, susceptible to errors from typos, less efficient and for some collections, might throw a <em>ConcurrentModificationException</em>.

ReturnFromFinallyBlock.description=Returning from a finally block is confusing and can hide the original exception.
ReturnFromFinallyBlock.description.html=Returning from a <em>finally</em> block is confusing and can hide the original exception.

ReturnsNullInsteadOfEmptyArray.description=Consider returning a zero length array rather than null. It is often a better design to return a length zero array rather than a null reference to indicate that there are no results (i.e., an empty list of results). This way, no explicit check for null is needed by clients of the method.
ReturnsNullInsteadOfEmptyArray.description.html=Consider returning a zero length array rather than null. It is often a better design to return a length zero array rather than a null reference to indicate that there are no results (i.e., an empty list of results). This way, no explicit check for null is needed by clients of the method.

ReturnsNullInsteadOfEmptyCollection.description=Consider returning a zero length collection rather than null. It is often a better design to return a length zero collection rather than a null reference to indicate that there are no results (i.e., an empty list of results). This way, no explicit check for null is needed by clients of the method.
ReturnsNullInsteadOfEmptyCollection.description.html=Consider returning a zero length collection rather than null. It is often a better design to return a length zero collection rather than a null reference to indicate that there are no results (i.e., an empty list of results). This way, no explicit check for null is needed by clients of the method.

SerialVersionUID.description=A serialVersionUID is normally intended to be used with Serialization. It needs to be of type long, static, and final. Also, it should have a visibility modifier such as public or private. Providing no modifier creates a Property and Groovy generates a getter, which is probably not intended.
SerialVersionUID.description.html=A serialVersionUID is normally intended to be used with Serialization. It needs to be of type long, static, and final. Also, it should have a visibility modifier such as public or private. Providing no modifier creates a Property and Groovy generates a getter, which is probably not intended.

SimpleDateFormatMissingLocale.description=Be sure to specify a Locale when creating a new instance of SimpleDateFormat; the class is locale-sensitive. If you instantiate SimpleDateFormat without a Locale parameter, it will format the date and time according to the default Locale. Both the pattern and the Locale determine the format. For the same pattern, SimpleDateFormat may format a date and time differently if the Locale varies.
SimpleDateFormatMissingLocale.description.html=Be sure to specify a Locale when creating a new instance of SimpleDateFormat; the class is locale-sensitive. If you instantiate SimpleDateFormat without a Locale parameter, it will format the date and time according to the default Locale. Both the pattern and the Locale determine the format. For the same pattern, SimpleDateFormat may format a date and time differently if the Locale varies.

ThrowExceptionFromFinallyBlock.description=Throwing an exception from a finally block is confusing and can hide the original exception.
ThrowExceptionFromFinallyBlock.description.html=Throwing an exception from a <em>finally</em> block is confusing and can hide the original exception.

UnsafeCallToNegativeOffset.description=This possible warns of referencing the element at the index of -1 in an Array or List. It is possible to get the last element of a list by calling list[-1], however an empty list will throw an exception for this operation. It is usually better to use the last() method on the list or array to access the last element. The last() method returns the last element of the collection or null if not found.
UnsafeCallToNegativeOffset.description.html=This possible warns of referencing the element at the index of -1 in an Array or List. It is possible to get the last element of a list by calling list[-1], however an empty list will throw an exception for this operation. It is usually better to use the last() method on the list or array to access the last element. The last() method returns the last element of the collection or null if not found.

UseCollectMany.description=In many case collectMany() yields the same result as collect{}.flatten(). It is easier to understand and more clearly conveys the intent.
UseCollectMany.description.html=In many case <em>collectMany()</em> yields the same result as <em>collect{}.flatten()</em>. It is easier to understand and more clearly conveys the intent.

UseCollectNested.description=Instead of nested collect{}-calls use collectNested{}
UseCollectNested.description.html=Instead of nested collect{}-calls use collectNested{}

ClosureAsLastMethodParameter.description=If a method is called and the last parameter is an inline closure then it can be declared outside of the method call brackets.
ClosureAsLastMethodParameter.description.html=If a method is called and the last parameter is an inline closure then it can be declared outside of the method call brackets.

ElseBlockBraces.description=Use braces for else blocks, even for a single statement. By default, braces are not required for an else if it is followed immediately by an if. Set the bracesRequiredForElseIf property to true to require braces is that situation as well.
ElseBlockBraces.description.html=Use braces for <em>else</em> blocks, even for a single statement. By default, braces are not required for an <em>else</em> if it is followed immediately by an <em>if</em>. Set the <em>bracesRequiredForElseIf</em> property to true to require braces is that situation as well.

ForStatementBraces.description=Use braces for for statements, even for a single statement.
ForStatementBraces.description.html=Use braces for <em>for</em> statements, even for a single statement.

IfStatementBraces.description=Use braces for if statements, even for a single statement.
IfStatementBraces.description.html=Use braces for <em>if</em> statements, even for a single statement.

WhileStatementBraces.description=Use braces for while statements, even for a single statement.
WhileStatementBraces.description.html=Use braces for <em>while</em> statements, even for a single statement.

NestedSynchronization.description=Nested synchronized statements should be avoided. Nested synchronized statements are either useless (if the lock objects are identical) or prone to deadlock.
NestedSynchronization.description.html=Nested synchronized statements should be avoided. Nested synchronized statements are either useless (if the lock objects are identical) or prone to deadlock.

SynchronizedMethod.description=This rule reports uses of the synchronized keyword on methods. Synchronized methods are the same as synchronizing on 'this', which effectively make your synchronization policy public and modifiable by other objects. To avoid possibilities of deadlock, it is better to synchronize on internal objects.
SynchronizedMethod.description.html=This rule reports uses of the <em>synchronized</em> keyword on methods. Synchronized methods are the same as synchronizing on 'this', which effectively make your synchronization policy public and modifiable by other objects. To avoid possibilities of deadlock, it is better to synchronize on internal objects.

SynchronizedOnGetClass.description=Synchronization on getClass rather than class literal. This instance method synchronizes on this.getClass(). If this class is subclassed, subclasses will synchronize on the class object for the subclass, which isn't likely what was intended.
SynchronizedOnGetClass.description.html=Synchronization on getClass rather than class literal. This instance method synchronizes on this.getClass(). If this class is subclassed, subclasses will synchronize on the class object for the subclass, which isn't likely what was intended.

SynchronizedOnThis.description=This rule reports uses of the synchronized blocks where the synchronization reference is 'this'. Doing this effectively makes your synchronization policy public and modifiable by other objects. To avoid possibilities of deadlock, it is better to synchronize on internal objects.
SynchronizedOnThis.description.html=This rule reports uses of the <em>synchronized</em> blocks where the synchronization reference is 'this'. Doing this effectively makes your synchronization policy public and modifiable by other objects. To avoid possibilities of deadlock, it is better to synchronize on internal objects.

SystemRunFinalizersOnExit.description=Method calls to System.runFinalizersOnExit() should not be allowed. This method is inherently non-thread-safe, may result in data corruption, deadlock, and may effect parts of the program far removed from it's call point. It is deprecated, and it's use strongly discouraged.
SystemRunFinalizersOnExit.description.html=Method calls to <em>System.runFinalizersOnExit()</em> should not be allowed. This method is inherently non-thread-safe, may result in data corruption, deadlock, and may effect parts of the program far removed from it's call point. It is deprecated, and it's use strongly discouraged.

ThreadYield.description=Method calls to Thread.yield() should not be allowed. This method has no useful guaranteed semantics, and is often used by inexperienced programmers to mask race conditions.
ThreadYield.description.html=Method calls to <em>Thread.yield()</em> should not be allowed. This method has no useful guaranteed semantics, and is often used by inexperienced programmers to mask race conditions.

ThreadLocalNotStaticFinal.description=ThreadLocal fields should be static and final. In the most common case a java.lang.ThreadLocal instance associates state with a thread. A non-static non-final java.lang.ThreadLocal field associates state with an instance-thread combination. This is seldom necessary and often a bug which can cause memory leaks and possibly incorrect behavior.
ThreadLocalNotStaticFinal.description.html=<em>ThreadLocal</em> fields should be <em>static</em> and <em>final</em>. In the most common case a <em>java.lang.ThreadLocal</em> instance associates state with a thread. A non-<em>static</em> non-<em>final</em> <em>java.lang.ThreadLocal</em> field associates state with an instance-thread combination. This is seldom necessary and often a bug which can cause memory leaks and possibly incorrect behavior.

UseOfNotifyMethod.description=This code calls notify() rather than notifyAll(). Java monitors are often used for multiple conditions. Calling notify() only wakes up one thread, meaning that the thread woken up might not be the one waiting for the condition that the caller just satisfied.
UseOfNotifyMethod.description.html=This code calls notify() rather than notifyAll(). Java monitors are often used for multiple conditions. Calling notify() only wakes up one thread, meaning that the thread woken up might not be the one waiting for the condition that the caller just satisfied.

VolatileLongOrDoubleField.description=Long or double fields should not be declared as volatile. Java specifies that reads and writes from such fields are atomic, but many JVM's have violated this specification. Unless you are certain of your JVM, it is better to synchronize access to such fields rather than declare them volatile. This rule flags fields marked volatile when their type is double or long or the name of their type is "Double" or "Long".
VolatileLongOrDoubleField.description.html=Long or double fields should not be declared as <em>volatile</em>. Java specifies that reads and writes from such fields are atomic, but many JVM's have violated this specification. Unless you are certain of your JVM, it is better to synchronize access to such fields rather than declare them <em>volatile</em>. This rule flags fields marked <em>volatile</em> when their type is double or long or the name of their type is "Double" or "Long".

AbstractClassWithoutAbstractMethod.description=The abstract class does not contain any abstract methods. An abstract class suggests an incomplete implementation, which is to be completed by subclasses implementing the abstract methods. If the class is intended to be used as a base class only (not to be instantiated direcly) a protected constructor can be provided prevent direct instantiation.
AbstractClassWithoutAbstractMethod.description.html=The abstract class does not contain any abstract methods. An abstract class suggests an incomplete implementation, which is to be completed by subclasses implementing the abstract methods. If the class is intended to be used as a base class only (not to be instantiated direcly) a protected constructor can be provided prevent direct instantiation.

CloseWithoutCloseable.description=If a class defines a "void close()" then that class should implement java.io.Closeable.
CloseWithoutCloseable.description.html=If a class defines a "void close()" then that class should implement java.io.Closeable.

ConstantsOnlyInterface.description=An interface should be used only to model a behaviour of a class: using an interface as a container of constants is a poor usage pattern.
ConstantsOnlyInterface.description.html=An interface should be used only to model a behaviour of a class: using an interface as a container of constants is a poor usage pattern.

EmptyMethodInAbstractClass.description=An empty method in an abstract class should be abstract instead, as developer may rely on this empty implementation rather than code the appropriate one.
EmptyMethodInAbstractClass.description.html=An empty method in an abstract class should be abstract instead, as developer may rely on this empty implementation rather than code the appropriate one.

FinalClassWithProtectedMember.description=This rule finds classes marked final that contain protected methods. If a class is final then it may not be subclassed, and there is therefore no point in having a method with protected visibility. Either the class should not be final or the method should be private or protected.
FinalClassWithProtectedMember.description.html=This rule finds classes marked final that contain protected methods. If a class is final then it may not be subclassed, and there is therefore no point in having a method with protected visibility. Either the class should not be final or the method should be private or protected.

ImplementationAsType.description=Checks for use of a predefined set of concrete classes (e.g. ArrayList, Hashtable, ConcurrentHashMap) when specifying the type of a method parameter, closure parameter, constructor parameter, method return type or field type. The associated interfaces should be used to specify the type instead.
ImplementationAsType.description.html=Checks for use of a predefined set of concrete classes (e.g. <em>ArrayList</em>, <em>Hashtable</em>, <em>ConcurrentHashMap</em>) when specifying the type of a method parameter, closure parameter, constructor parameter, method return type or field type. The associated interfaces should be used to specify the type instead.

DuplicateNumberLiteral.description=Code containing duplicate number literals can usually be improved by declaring the number as a constant field.  The ignoreNumbers property (${rule.ignoreNumbers}) can optionally specify a comma-separated list of numbers to ignore.
DuplicateNumberLiteral.description.html=Code containing number String literals can usually be improved by declaring the number as a constant field.  The <em>ignoreNumbers</em> property (${rule.ignoreNumbers}) can optionally specify a comma-separated list of numbers to ignore.

DuplicateStringLiteral.description=Code containing duplicate String literals can usually be improved by declaring the String as a constant field. The ignoreStrings property (${rule.ignoreStrings}) can optionally specify a comma-separated list of Strings to ignore.
DuplicateStringLiteral.description.html=Code containing duplicate String literals can usually be improved by declaring the String as a constant field. The <em>ignoreStrings</em> property (${rule.ignoreStrings}) can optionally specify a comma-separated list of Strings to ignore.

DuplicateListLiteral.description=Code containing duplicate List literals can usually be improved by declaring the List as a constant field.
DuplicateListLiteral.description.html=Code containing duplicate <em>List</em> literals can usually be improved by declaring the <em>List</em> as a constant field.

DuplicateMapLiteral.description=Code containing duplicate Map literals can usually be improved by declaring the Map as a constant field.
DuplicateMapLiteral.description.html=Code containing duplicate <em>Map</em> literals can usually be improved by declaring the <em>Map</em> as a constant field.

CatchArrayIndexOutOfBoundsException.description=Check the size of the array before accessing an array element rather than catching ArrayIndexOutOfBoundsException.
CatchArrayIndexOutOfBoundsException.description.html=Check the size of the array before accessing an array element rather than catching <em>ArrayIndexOutOfBoundsException</em>.

CatchError.description=Catching Error is dangerous; it can catch exceptions such as ThreadDeath and OutOfMemoryError.
CatchError.description.html=Catching <em>Error</em> is dangerous; it can catch exceptions such as <em>ThreadDeath</em> and <em>OutOfMemoryError</em>.

CatchException.description=Catching Exception is often too broad or general. It should usually be restricted to framework or infrastructure code, rather than application code.
CatchException.description.html=Catching <em>Exception</em> is often too broad or general. It should usually be restricted to framework or infrastructure code, rather than application code.

CatchIllegalMonitorStateException.description=Dubious catching of IllegalMonitorStateException. IllegalMonitorStateException is generally only thrown in case of a design flaw in your code (calling wait or notify on an object you do not hold a lock on).
CatchIllegalMonitorStateException.description.html=Dubious catching of IllegalMonitorStateException. IllegalMonitorStateException is generally only thrown in case of a design flaw in your code (calling wait or notify on an object you do not hold a lock on).

CatchIndexOutOfBoundsException.description=Check that an index is valid before accessing an indexed element rather than catching IndexOutOfBoundsException.
CatchIndexOutOfBoundsException.description.html=Check that an index is valid before accessing an indexed element rather than catching <em>IndexOutOfBoundsException</em>.

CatchNullPointerException.description=Catching NullPointerException is never appropriate. It should be avoided in the first place with proper null checking, and it can mask underlying errors.
CatchNullPointerException.description.html=Catching <em>NullPointerException</em> is never appropriate. It should be avoided in the first place with proper null checking, and it can mask underlying errors.

CatchRuntimeException.description=Catching RuntimeException is often too broad or general. It should usually be restricted to framework or infrastructure code, rather than application code.
CatchRuntimeException.description.html=Catching <em>RuntimeException</em> is often too broad or general. It should usually be restricted to framework or infrastructure code, rather than application code.

CatchThrowable.description=Catching Throwable is dangerous; it can catch exceptions such as ThreadDeath and OutOfMemoryError.
CatchThrowable.description.html=Catching <em>Throwable</em> is dangerous; it can catch exceptions such as <em>ThreadDeath</em> and <em>OutOfMemoryError</em>.

ConfusingClassNamedException.description=This class is not derived from another exception, but ends with 'Exception'. This will be confusing to users of this class.
ConfusingClassNamedException.description.html=This class is not derived from another exception, but ends with 'Exception'. This will be confusing to users of this class.

ExceptionExtendsError.description=Errors are system exceptions. Do not extend them.
ExceptionExtendsError.description.html=Errors are system exceptions. Do not extend them.

MissingNewInThrowStatement.description=A common Groovy mistake when throwing exceptions is to forget the new keyword. For instance, "throw RuntimeException()" instead of "throw new RuntimeException()". If the error path is not unit tested then the production system will throw a Method Missing exception and hide the root cause. This rule finds constructs like "throw RuntimeException()" that look like a new keyword was meant to be used but forgotten.
MissingNewInThrowStatement.description.html=A common Groovy mistake when throwing exceptions is to forget the new keyword. For instance, "throw RuntimeException()" instead of "throw new RuntimeException()". If the error path is not unit tested then the production system will throw a Method Missing exception and hide the root cause. This rule finds constructs like "throw RuntimeException()" that look like a new keyword was meant to be used but forgotten.

ReturnNullFromCatchBlock.description=Returning null from a catch block often masks errors and requires the client to handle error codes. In some coding styles this is discouraged.
ReturnNullFromCatchBlock.description.html=Returning <em>null</em> from a catch block often masks errors and requires the client to handle error codes. In some coding styles this is discouraged.

ThrowError.description=Checks for throwing an instance of java.lang.Error.
ThrowError.description.html=Checks for throwing an instance of <em>java.lang.Error</em>.

ThrowException.description=Checks for throwing an instance of java.lang.Exception.
ThrowException.description.html=Checks for throwing an instance of <em>java.lang.Exception</em>.

ThrowNullPointerException.description=Checks for throwing an instance of java.lang.NullPointerException.
ThrowNullPointerException.description.html=Checks for throwing an instance of <em>java.lang.NullPointerException</em>.

ThrowRuntimeException.description=Checks for throwing an instance of java.lang.RuntimeException.
ThrowRuntimeException.description.html=Checks for throwing an instance of <em>java.lang.RuntimeException</em>.

ThrowThrowable.description=Checks for throwing an instance of java.lang.Throwable.
ThrowThrowable.description.html=Checks for throwing an instance of <em>java.lang.Throwable</em>.

IllegalRegex.description=Checks for a specified illegal regular expression within the source code. The regex property specifies the regular expression to check for. It is required and cannot be null or empty.
IllegalRegex.description.html=Checks for a specified illegal regular expression within the source code. The <em>regex</em> property specifies the regular expression to check for. It is required and cannot be null or empty.

RequiredRegex.description=Checks for a specified regular expression that must exist within the source code. The regex property specifies the regular expression to check for. It is required and cannot be null or empty.
RequiredRegex.description.html=Checks for a specified regular expression that must exist within the source code. The <em>regex</em> property specifies the regular expression to check for. It is required and cannot be null or empty.

RequiredString.description=Checks for a specified text string that must exist within the source code. The string property specifies the String to check for. It is required and cannot be null or empty.
RequiredString.description.html=Checks for a specified text string that must exist within the source code. The <em>string</em> property specifies the String to check for. It is required and cannot be null or empty.

StatelessClass.description=Checks for fields on classes that should remain "stateless" and reentrant. The ignoreFieldNames property (${rule.ignoreFieldNames}) specifies one or more field names that should be ignored. The ignoreFieldTypes property specifies one or more field type names that should be ignored. Both can optionally contain wildcard characters ('*' or '?').
StatelessClass.description.html=Checks for fields on classes that should remain "stateless" and reentrant. The <em>ignoreFieldNames</em> property (${rule.ignoreFieldNames}) specifies one or more field names that should be ignored. The <em>ignoreFieldTypes</em> property specifies one or more field type names that should be ignored. Both can optionally contain wildcard characters ('*' or '?').

GrailsPublicControllerMethod.description=Checks for public methods on Grails controller classes. Static methods are ignored.
GrailsPublicControllerMethod.description.html=Checks for <em>public</em> methods on Grails controller classes. Static methods are ignored.

GrailsSessionReference.description=Checks for references to the session object from within Grails controller and taglib classes. [DEPRECATED]
GrailsSessionReference.description.html=Checks for references to the <em>session</em> object from within Grails controller and taglib classes. [DEPRECATED]

GrailsServletContextReference.description=Checks for references to the servletContext object from within Grails controller and taglib classes.
GrailsServletContextReference.description.html=Checks for references to the <em>servletContext</em> object from within Grails controller and taglib classes.

GrailsStatelessService.description=Checks for fields on Grails service classes. Grails service classes are singletons, by default, and so they should be reentrant and typically stateless. The ignoreFieldNames property (${rule.ignoreFieldNames}) specifies one or more field names that should be ignored. The ignoreFieldTypes property (${rule.ignoreFieldTypes}) specifies one or more field type names that should be ignored. Both can optionally contain wildcard characters ('*' or '?').
GrailsStatelessService.description.html=Checks for fields on Grails service classes. Grails service classes are singletons, by default, and so they should be reentrant and typically stateless. The <em>ignoreFieldNames</em> property (${rule.ignoreFieldNames}) specifies one or more field names that should be ignored. The <em>ignoreFieldTypes</em> property (${rule.ignoreFieldTypes}) specifies one or more field type names that should be ignored. Both can optionally contain wildcard characters ('*' or '?').

DuplicateImport.description=Duplicate import statements are unnecessary.
DuplicateImport.description.html=Duplicate import statements are unnecessary.

UnnecessaryInstantiationToGetClass.description=Avoid instantiating an object just to call getClass() on it; use the .class public member instead.
UnnecessaryInstantiationToGetClass.description.html=Avoid instantiating an object just to call getClass() on it; use the .class public member instead.

ImportFromSamePackage.description=An import of a class that is within the same package is unnecessary.
ImportFromSamePackage.description.html=An import of a class that is within the same package is unnecessary.

UnnecessaryGroovyImport.description=A Groovy file does not need to include an import for classes from java.lang, java.util, java.io, java.net, groovy.lang and groovy.util, as well as the classes java.math.BigDecimal and java.math.BigInteger.
UnnecessaryGroovyImport.description.html=A Groovy file does not need to include an import for classes from <em>java.lang</em>, <em>java.util</em>, <em>java.io</em>, <em>java.net</em>, <em>groovy.lang</em> and <em>groovy.util</em>, as well as the classes <em>java.math.BigDecimal</em> and <em>java.math.BigInteger</em>.

UnusedImport.description=Imports for a class that is never referenced within the source file is unnecessary.
UnusedImport.description.html=Imports for a class that is never referenced within the source file is unnecessary.

MisorderedStaticImports.description=Static imports should never be declared after nonstatic imports.
MisorderedStaticImports.description.html=Static imports should never be declared after nonstatic imports.

NoWildcardImports.description=Wildcard imports, static or otherwise, should not be used.
NoWildcardImports.description.html=Wildcard imports, static or otherwise, should not be used.

JUnitSetUpCallsSuper.description=Checks that if the JUnit setUp() method is defined, that it includes a call to super.setUp().
JUnitSetUpCallsSuper.description.html=Checks that if the JUnit <em>setUp()</em> method is defined, that it includes a call to <em>super.setUp()</em>.

JUnitTearDownCallsSuper.description=Checks that if the JUnit tearDown() method is defined, that it includes a call to super.tearDown().
JUnitTearDownCallsSuper.description.html=Checks that if the JUnit <em>tearDown()</em> method is defined, that it includes a call to <em>super.tearDown()</em>.

JUnitAssertAlwaysFails.description=Checks for JUnit assert() method calls with constant arguments such that the assertion always fails. This includes: assertTrue(false), assertFalse(true) and assertNull(CONSTANT).
JUnitAssertAlwaysFails.description.html=Checks for JUnit <em>assert()</em> method calls with constant arguments such that the assertion always fails. This includes: <em>assertTrue(false)</em>, <em>assertFalse(true)</em> and <em>assertNull(CONSTANT)</em>.

JUnitAssertAlwaysSucceeds.description=Checks for JUnit assert() method calls with constant arguments such that the assertion always succeeds. This includes: assertTrue(true), assertFalse(false) and assertNull(null).
JUnitAssertAlwaysSucceeds.description.html=Checks for JUnit <em>assert()</em> method calls with constant arguments such that the assertion always succeeds. This includes: <em>assertTrue(true)</em>, <em>assertFalse(false)</em> and <em>assertNull(null)</em>.

JUnitAssertEqualsConstantActualValue.description=Reports usages of org.junit.Assert.assertEquals([message,] expected, actual) where the 'actual' parameter is a constant or a literal. Most likely it was intended to be the 'expected' value.
JUnitAssertEqualsConstantActualValue.description.html=Reports usages of org.junit.Assert.assertEquals([message,] expected, actual) where the 'actual' parameter is a constant or a literal. Most likely it was intended to be the 'expected' value.

JUnitPublicNonTestMethod.description=Checks if a JUnit test class contains public methods other than standard test methods, JUnit framework methods or methods with JUnit annotations.
JUnitPublicNonTestMethod.description.html=Checks if a JUnit test class contains public methods other than standard test methods, JUnit framework methods or methods with JUnit annotations.

JUnitStyleAssertions.description=This rule detects calling JUnit style assertions like assertEquals, assertTrue, assertFalse, assertNull, assertNotNull. Groovy 1.7 ships with a feature called the "power assert", which is an assert statement with better error reporting. This is preferable to the JUnit assertions.
JUnitStyleAssertions.description.html=This rule detects calling JUnit style assertions like <em>assertEquals</em>, <em>assertTrue</em>, <em>assertFalse</em>, <em>assertNull</em>, <em>assertNotNull</em>. Groovy 1.7 ships with a feature called the "power assert", which is an assert statement with better error reporting. This is preferable to the JUnit assertions.

JUnitUnnecessarySetUp.description=Checks for JUnit setUp() methods that contain only a call to super.setUp().
JUnitUnnecessarySetUp.description.html=Checks for JUnit <em>setUp()</em> methods that contain only a call to <em>super.setUp()</em>.

JUnitUnnecessaryTearDown.description=Checks for JUnit tearDown() methods that contain only a call to super.tearDown().
JUnitUnnecessaryTearDown.description.html=Checks for JUnit <em>tearDown()</em> methods that contain only a call to <em>super.tearDown()</em>.

UseAssertEqualsInsteadOfAssertTrue.description=This rule detects JUnit assertions in object equality. These assertions should be made by more specific methods, like assertEquals.
UseAssertEqualsInsteadOfAssertTrue.description.html=This rule detects JUnit assertions in object equality. These assertions should be made by more specific methods, like <em>assertEquals</em>.

UseAssertNullInsteadOfAssertEquals.description=This rule detects JUnit calling assertEquals where the first or second parameter is null. These assertion should be made against the assertNull method instead.
UseAssertNullInsteadOfAssertEquals.description.html=This rule detects JUnit calling <em>assertEquals</em> where the first or second parameter is null. These assertion should be made against the <em>assertNull</em> method instead.

UseAssertSameInsteadOfAssertTrue.description=This rule detects JUnit calling assertTrue where the first or second parameter is an Object#is() call testing for reference equality. These assertion should be made against the assertSame method instead.
UseAssertSameInsteadOfAssertTrue.description.html=This rule detects JUnit calling <em>assertTrue</em> where the first or second parameter is an Object#is() call testing for reference equality. These assertion should be made against the <em>assertSame</em> method instead.

UseAssertFalseInsteadOfNegation.description=In unit tests, if a condition is expected to be false then there is no sense using assertTrue with the negation operator. For instance, assertTrue(!condition) can always be simplified to assertFalse(condition)
UseAssertFalseInsteadOfNegation.description.html=In unit tests, if a condition is expected to be false then there is no sense using assertTrue with the negation operator. For instance, assertTrue(!condition) can always be simplified to assertFalse(condition)

UseAssertTrueInsteadOfAssertEquals.description=This rule detects JUnit calling assertEquals where the first parameter is a boolean. These assertions should be made by more specific methods, like assertTrue or assertFalse.
UseAssertTrueInsteadOfAssertEquals.description.html=This rule detects JUnit calling <em>assertEquals</em> where the first parameter is a boolean. These assertions should be made by more specific methods, like <em>assertTrue</em> or <em>assertFalse</em>.

UseAssertTrueInsteadOfNegation.description=In unit tests, if a condition is expected to be true then there is no sense using assertFalse with the negation operator. For instance, assertFalse(!condition) can always be simplified to assertTrue(condition)
UseAssertTrueInsteadOfNegation.description.html=In unit tests, if a condition is expected to be true then there is no sense using assertFalse with the negation operator. For instance, assertFalse(!condition) can always be simplified to assertTrue(condition)

JUnitFailWithoutMessage.description=This rule detects JUnit calling the fail() method without an argument. For better error reporting you should always provide a message.
JUnitFailWithoutMessage.description.html=This rule detects JUnit calling the <em>fail()</em> method without an argument. For better error reporting you should always provide a message.

JUnitTestMethodWithoutAssert.description=This rule searches for test methods that do not contain assert statements. Either the test method is missing assert statements, which is an error, or the test method contains custom assert statements that do not follow a proper assert naming convention. Test methods are defined as public void methods that begin with the work test or have a @Test annotation. By default this rule applies to the default test class names, but this can be changed using the rule's applyToClassNames property.
JUnitTestMethodWithoutAssert.description.html=This rule searches for test methods that do not contain assert statements. Either the test method is missing assert statements, which is an error, or the test method contains custom assert statements that do not follow a proper assert naming convention. Test methods are defined as public void methods that begin with the work test or have a @Test annotation. By default this rule applies to the default test class names, but this can be changed using the rule's applyToClassNames property.

LoggerForDifferentClass.description=Checks for instantiating a logger (Log4J, SLF4J, Logback, Apache Commons Logging or Java Util Logging) for a class other than the current class.
LoggerForDifferentClass.description.html=Checks for instantiating a logger (<em>Log4J</em>, <em>SLF4J</em>, <em>Logback</em>, <em>Apache Commons Logging</em> or <em>Java Util Logging</em>) for a class other than the current class.

LoggingSwallowsStacktrace.description=If you are logging an exception then the proper API is to call error(Object, Throwable), which will log the message and the exception stack trace. If you call error(Object) then the stacktrace may not be logged.
LoggingSwallowsStacktrace.description.html=If you are logging an exception then the proper API is to call error(Object, Throwable), which will log the message and the exception stack trace. If you call error(Object) then the stacktrace may not be logged.

LoggerWithWrongModifiers.description=Logger objects should be declared private, static and final. If subclasses should have access to a Logger in a parent class then the Logger should be declared protected, non-static and final. This rule find loggers that are not declared with these modifiers.
LoggerWithWrongModifiers.description.html=Logger objects should be declared private, static and final. If subclasses should have access to a Logger in a parent class then the Logger should be declared protected, non-static and final. This rule find loggers that are not declared with these modifiers.

MultipleLoggers.description=This rule catches classes that have more than one logger object defined. Typically, a class has zero or one logger objects.
MultipleLoggers.description.html=This rule catches classes that have more than one logger object defined. Typically, a class has zero or one logger objects.

PrintStackTrace.description=Checks for calls to printStackTrace().
PrintStackTrace.description.html=Checks for calls to <em>printStackTrace()</em>.

Println.description=Checks for calls to this.print(), this.println() or this.printf().
Println.description.html=Checks for calls to <em>this.print()</em>, <em>this.println()</em> or <em>this.printf()</em>.

SystemErrPrint.description=Checks for calls to System.err.print(), System.err.println() or System.err.printf().
SystemErrPrint.description.html=Checks for calls to <em>System.err.print()</em>, <em>System.err.println()</em> or <em>System.err.printf()</em>.

SystemOutPrint.description=Checks for calls to System.out.print(), System.out.println() or System.out.printf().
SystemOutPrint.description.html=Checks for calls to <em>System.out.print()</em>, <em>System.out.println()</em> or <em>System.out.printf()</em>.

AbstractClassName.description=Verifies that the name of an abstract class matches a regular expression specified in the regex property. If that property is null or empty, then this rule is not applied (i.e., it does nothing). It defaults to null, so this rule must be explicitly configured to be active. This rule ignores interfaces.
AbstractClassName.description.html=Verifies that the name of an abstract class matches a regular expression specified in the <em>regex</em> property. If that property is null or empty, then this rule is not applied (i.e., it does nothing). It defaults to null, so this rule must be explicitly configured to be active. This rule ignores interfaces.

ClassName.description=Verifies that the name of a class matches a regular expression. By default it checks that the class name starts with an uppercase letter and is followed by zero or more word characters (letters, numbers or underscores). The regex property specifies the regular expression used to validate the class name.
ClassName.description.html=Verifies that the name of a class matches a regular expression. By default it checks that the class name starts with an uppercase letter and is followed by zero or more word characters (letters, numbers or underscores). The <em>regex</em> property specifies the regular expression used to validate the class name.

ClassNameSameAsFilename.description=Reports files containing only one top level class / enum / interface which is named differently than the file.
ClassNameSameAsFilename.description.html=Reports files containing only one top level class / enum / interface which is named differently than the file.

FieldName.description=Verifies that the name of each field matches a regular expression. By default it checks that non-'final' field names start with a lowercase letter and contains only letters or numbers, and 'final' field names start with an uppercase letter and contain only uppercase letters, numbers and underscores. The regex property specifies the default regular expression used to validate field names. The finalRegex property specifies the regular expression to validate 'final' field names. The staticRegex property specifies the regular expression to validate 'static' field names. The staticFinalRegex property specifies the regular expression to validate 'static final' field names.  The ignoreFieldNames property (${rule.ignoreFieldNames}) can specify field names that should be ignored, optionally containing wildcard characters ('*' or '?').
FieldName.description.html=Verifies that the name of each field matches a regular expression. By default it checks that non-'final' field names start with a lowercase letter and contains only letters or numbers, and 'final' field names start with an uppercase letter and contain only uppercase letters, numbers and underscores. The <em>regex</em> property specifies the default regular expression used to validate field names. The <em>finalRegex</em> property specifies the regular expression to validate 'final' field names. The <em>staticRegex</em> property specifies the regular expression to validate 'static' field names. The <em>staticFinalRegex</em> property specifies the regular expression to validate 'static final' field names.  The <em>ignoreFieldNames</em> property (${rule.ignoreFieldNames})can specify field names that should be ignored, optionally containing wildcard characters ('*' or '?').

InterfaceName.description=Verifies that the name of an interface matches a regular expression specified in the regex property. If that property is null or empty, then this rule is not applied (i.e., it does nothing). It defaults to null, so this rule must be explicitly configured to be active.
InterfaceName.description.html=Verifies that the name of an interface matches a regular expression specified in the <em>regex</em> property. If that property is null or empty, then this rule is not applied (i.e., it does nothing). It defaults to null, so this rule must be explicitly configured to be active.

MethodName.description=Verifies that the name of each method matches a regular expression. By default it checks that the method name starts with a lowercase letter. The regex property specifies the regular expression to check the method name against.  The ignoreMethodNames property (${rule.ignoreMethodNames}) can specify method names that should be ignored, optionally containing wildcard characters ('*' or '?').
MethodName.description.html=Verifies that the name of each method matches a regular expression. By default it checks that the method name starts with a lowercase letter. The <em>regex</em> property specifies the regular expression to check the method name against.  The <em>ignoreMethodNames</em> property (${rule.ignoreMethodNames}) can specify method names that should be ignored, optionally containing wildcard characters ('*' or '?').

ObjectOverrideMisspelledMethodName.description=Verifies that the names of the most commonly overridden methods of Object: equals, hashCode and toString, are correct.
ObjectOverrideMisspelledMethodName.description.html=Verifies that the names of the most commonly overridden methods of Object: <em>equals</em>, <em>hashCode</em> and <em>toString</em>, are correct.

PackageName.description=Verifies that the package name for a class matches a regular expression. By default it checks that the package name consists of only lowercase letters, separated by periods. The regex property specifies the regular expression used to validate the package name. The packageNameRequired property indicates whether a package name declaration is required for all classes.
PackageName.description.html=Verifies that the package name for a class matches a regular expression. By default it checks that the package name consists of only lowercase letters, separated by periods. The <em>regex</em> property specifies the regular expression used to validate the package name. The <em>packageNameRequired</em> property indicates whether a package name declaration is required for all classes.

PackageNameMatchesFilePath.description=A package source file's path should match the package itself. To find the package-relevant subpath in the file path the groupId needs to be configured. It is expected in every package declaration.
PackageNameMatchesFilePath.description.html=A package source file's path should match the package itself. To find the package-relevant subpath in the file path the <em>groupId</em> <i>needs</i> to be configured. It is expected in every package declaration.

ParameterName.description=Verifies that the name of each parameter matches a regular expression. This rule applies to method parameters, constructor parameters and closure parameters. By default it checks that parameter names start with a lowercase letter and contains only letters or numbers. The regex property specifies the default regular expression used to validate the parameter name.  The ignoreParameterNames property (${rule.ignoreParameterNames}) can specify parameter names that should be ignored, optionally containing wildcard characters ('*' or '?').
ParameterName.description.html=Verifies that the name of each parameter matches a regular expression. This rule applies to method parameters, constructor parameters and closure parameters. By default it checks that parameter names start with a lowercase letter and contains only letters or numbers. The <em>regex</em> property specifies the default regular expression used to validate the parameter name.  The <em>ignoreParameterNames</em> property (${rule.ignoreParameterNames}) can specify parameter names that should be ignored, optionally containing wildcard characters ('*' or '?').

VariableName.description=Verifies that the name of each method matches a regular expression. By default it checks that non-'final' variable names start with a lowercase letter and contains only letters or numbers, and 'final' variable names start with an uppercase letter and contain only uppercase letters, numbers and underscores. The regex property specifies the default regular expression used to validate a non-'final' variable name. The finalRegex property specifies the regular expression used to validate 'final' variable names. The ignoreVariableNames property (${rule.ignoreVariableNames}) can specify variable names that should be ignored, optionally containing wildcard characters ('*' or '?').
VariableName.description.html=Verifies that the name of each method matches a regular expression. By default it checks that non-'final' variable names start with a lowercase letter and contains only letters or numbers, and 'final' variable names start with an uppercase letter and contain only uppercase letters, numbers and underscores. The <em>regex</em> property specifies the default regular expression used to validate a non-'final' variable name. The <em>finalRegex</em> property specifies the regular expression used to validate 'final' variable names. The <em>ignoreVariableNames</em> property (${rule.ignoreVariableNames}) can specify variable names that should be ignored, optionally containing wildcard characters ('*' or '?').

PropertyName.description=Verifies that the name of each property matches a regular expression. By default it checks that property names other than 'static final' start with a lowercase letter and contains only letters or numbers, and 'static final' property names start with an uppercase letter and contain only uppercase letters, numbers and underscores. The regex property specifies the default regular expression used to validate property names. The finalRegex property specifies the regular expression to validate 'final' property names. The staticRegex property specifies the regular expression to validate 'static' property names. The staticFinalRegex property specifies the regular expression to validate 'static final' property names.  The ignorePropertyNames property (${rule.ignorePropertyNames}) can specify property names that should be ignored, optionally containing wildcard characters ('*' or '?').
PropertyName.description.html=Verifies that the name of each property matches a regular expression. By default it checks that property names other than 'static final' start with a lowercase letter and contains only letters or numbers, and 'static final' property names start with an uppercase letter and contain only uppercase letters, numbers and underscores. The <em>regex</em> property specifies the default regular expression used to validate property names. The <em>finalRegex</em> property specifies the regular expression to validate 'final' property names. The <em>staticRegex</em> property specifies the regular expression to validate 'static' property names. The <em>staticFinalRegex</em> property specifies the regular expression to validate 'static final' property names.  The <em>ignorePropertyNames</em> property (${rule.ignorePropertyNames}) can specify property names that should be ignored, optionally containing wildcard characters ('*' or '?').

ConfusingMethodName.description=Checks for confusing method names. The referenced methods have names that differ only by capitalization. This is very confusing because if the capitalization were identical then one of the methods would override the other.
ConfusingMethodName.description.html=Checks for confusing method names. The referenced methods have names that differ only by capitalization. This is very confusing because if the capitalization were identical then one of the methods would override the other.

AbcComplexity.description=Checks the ABC metric of size/complexity for methods/classes.\
  A method (or "closure field") with an ABC complexity value (score) greater than the maxMethodComplexity \
  property (${rule.maxMethodComplexity}) causes a violation. Likewise, a class that has an (average method) ABC complexity\
  value greater than the maxClassAverageMethodComplexity property (${rule.maxClassAverageMethodComplexity}) causes a violation. [DEPRECATED: Use AbcMetric rule instead]
AbcComplexity.description.html=Checks the ABC metric of size/complexity for methods/classes.\
  A method (or "closure field") with an ABC complexity value (score) greater than the <em>maxMethodComplexity</em> \
  property (${rule.maxMethodComplexity}) causes a violation. Likewise, a class that has an (average method) ABC complexity\
  value greater than the <em>maxClassAverageMethodComplexity</em> property (${rule.maxClassAverageMethodComplexity}) causes a violation. [DEPRECATED: Use <em>AbcMetric</em> rule instead]

AbcMetric.description=Checks the ABC size metric for methods/classes. \
  A method (or "closure field") with an ABC score greater than the maxMethodAbcScore \
  property (${rule.maxMethodAbcScore}) causes a violation. Likewise, a class that has an (average method) ABC score \
  greater than the maxClassAverageMethodAbcScore property (${rule.maxClassAverageMethodAbcScore}) causes a violation.
AbcMetric.description.html=Checks the ABC size metric for methods/classes. \
  A method (or "closure field") with an ABC score greater than the <em>maxMethodAbcScore</em> \
  property (${rule.maxMethodAbcScore}) causes a violation. Likewise, a class that has an (average method) ABC score \
  greater than the <em>maxClassAverageMethodAbcScore</em> property (${rule.maxClassAverageMethodAbcScore}) causes a violation.

ClassSize.description=Checks if the size of a class exceeds the number of lines specified by the maxLines property (${rule.maxLines}).
ClassSize.description.html=Checks if the size of a class exceeds the number of lines specified by the <em>maxLines</em> property (${rule.maxLines}).

CyclomaticComplexity.description=Checks the cyclomatic complexity for methods/classes.\
  A method (or "closure field") with a cyclomatic complexity value greater than the maxMethodComplexity \
  property (${rule.maxMethodComplexity}) causes a violation. Likewise, a class that has an (average method) cyclomatic complexity\
  value greater than the maxClassAverageMethodComplexity property (${rule.maxClassAverageMethodComplexity}) causes a violation.
CyclomaticComplexity.description.html=Checks the cyclomatic complexity for methods/classes.\
  A method (or "closure field") with a cyclomatic complexity value greater than the <em>maxMethodComplexity</em> \
  property (${rule.maxMethodComplexity}) causes a violation. Likewise, a class that has an (average method) cyclomatic complexity\
  value greater than the <em>maxClassAverageMethodComplexity</em> property (${rule.maxClassAverageMethodComplexity}) causes a violation.

MethodCount.description=A class with too many methods is probably a good suspect for refactoring, in order to reduce its \
  complexity and find a way to have more fine grained objects. The <em>maxMethods</em> property (${rule.maxMethods}) specifies the threshold.
MethodCount.description.html=A class with too many methods is probably a good suspect for refactoring, in order to reduce its \
  complexity and find a way to have more fine grained objects.The <em>maxMethods</em> property (${rule.maxMethods}) specifies the threshold.

MethodSize.description=Checks if the size of a method exceeds the number of lines specified by the maxLines property (${rule.maxLines}).
MethodSize.description.html=Checks if the size of a method exceeds the number of lines specified by the <em>maxLines</em> property (${rule.maxLines}).

NestedBlockDepth.description=Checks for blocks or closures nested more than maxNestedBlockDepth (${rule.maxNestedBlockDepth}) levels deep.
NestedBlockDepth.description.html=Checks for blocks or closures nested more than <em>maxNestedBlockDepth</em> (${rule.maxNestedBlockDepth}) levels deep.

ParameterCount.description=Checks if the number of parameters in method/constructor exceeds the number of parameters specified by the maxParameters property.
ParameterCount.description.html=Checks if the number of parameters in method/constructor exceeds the number of parameters specified by the maxParameters property.

UnnecessaryBigDecimalInstantiation.description=It is unnecessary to instantiate BigDecimal objects. Instead just use the decimal literal or the 'G' identifier to force the type, such as 123.45 or 123.45G.
UnnecessaryBigDecimalInstantiation.description.html=It is unnecessary to instantiate BigDecimal objects. Instead just use the decimal literal or the 'G' identifier to force the type, such as 123.45 or 123.45G.

UnnecessaryBigIntegerInstantiation.description=It is unnecessary to instantiate BigInteger objects. Instead just use the literal with the 'G' identifier to force the type, such as 8G or 42G.
UnnecessaryBigIntegerInstantiation.description.html=It is unnecessary to instantiate BigInteger objects. Instead just use the literal with the 'G' identifier to force the type, such as 8G or 42G.

UnnecessaryBooleanExpression.description=Checks for unnecessary boolean expressions, including ANDing (&&) or ORing (||) with true, false, null, or a Map/List/String/Number literal. Also checks for negation (!) of true, false, null, or a Map/List/String/Number literal.
UnnecessaryBooleanExpression.description.html=Checks for unnecessary boolean expressions, including ANDing (&amp;&amp;) or ORing (||) with <em>true</em>, <em>false</em>, <em>null</em>, or a Map/List/String/Number literal. Also checks for negation (!) of <em>true</em>, <em>false</em>, <em>null</em>, or a Map/List/String/Number literal.

UnnecessaryBooleanInstantiation.description=Use Boolean.valueOf() for variable values or Boolean.TRUE and Boolean.FALSE for constant values instead of calling the Boolean() constructor directly or calling Boolean.valueOf(true) or Boolean.valueOf(false).
UnnecessaryBooleanInstantiation.description.html=Use <em>Boolean.valueOf()</em> for variable values or <em>Boolean.TRUE</em> and <em>Boolean.FALSE</em> for constant values instead of calling the <em>Boolean()</em> constructor directly or calling <em>Boolean.valueOf(true)</em> or <em>Boolean.valueOf(false)</em>.

UnnecessaryCallForLastElement.description=This rule checks for excessively verbose methods of accessing the last element of an array or list. For instance, it is possible to access the last element of an array by performing array[array.length - 1], in Groovy it is simpler to either call array.last() or array[-1]. The same is true for lists. This violation is triggered whenever a get, getAt, or array-style access is used with an object size check.
UnnecessaryCallForLastElement.description.html=This rule checks for excessively verbose methods of accessing the last element of an array or list. For instance, it is possible to access the last element of an array by performing array[array.length - 1], in Groovy it is simpler to either call array.last() or array[-1]. The same is true for lists. This violation is triggered whenever a get, getAt, or array-style access is used with an object size check.

UnnecessaryConstructor.description=This rule detects when a constructor is not necessary; i.e., when there's only one constructor, it's public, has an empty body, and takes no arguments.
UnnecessaryConstructor.description.html=This rule detects when a constructor is not necessary; i.e., when there's only one constructor, it's public, has an empty body, and takes no arguments.

UnnecessaryDoubleInstantiation.description=It is unnecessary to instantiate Double objects. Instead just use the double literal or the 'D' identifier to force the type, such as 123.45d or 0.42d.
UnnecessaryDoubleInstantiation.description.html=It is unnecessary to instantiate Double objects. Instead just use the double literal or the 'D' identifier to force the type, such as 123.45d or 0.42d.

UnnecessaryFloatInstantiation.description=It is unnecessary to instantiate Float objects. Instead just use the float literal with the 'F' identifier to force the type, such as 123.45F or 0.42f.
UnnecessaryFloatInstantiation.description.html=It is unnecessary to instantiate Float objects. Instead just use the float literal with the 'F' identifier to force the type, such as 123.45F or 0.42f.

UnnecessaryGetter.description=Checks for explicit calls to getter/accessor methods which can, for the most part, be replaced by property access. A getter is defined as a method call that matches get[A-Z] but not getClass() or get[A-Z][A-Z] such as getURL(). Getters do not take method arguments.
UnnecessaryGetter.description.html=Checks for explicit calls to getter/accessor methods which can, for the most part, be replaced by property access. A getter is defined as a method call that matches get[A-Z] but not getClass() or get[A-Z][A-Z] such as getURL(). Getters do not take method arguments.

UnnecessaryIfStatement.description=Checks for if statements where the if and else blocks (or subsequent fall-through to a return), are merely returning true and false constants. These cases can be replaced by a simple return statement.
UnnecessaryIfStatement.description.html=Checks for <em>if</em> statements where the if and else blocks (or subsequent fall-through to a <em>return</em>) are merely returning <em>true</em> and <em>false</em> constants. These cases can be replaced by a simple return statement.

UnnecessaryNullCheck.description=Groovy contains the safe dereference operator, which can be used in boolean conditional statements to safely replace explicit "x == null" tests.
UnnecessaryNullCheck.description.html=Groovy contains the safe dereference operator, which can be used in boolean conditional statements to safely replace explicit "x == null" tests.

UnnecessaryNullCheckBeforeInstanceOf.description=There is no need to check for null before an instanceof; the instanceof keyword returns false when given a null argument.
UnnecessaryNullCheckBeforeInstanceOf.description.html=There is no need to check for null before an instanceof; the instanceof keyword returns false when given a null argument.

UnnecessaryObjectReferences.description=Violations are triggered when an excessive set of consecutive statements all reference the same variable. This can be made more readable by using a with or identity block.
UnnecessaryObjectReferences.description.html=Violations are triggered when an excessive set of consecutive statements all reference the same variable. This can be made more readable by using a with or identity block.

UnnecessaryTernaryExpression.description=Checks for ternary expressions where the conditional expression always evaluates to a boolean and the true and false expressions are merely returning true and false constants. Also checks for ternary expressions where both expressions are the same constant or variable.
UnnecessaryTernaryExpression.description.html=Checks for ternary expressions where the conditional expression always evaluates to a boolean and the true and false expressions are merely returning <em>true</em> and <em>false</em> constants. Also checks for ternary expressions where both expressions are the same constant or variable.

UnnecessaryReturnKeyword.description=In Groovy, the return keyword is often optional. If a statement is the last line in a method or closure then you do not need to have the return keyword.
UnnecessaryReturnKeyword.description.html=In Groovy, the return <em>keyword</em> is often optional. If a statement is the last line in a method or closure then you do not need to have the <em>return</em> keyword.

UnnecessaryIntegerInstantiation.description=It is unnecessary to instantiate Integer objects. Instead just use the literal with the 'I' identifier to force the type, such as 8I or 42i.
UnnecessaryIntegerInstantiation.description.html=It is unnecessary to instantiate Integer objects. Instead just use the literal with the 'I' identifier to force the type, such as 8I or 42i.

UnnecessaryLongInstantiation.description=It is unnecessary to instantiate Long objects. Instead just use the literal with the 'L' identifier to force the type, such as 8L or 42L.
UnnecessaryLongInstantiation.description.html=It is unnecessary to instantiate Long objects. Instead just use the literal with the 'L' identifier to force the type, such as 8L or 42L.

UnnecessaryOverridingMethod.description=The overriding method merely calls the same method defined in a superclass
UnnecessaryOverridingMethod.description.html=The overriding method merely calls the same method defined in a superclass

UnnecessaryCollectionCall.description=Useless call to collections. This call doesn't make sense. For any collection c, calling c.containsAll(c) should always be true, and c.retainAll(c) should have no effect.
UnnecessaryCollectionCall.description.html=Useless call to collections. This call doesn't make sense. For any collection c, calling <em>c.containsAll(c)</em> should always be true, and <em>c.retainAll(c)</em> should have no effect.

UnnecessaryCatchBlock.description=Violations are triggered when a catch block does nothing but throw the original exception. In this scenario there is usually no need for a catch block, just let the exception be thrown from the original code. This condition frequently occurs when catching an exception for debugging purposes but then forgetting to take the catch statement out.
UnnecessaryCatchBlock.description.html=Violations are triggered when a catch block does nothing but throw the original exception. In this scenario there is usually no need for a catch block, just let the exception be thrown from the original code. This condition frequently occurs when catching an exception for debugging purposes but then forgetting to take the catch statement out.

UnnecessaryCollectCall.description=Some method calls to Object.collect(Closure) can be replaced with the spread operator. For instance, list.collect { it.multiply(2) } can be replaced by list*.multiply(2). Warning: if a collection is null, collect will return an empty list, while *. will return null.
UnnecessaryCollectCall.description.html=Some method calls to Object.collect(Closure) can be replaced with the spread operator. For instance, list.collect { it.multiply(2) } can be replaced by list*.multiply(2). Warning: if a collection is null, collect will return an empty list, while *. will return null.

UnnecessaryStringInstantiation.description=Use a String literal (e.g., "...") instead of calling the corresponding String constructor (new String("..")) directly.
UnnecessaryStringInstantiation.description.html=Use a String literal (e.g., "...") instead of calling the corresponding String constructor (new String("..")) directly.

UnnecessaryElseStatement.description=When an if statement block ends with a return statement the else is unnecessary. The logic in the else branch can be run without being in a new scope.
UnnecessaryElseStatement.description.html=When an if statement block ends with a return statement the else is unnecessary. The logic in the else branch can be run without being in a new scope.

UnnecessaryParenthesesForMethodCallWithClosure.description=If a method is called and the only parameter to that method is an inline closure then the parentheses of the method call can be omitted.
UnnecessaryParenthesesForMethodCallWithClosure.description.html=If a method is called and the only parameter to that method is an inline closure then the parentheses of the method call can be omitted.

UnusedArray.description=Checks for array allocations that are not assigned or used, unless it is the last statement within a block.
UnusedArray.description.html=Checks for array allocations that are not assigned or used, unless it is the last statement within a block.

UnusedObject.description=Checks for object allocations that are not assigned or used, unless it is the last statement within a block.
UnusedObject.description.html=Checks for object allocations that are not assigned or used, unless it is the last statement within a block

UnusedPrivateField.description=Checks for private fields that are not referenced within the same class.
UnusedPrivateField.description.html=Checks for private fields that are not referenced within the same class.

UnusedPrivateMethod.description=Checks for private methods that are not referenced within the same class.
UnusedPrivateMethod.description.html=Checks for private methods that are not referenced within the same class.

UnusedPrivateMethodParameter.description=Checks for parameters to private methods that are not referenced within the method body.
UnusedPrivateMethodParameter.description.html=Checks for parameters to private methods that are not referenced within the method body.

UnusedVariable.description=Checks for variables that are never referenced. The ignoreVariableNames property (${rule.ignoreVariableNames}) specifies one or more variable names that should be ignored, optionally containing wildcard characters ('*' or '?').
UnusedVariable.description.html=Checks for variables that are never referenced. The <em>ignoreVariableNames</em> property (${rule.ignoreVariableNames}) specifies one or more variable names that should be ignored, optionally containing wildcard characters ('*' or '?').

WaitOutsideOfWhileLoop.description=Calls to Object.wait() must be within a while loop. Consider using the Java concurrency utilities instead of wait() and notify().
WaitOutsideOfWhileLoop.description.html=Calls to <em>Object.wait()</em> must be within a <em>while</em> loop. Consider using the Java concurrency utilities instead of <em>wait()</em> and <em>notify()</em>.

SwallowThreadDeath.description=Checks for code that catches ThreadDeath without re-throwing it.
SwallowThreadDeath.description.html=Checks for code that catches ThreadDeath without re-throwing it.

StatelessSingleton.description=There is no point in creating a stateless Singleton because there is nothing within the class that needs guarding and no side effects to calling the constructor. Just create new instances of the object or write a Utility class with static methods.
StatelessSingleton.description.html=There is no point in creating a stateless Singleton because there is nothing within the class that needs guarding and no side effects to calling the constructor. Just create new instances of the object or write a Utility class with static methods.

PrivateFieldCouldBeFinal.description=Checks for private fields that are only set within a constructor or field initializer. Such fields can safely be made final.
PrivateFieldCouldBeFinal.description.html=Checks for <em>private</em> fields that are only set within a constructor or field initializer. Such fields can safely be made <em>final</em>.

ParameterReassignment.description=Checks for a method or closure parameter being reassigned to a new value within the body of the method/closure, which is a confusing and questionable practice. Use a temporary variable instead.
ParameterReassignment.description.html=Checks for a method or closure parameter being reassigned to a new value within the body of the method/closure, which is a confusing and questionable practice. Use a temporary variable instead.

TernaryCouldBeElvis.description=Checks for ternary expressions where the boolean and true expressions are the same. These can be simplified to an Elvis expression.
TernaryCouldBeElvis.description.html=Checks for ternary expressions where the boolean and true expressions are the same. These can be simplified to an Elvis expression.

AssertWithinFinallyBlock.description=Checks for assert statements within a finally block. An assert can throw an exception, hiding the original exception, if there is one.
AssertWithinFinallyBlock.description.html=Checks for <em>assert</em> statements within a <em>finally</em> block. An <em>assert</em> can throw an exception, hiding the original exception, if there is one.

ConstantAssertExpression.description=Checks for assert statements where the assert boolean condition expression is a constant or literal value.
ConstantAssertExpression.description.html=Checks for <em>assert</em> statements where the assert boolean condition expression is a constant or literal value.

BrokenNullCheck.description=Looks for faulty checks for null that can cause a NullPointerException.
BrokenNullCheck.description.html=Looks for faulty checks for null that can cause a <em>NullPointerException</em>.

VectorIsObsolete.description=The java.util.Vector class is effectively obsolete. Use the Java Collections Framework classes instead, including ArrayList or Collections.synchronizedList(). See the JDK javadoc.
VectorIsObsolete.description.html=The <em>java.util.Vector</em> class is effectively obsolete. Use the <em>Java Collections Framework</em> classes instead, including <em>ArrayList</em> or <em>Collections.synchronizedList()</em>. See the JDK javadoc.

HashtableIsObsolete.description=The java.util.Hashtable class is effectively obsolete. Use the Java Collections Framework classes instead, including HashMap or ConcurrentHashMap. See the JDK javadoc.
HashtableIsObsolete.description.html=The <em>java.util.Hashtable</em> class is effectively obsolete. Use the <em>Java Collections Framework</em> classes instead, including <em>HashMap</em> or <em>ConcurrentHashMap</em>. See the JDK javadoc.

CrapMetric.description=Checks the CRAP (Change Risk Anti-Patterns) score for methods/classes. \
  The CRAP metric score is based on the cyclomatic complexity and test coverage for individual methods. \
  A method with a CRAP value greater than the maxMethodCrapScore \
  property (${rule.maxMethodCrapScore}) causes a violation. Likewise, a class that has an (average method) CRAP \
  value greater than the maxClassAverageMethodCrapScore property (${rule.maxClassAverageMethodCrapScore}) causes a violation.
CrapMetric.description.html=Checks the CRAP (Change Risk Anti-Patterns) score for methods/classes. \
  The CRAP metric score is based on the cyclomatic complexity and test coverage for individual methods. \
  A method with a CRAP value greater than the <em>maxMethodCrapScore</em> \
  property (${rule.maxMethodCrapScore}) causes a violation. Likewise, a class that has an (average method) CRAP \
  value greater than the <em>maxClassAverageMethodCrapScore</em> property (${rule.maxClassAverageMethodCrapScore}) causes a violation.

JUnitLostTest.description=Checks for classes that import JUnit 4 classes and contain a public, instance, void, no-arg method named test* that is not annotated with @Test.
JUnitLostTest.description.html=Checks for classes that import JUnit 4 classes and contain a public, instance, void, no-arg method named test* that is not annotated with @Test.

SpaceAfterComma.description=Checks that there is at least one space or whitespace following each comma. That includes checks for method and closure declaration parameter lists, method call parameter lists, Map literals and List literals.
SpaceAfterComma.description.html=Checks that there is at least one space or whitespace following each comma. That includes checks for method and closure declaration parameter lists, method call parameter lists, Map literals and List literals.

SpaceAfterSemicolon.description=Checks that there is at least one space or whitespace following each semicolon separating multiple statements on a single line or the clauses within a classic for loop.
SpaceAfterSemicolon.description.html=Checks that there is at least one space or whitespace following each semicolon separating multiple statements on a single line or the clauses within a classic for loop.

SpaceAroundOperator.description=Check that there is at least one space (blank) or whitespace around each binary operator.
SpaceAroundOperator.description.html=Check that there is at least one space (blank) or whitespace around each binary operator.

SpaceBeforeOpeningBrace.description=Check that there is at least one space (blank) or whitespace before each opening brace ("{") for method/class/interface declarations, closure expressions and block statements.
SpaceBeforeOpeningBrace.description.html=Check that there is at least one space (blank) or whitespace before each opening brace ("{") for method/class/interface declarations, closure expressions and block statements.

SpaceAfterOpeningBrace.description=Check that there is at least one space (blank) or whitespace after each opening brace ("{") for method/class/interface declarations, closure expressions and block statements.
SpaceAfterOpeningBrace.description.html=Check that there is at least one space (blank) or whitespace after each opening brace ("{") for method/class/interface declarations, closure expressions and block statements.

SpaceBeforeClosingBrace.description=Check that there is at least one space (blank) or whitespace before each closing brace ("}") for method/class/interface declarations, closure expressions and block statements.
SpaceBeforeClosingBrace.description.html=Check that there is at least one space (blank) or whitespace before each closing brace ("}") for method/class/interface declarations, closure expressions and block statements.

SpaceAfterClosingBrace.description=Check that there is at least one space (blank) or whitespace after each closing brace ("}") for method/class/interface declarations, closure expressions and block statements.
SpaceAfterClosingBrace.description.html=Check that there is at least one space (blank) or whitespace after each closing brace ("}") for method/class/interface declarations, closure expressions and block statements.

SpaceAfterIf.description=Check that there is exactly one space (blank) after the if keyword and before the opening parenthesis.
SpaceAfterIf.description.html=Check that there is exactly one space (blank) after the <em>if</em> keyword and before the opening parenthesis.

SpaceAfterFor.description=Check that there is exactly one space (blank) after the for keyword and before the opening parenthesis.
SpaceAfterFor.description.html=Check that there is exactly one space (blank) after the <em>for</em> keyword and before the opening parenthesis.

SpaceAfterWhile.description=Check that there is exactly one space (blank) after the while keyword and before the opening parenthesis.
SpaceAfterWhile.description.html=Check that there is exactly one space (blank) after the <em>while</em> keyword and before the opening parenthesis.

SpaceAfterSwitch.description=Check that there is exactly one space (blank) after the switch keyword and before the opening parenthesis.
SpaceAfterSwitch.description.html=Check that there is exactly one space (blank) after the <em>switch</em> keyword and before the opening parenthesis.

SpaceAfterCatch.description=Check that there is exactly one space (blank) after the catch keyword and before the opening parenthesis.
SpaceAfterCatch.description.html=Check that there is exactly one space (blank) after the <em>catch</em> keyword and before the opening parenthesis.

TrailingWhitespace.description=Checks that no lines of source code end with whitespace characters.
TrailingWhitespace.description.html=Checks that no lines of source code end with whitespace characters.

JUnitUnnecessaryThrowsException.description=Check for throws clauses on JUnit test methods. That is not necessary in Groovy.
JUnitUnnecessaryThrowsException.description.html=Check for <em>throws</em> clauses on JUnit test methods. That is not necessary in Groovy.

GrailsDuplicateMapping.description=Check for duplicate name in a domain class mapping
GrailsDuplicateMapping.description.html=Check for duplicate name in a domain class mapping

GrailsDuplicateConstraint.description=Check for duplicate entry in domain class constraints
GrailsDuplicateConstraint.description.html=Check for duplicate entry in domain class constraints

GrailsMassAssignment.description=Untrusted input should not be allowed to set arbitrary object fields without restriction.
GrailsMassAssignment.description.html=Untrusted input should not be allowed to set arbitrary object fields without restriction.

IfStatementCouldBeTernary.description=Checks for if statements where both the if and else blocks contain only a single return statement with a constant or literal value
IfStatementCouldBeTernary.description.html=Checks for <em>if</em> statements where both the <em>if</em> and <em>else</em> blocks contain only a single <em>return</em> statement with a constant or literal value

ExceptionNotThrown.description=Checks for an exception constructor call without a throw as the last statement within a catch block.
ExceptionNotThrown.description.html=Checks for an exception constructor call without a <em>throw</em> as the last statement within a catch block.

NoDef.description=def should not be used. You should replace it with concrete type.
NoDef.description.html=<em>def</em> should not be used. You should replace it with concrete type.

#-----------------------------------------------------------------------------------------
# Report labels, etc.
#-----------------------------------------------------------------------------------------
htmlReport.titlePrefix=CodeNarc Report
htmlReport.reportTimestamp.label=Date:
htmlReport.reportTitle.title=Report title:
htmlReport.reportVersion.label=Generated with:
htmlReport.summary.title=Summary
htmlReport.summary.packageHeading=Package
htmlReport.summary.totalFilesHeading=Total Files
htmlReport.summary.filesWithViolationsHeading=Files with Violations
htmlReport.summary.priority1Heading=Priority 1
htmlReport.summary.priority2Heading=Priority 2
htmlReport.summary.priority3Heading=Priority 3
htmlReport.summary.priority4Heading=Priority 4
htmlReport.summary.allPackages=All Packages
htmlReport.violations.ruleName=Rule Name
htmlReport.violations.priority=Priority
htmlReport.violations.lineNumber=Line #
htmlReport.violations.sourceLine=Source Line / Message
htmlReport.ruleDescriptions.title=Rule Descriptions
htmlReport.ruleDescriptions.ruleNameHeading=Rule Name
htmlReport.ruleDescriptions.descriptionHeading=Description
