cast.to.concrete.class.display.name=Cast to a concrete class
cast.to.concrete.class.problem.descriptor=Cast to concrete class {0} #loc
class.references.subclass.display.name=Class references one of its subclasses
class.references.subclass.problem.descriptor=Class ''{0}'' references subclass #ref #loc
class.references.subclass.problem.descriptor.anonymous=Anonymous class references subclass #ref #loc
collection.declared.by.class.display.name=Collection declared by class, not interface
collection.declared.by.class.problem.descriptor=Declaration of #ref should probably be weakened to ''{0}'' #loc
collection.declared.by.class.ignore.locals.option=Ignore local variables
collection.declared.by.class.ignore.private.members.option=Ignore private fields and methods
feature.envy.display.name=Feature envy
feature.envy.problem.descriptor=Class ''{0}'' accessed repeatedly in method #ref() #loc
instance.variable.of.concrete.class.display.name=Type of instance field is concrete class
instance.variable.of.concrete.class.problem.descriptor=Type of field ''{0}'' is concrete class #ref #loc
chain.of.instanceof.checks.display.name=Chain of 'instanceof' checks
chain.of.instanceof.checks.problem.descriptor=Chain of 'instanceof' checks indicates abstraction failure #loc
instanceof.concrete.class.display.name='instanceof' a concrete class
instanceof.concrete.class.problem.descriptor='instanceof' concrete class #ref #loc
instanceof.check.for.this.display.name='instanceof' check for 'this'
instanceof.check.for.this.problem.descriptor='instanceof' check for #ref #loc
local.variable.of.concrete.class.display.name=Local variable of concrete class
local.variable.of.concrete.class.problem.descriptor=Local variable ''{0}'' of concrete class #ref #loc
magic.number.display.name=Magic number
magic.number.problem.descriptor=Magic number #ref #loc
magic.number.ignore.option=Ignore constants in 'hashCode()' methods
method.return.concrete.class.display.name=Method return of concrete class
method.return.concrete.class.problem.descriptor=Method returns a concrete class #ref #loc
overly.strong.type.cast.display.name=Overly strong type cast
overly.strong.type.cast.weaken.quickfix=Weaken overly strong cast
concrete.class.method.parameter.display.name=Method parameter of concrete class
concrete.class.method.parameter.problem.descriptor=Parameter ''{0}'' of concrete class #ref #loc
public.method.not.in.interface.display.name='public' method not exposed in interface
public.method.not.in.interface.problem.descriptor='public' method #ref() is not exposed via an interface #loc
public.method.not.in.interface.option=Ignore if the containing class does not implement a non-library interface
static.variable.of.concrete.class.display.name=Static field of concrete class
static.variable.of.concrete.class.problem.descriptor=Static field ''{0}'' of concrete class #ref #loc
incompatible.mask.operation.display.name=Incompatible bitwise mask operation
incompatible.mask.operation.problem.descriptor.always.false=#ref is always false #loc
incompatible.mask.operation.problem.descriptor.always.true=#ref is always true #loc
pointless.bitwise.expression.display.name=Pointless bitwise expression
pointless.bitwise.expression.simplify.quickfix=Simplify
shift.operation.by.inappropriate.constant.display.name=Shift operation by inappropriate constant
shift.operation.by.inappropriate.constant.problem.descriptor.too.large=Shift operation #ref by overly large constant value #loc
shift.operation.by.inappropriate.constant.problem.descriptor.negative=Shift operation #ref by negative constant value #loc
equals.called.on.array.display.name='equals()' called on array
equals.called.on.array.problem.descriptor=#ref() between arrays should probably be 'Arrays.equals()' #loc
replace.with.arrays.equals=Replace with 'Arrays.equals()'
replace.with.arrays.deep.equals=Replace with 'Arrays.deepEquals()'
assignment.to.null.display.name=Assignment to 'null'
assignment.to.null.problem.descriptor=Assignment of variable #ref to 'null' #loc
assignment.to.null.option=Ignore assignments to fields
assignment.to.static.field.from.instance.method.display.name=Assignment to static field from instance method
assignment.to.static.field.from.instance.method.problem.descriptor=Assignment to static field #ref from an instance method #loc
assignment.used.as.condition.display.name=Assignment used as condition
assignment.used.as.condition.problem.descriptor=#ref used as condition #loc
assignment.used.as.condition.replace.quickfix=Replace '=' with '=='
cast.conflicts.with.instanceof.display.name=Cast conflicts with 'instanceof'
cast.conflicts.with.instanceof.problem.descriptor=Cast #ref conflicts with surrounding 'instanceof' check #loc
casting.to.incompatible.interface.display.name=Casting to incompatible interface
casting.to.incompatible.interface.problem.descriptor=Cast to incompatible interface #ref #loc
collection.added.to.self.display.name=Collection added to self
collection.added.to.self.problem.descriptor=''{0}()'' called on collection #ref with itself as argument #loc
non.final.field.compareto.display.name=Non-final field referenced in 'compareTo()'
non.final.field.compareto.problem.descriptor=Non-final field #ref accessed in 'compareTo()' #loc
covariant.compareto.display.name=Covariant 'compareTo()'
covariant.compareto.problem.descriptor=#ref() should take 'Object' as its argument #loc
covariant.equals.display.name=Covariant 'equals()'
covariant.equals.problem.descriptor=#ref() should take 'Object' as its argument #loc
empty.class.initializer.display.name=Empty class initializer
empty.class.initializer.problem.descriptor=Empty class initializer #loc
empty.class.initializer.delete.quickfix=Delete empty class initializer
statement.with.empty.body.display.name=Statement with empty body
statement.with.empty.body.problem.descriptor=#ref statement has empty body #loc
statement.with.empty.body.include.option=Include statement bodies that are empty code blocks
equals.between.inconvertible.types.display.name='equals()' between objects of inconvertible types
equals.between.inconvertible.types.problem.descriptor=#ref() between objects of inconvertible types ''{0}'' and ''{1}'' #loc
non.final.field.in.equals.display.name=Non-final field referenced in 'equals()'
non.final.field.in.equals.problem.descriptor=Non-final field #ref accessed in 'equals()' #loc
equals.doesnt.check.class.parameter.display.name='equals()' method which does not check class of parameter
equals.doesnt.check.class.parameter.problem.descriptor=#ref() should check the class of its parameter #loc
for.loop.not.use.loop.variable.display.name='for' loop where update or condition does not use loop variable
for.loop.not.use.loop.variable.problem.descriptor.condition=#ref statement has condition which does not use the for loop variable #loc
for.loop.not.use.loop.variable.problem.descriptor.update=#ref statement has update which does not use the for loop variable #loc
for.loop.not.use.loop.variable.problem.descriptor.both.condition.and.update=#ref statement has condition and update which do not use the for loop variable #loc
non.final.field.in.hashcode.display.name=Non-final field referenced in 'hashCode()'
non.final.field.in.hashcode.problem.descriptor=Non-final field #ref accessed in 'hashCode()' #loc
result.of.method.call.ignored.display.name=Result of method call ignored
result.of.method.call.ignored.problem.descriptor=Result of {0}.#ref() is ignored #loc
result.of.method.call.ignored.class.column.title=Class name
result.of.method.call.ignored.method.column.title=Method name
result.of.method.call.ignored.non.library.option=Report all ignored non-library calls
infinite.recursion.display.name=Infinite recursion
infinite.recursion.problem.descriptor=Method #ref() recurses infinitely, and can only end by throwing an exception #loc
instanceof.with.incompatible.interface.display.name='instanceof' with incompatible interface
instanceof.with.incompatible.interface.problem.descriptor='instanceof' incompatible interface #ref #loc
instantiation.utility.class.display.name=Instantiation of utility class
instantiation.utility.class.problem.descriptor=Instantiation of utility class #ref #loc
iterator.hasnext.which.calls.next.display.name='Iterator.hasNext()' which calls 'next()'
iterator.hasnext.which.calls.next.problem.descriptor=Iterator.#ref() contains call to 'next()' #loc
iterator.next.does.not.throw.nosuchelementexception.display.name='Iterator.next()' which can't throw 'NoSuchElementException'
malformed.format.string.display.name=Malformed format string
malformed.format.string.problem.descriptor.malformed=Format string #ref is malformed #loc
malformed.format.string.problem.descriptor.too.many.arguments=Too many arguments for format string #ref #loc
malformed.format.string.problem.descriptor.too.few.arguments=Too few arguments for format string #ref #loc
malformed.format.string.problem.descriptor.arguments.do.not.match.type=Format string #ref does not match the type of its arguments #loc
malformed.regular.expression.display.name=Malformed regular expression
malformed.regular.expression.problem.descriptor1=Regular expression #ref is malformed #loc
malformed.regular.expression.problem.descriptor2=Regular expression #ref is malformed: {0} #loc
malformed.xpath.expression.display.name=Malformed XPath expression
malformed.xpath.expression.problem.description=XPath expression #ref is malformed #loc
mismatched.read.write.array.display.name=Mismatched read and write of array
mismatched.read.write.array.problem.descriptor.write.not.read=Contents of array #ref are written to, but never read #loc
mismatched.read.write.array.problem.descriptor.read.not.write=Contents of array #ref are read, but never written to #loc
mismatched.update.collection.display.name=Mismatched query and update of collection
mismatched.update.collection.problem.descriptor.updated.not.queried=Contents of collection #ref are updated, but never queried #loc
mismatched.update.collection.problem.description.queried.not.updated=Contents of collection #ref are queried, but never updated #loc
misspelled.compareto.display.name='compareto()' instead of 'compareTo()'
misspelled.compareto.problem.descriptor=#ref() method should probably be 'compareTo()' #loc
rename.quickfix=Rename
renameto.quickfix=Rename to ''{0}''
misspelled.equals.display.name='equal()' instead of 'equals()'
misspelled.equals.problem.descriptor=#ref() method should probably be 'equals()' #loc
misspelled.hashcode.display.name='hashcode()' instead of 'hashCode()'
misspelled.hashcode.problem.descriptor=#ref() should probably be 'hashCode()' #loc
misspelled.tostring.display.name='tostring()' instead of 'toString()'
misspelled.tostring.problem.descriptor=#ref() method should probably be 'toString()' #loc
non.short.circuit.boolean.expression.display.name=Non-short-circuit boolean expression
non.short.circuit.boolean.expression.problem.descriptor=Non-short-circuit boolean expression #ref #loc
non.short.circuit.boolean.expression.replace.quickfix=Replace with short circuit expression
null.argument.to.var.arg.method.display.name=Confusing 'null' argument to var-arg method
null.argument.to.var.arg.method.problem.descriptor=Confusing #ref argument to var-arg method #loc
primitive.array.argument.to.var.arg.method.display.name=Confusing primitive array argument to var-arg method
primitive.array.argument.to.var.arg.method.problem.descriptor=Confusing primitive array argument to var-arg method #loc
object.comparison.display.name=Object comparison using '==', instead of 'equals()'
object.comparison.enumerated.ignore.option=Ignore '==' between enumerated types
object.comparison.klass.ignore.option=Ignore '==' on 'java.lang.Class' objects
object.comparison.problem.description=Object values are compared using #ref, not 'equals()' #loc
object.comparison.replace.quickfix=Replace with 'equals()'
object.equals.null.problem.descriptor=.equals(#ref) is probably not what was intended #loc
default.tostring.call.display.name=Call to default 'toString()'
default.tostring.call.problem.descriptor=Call to default 'toString()' on #ref #loc
octal.and.decimal.integers.in.same.array.display.name=Octal and decimal integers in same array
octal.and.decimal.integers.in.same.array.problem.descriptor=Octal and decimal integers in the same array initializer #loc
result.of.object.allocation.ignored.display.name=Result of object allocation ignored
result.of.object.allocation.ignored.problem.descriptor=Result of new #ref() is ignored #loc
use.0index.in.jdbc.resultset.display.name=Use of index 0 in JDBC ResultSet
use.0index.in.jdbc.resultset.problem.descriptor=Use of index '0' in JDBC ResultSet #loc
use.0index.in.jdbc.prepared.statement.problem.descriptor=Use of index '0' in JDBC PreparedStatement #loc
return.of.null.display.name=Return of 'null'
return.of.null.problem.descriptor=Return of #ref #loc
return.of.null.arrays.option=Report methods that return arrays
return.of.null.quickfix=Annotate method as @Nullable
return.of.null.objects.option=Report methods that return objects
return.of.null.collections.option=Report methods that return collection objects
return.of.null.ignore.private.option=Ignore private methods
static.method.via.subclass.display.name=Static method referenced via subclass
static.method.via.subclass.problem.descriptor=Static method #ref() declared in class ''{0}'' but referenced via subclass ''{1}'' #loc
static.method.via.subclass.rationalize.quickfix=Rationalize static method call
static.field.via.subclass.display.name=Static field referenced via subclass
static.field.via.subclass.problem.descriptor=Static field #ref declared in class ''{0}'' but referenced via subclass ''{1}'' #loc
static.field.via.subclass.rationalize.quickfix=Rationalize static field access
string.comparison.display.name=String comparison using '==', instead of 'equals()'
number.comparison.display.name=Number comparison using '==', instead of 'equals()'
string.comparison.problem.descriptor=String values are compared using #ref, not 'equals()' #loc
number.comparison.problem.descriptor=Number objects are compared using #ref, not 'equals()' #loc
subtraction.in.compareto.display.name=Subtraction in 'compareTo()'
subtraction.in.compareto.problem.descriptor=Subtraction #ref in 'compareTo()' may result in overflow errors #loc
text.label.in.switch.statement.display.name=Text label in 'switch' statement
text.label.in.switch.statement.problem.descriptor=Text label #ref: in 'switch' statement #loc
properties.object.as.hashtable.display.name=Use of Properties object as a Hashtable
properties.object.as.hashtable.problem.descriptor=Call to Hashtable.#ref() on properties object #loc
assignment.replaceable.with.operator.assignment.display.name=Assignment replaceable with operator assignment
unnecessary.code.block.display.name=Unnecessary code block
unnecessary.code.block.unwrap.quickfix=Unwrap block
redundant.local.variable.display.name=Redundant local variable
redundant.local.variable.ignore.option=Ignore immediately returned or thrown variables
redundant.local.variable.annotation.option=Ignore variables which have an annotation
static.collection.display.name=Static collection
static.collection.problem.descriptor=Static collection #ref #loc
static.collection.ignore.option=Ignore weak static collections or maps
stringbuffer.field.display.name=StringBuffer field
stringbuffer.field.problem.descriptor=''{0}'' field #ref #loc
gc.call.display.name=Calls to 'System.gc()' or 'Runtime.gc()'
gc.call.problem.descriptor=#ref should not be called in production code #loc
array.allocation.zero.length.display.name=Zero-length array allocation
array.allocation.zero.length.problem.descriptor=Allocation of zero length array #loc
multiple.loggers.display.name=Class with multiple loggers
logger.name.option=Logger &class name:
multiple.loggers.problem.descriptor=Class #ref declares multiple loggers #loc
no.logger.display.name=Class without logger
no.logger.problem.descriptor=Class #ref does not declare a logger #loc
non.constant.logger.display.name=Non-constant logger
non.constant.logger.problem.descriptor=Non-constant logger field #ref #loc
public.method.without.logging.display.name='public' method without logging
public.method.without.logging.problem.descriptor='public' method #ref() has no logging call #loc
action.reset.telemetry.description=Reset telemetry data
telemetry.table.column.inspection.name=Inspection
telemetry.table.column.total.time=Total Run Time (ms)
telemetry.table.column.average.time=Average Run Time (ms)
telemetry.table.column.run.count=Run Count
telemetry.toolwindow.title=IG Telemetry
action.telemetry.refresh.description=Refresh telemetry display
finalize.doesnt.call.super.display.name='finalize()' does not call 'super.finalize()'
finalize.doesnt.call.super.ignore.option=Ignore for direct subclasses of 'java.lang.Object'
ignore.trivial.finalizers.option=Ignore for trivial 'finalize()' implementations
finalize.doesnt.call.super.problem.descriptor=#ref() #loc does not call 'super.finalize()'
finalize.declaration.display.name='finalize()' declaration
finalize.declaration.problem.descriptor=#ref() declared #loc
finalize.not.declared.protected.display.name='finalize()' not declared 'protected'
finalize.not.declared.protected.problem.descriptor=#ref() not declared 'protected' #loc
make.protected.quickfix=Make 'protected'
finalize.called.explicitly.display.name='finalize()' called explicitly
finalize.called.explicitly.problem.descriptor=#ref() called explicitly #loc
java.lang.import.display.name='java.lang' import
java.lang.import.problem.descriptor=Unnecessary import from package 'java.lang' #loc
import.display.name='*' import
import.problem.descriptor=Package import #ref #loc
redundant.import.display.name=Redundant import
redundant.import.problem.descriptor=Redundant import #ref #loc
import.from.same.package.display.name=Import from same package
import.from.same.package.problem.descriptor=Unnecessary import from same package #ref #loc
single.class.import.display.name=Single class import
single.class.import.problem.descriptor=Single class import #ref #loc
static.import.display.name=Static import
static.import.problem.descriptor=Static import #ref #loc
static.import.replace.quickfix=Replace with non-static import
unused.import.display.name=Unused import
unused.import.problem.descriptor=Unused import #ref #loc
clone.instantiates.objects.with.constructor.display.name='clone()' instantiates objects with constructor
clone.instantiates.objects.with.constructor.problem.descriptor='clone()' creates new #ref instances #loc
clone.doesnt.call.super.clone.display.name='clone()' does not call 'super.clone()'
clone.doesnt.call.super.clone.problem.descriptor=#ref() does not call 'super.clone()' #loc
clone.doesnt.declare.clonenotsupportedexception.display.name='clone()' does not declare 'CloneNotSupportedException'
clone.doesnt.declare.clonenotsupportedexception.problem.descriptor=#ref() #loc does not declare 'CloneNotSupportedException'
clone.doesnt.declare.clonenotsupportedexception.declare.quickfix=Declare 'CloneNotSupportedException'
clone.method.in.non.cloneable.class.display.name='clone()' method in non-Cloneable class
clone.method.in.non.cloneable.class.problem.descriptor=#ref() defined in non-Cloneable class ''{0}'' #loc
clone.method.in.non.cloneable.interface.problem.descriptor=#ref() defined in non-Cloneable interface ''{0}'' #loc
cloneable.class.without.clone.display.name=Cloneable class without 'clone()'
cloneable.class.without.clone.problem.descriptor=#ref does not define 'clone()' #loc
cloneable.class.without.clone.ignore.option=Ignore classes cloneable due to inheritance
cloneable.class.without.clone.quickfix=Generate 'clone()' method
class.without.tostring.display.name=Class without 'toString()'
class.without.tostring.problem.descriptor=Class #ref should probably implement 'toString()', for debugging purposes #loc
use.obsolete.collection.type.display.name=Use of obsolete collection type
use.obsolete.collection.type.problem.descriptor=Obsolete collection type #ref used #loc
use.obsolete.collection.type.ignore.library.arguments.option=Ignore obsolete collection types where they are required
inspection.suppression.annotation.display.name=Inspection suppression annotation
inspection.suppression.annotation.problem.descriptor=Inspection suppression annotation #ref #loc
use.system.out.err.display.name=Use of System.out or System.err
use.system.out.err.problem.descriptor=Uses of #ref should probably be replaced with more robust logging #loc
dumpstack.call.display.name=Call to 'Thread.dumpStack()'
dumpstack.call.problem.descriptor=Call to Thread.#ref() should probably be replaced with more robust logging #loc
printstacktrace.call.display.name=Call to 'printStackTrace()'
printstacktrace.call.problem.descriptor=Call to #ref() should probably be replaced with more robust logging #loc
todo.comment.display.name=TODO comment
todo.comment.problem.descriptor=TODO comment #ref #loc
abstract.method.call.in.constructor.display.name=Abstract method called during object construction
abstract.method.call.in.constructor.problem.descriptor=Call to 'abstract' method #ref() during object construction #loc
instance.variable.may.not.be.initialized.display.name=Instance field may not be initialized
instance.variable.may.not.be.initialized.problem.descriptor=Instance field #ref may not be initialized during object construction #loc
instance.Variable.may.not.be.initialized.problem.descriptor.junit=Instance field #ref may not be initialized during object construction or 'setUp()' call #loc
primitive.fields.ignore.option=Ignore primitive fields
instance.variable.used.before.initialized.display.name=Instance field used before initialization
instance.variable.used.before.initialized.problem.descriptor=Instance field #ref used before initialized #loc
non.final.static.variable.initialization.display.name=Non-final static field is used during class initialization
non.final.static.variable.initialization.problem.descriptor=Non-final static field #ref used during class initialization #loc
overridable.method.call.in.constructor.display.name=Overridable method called during object construction
overridable.method.call.in.constructor.problem.descriptor=Call to overridable method #ref() during object construction #loc
overridden.method.call.in.constructor.display.name=Overridden method called during object construction
overridden.method.call.in.constructor.problem.descriptor=Call to overridden method #ref() during object construction #loc
static.variable.may.not.be.initialized.display.name=Static field may not be initialized
static.variable.may.not.be.initialized.problem.descriptor=Static field #ref may not be initialized during class initialization #loc
static.variable.used.before.initialization.display.name=Static field used before initialization
static.variable.used.before.initialization.problem.descriptor=Static field #ref used before initialization #loc
this.reference.escaped.in.construction.display.name='this' reference escaped in object construction
this.reference.escaped.in.construction.problem.descriptor=Escape of #ref during object construction #loc
assignment.to.catch.block.parameter.display.name=Assignment to catch block parameter
extract.parameter.as.local.variable.quickfix=Extract parameter as local variable
assignment.to.for.loop.parameter.display.name=Assignment to 'for' loop parameter
assignment.to.for.loop.parameter.check.foreach.option=Check foreach parameters
assignment.to.for.loop.parameter.problem.descriptor=Assignment to for-loop parameter #ref #loc
assignment.to.method.parameter.display.name=Assignment to method parameter
chained.equality.comparisons.display.name=Chained equality comparisons
confusing.octal.escape.sequence.display.name=Confusing octal escape sequence
increment.decrement.display.name=Value of ++ or -- used
nested.assignment.display.name=Result of assignment used
nested.assignment.problem.descriptor=Result of assignment expression used #loc
overloaded.methods.with.same.number.parameters.display.name=Overloaded methods with same number of parameters
overloaded.vararg.method.display.name=Overloaded variable argument method
refused.bequest.display.name=Refused bequest
reuse.of.local.variable.display.name=Reuse of local variable
reuse.of.local.variable.split.quickfix=Split local variable
character.comparison.display.name=Character comparison
character.comparison.problem.descriptor=Character comparison #ref in an internationalized context #loc
assignment.collection.array.field.from.parameter.display.name=Assignment to Collection or array field from parameter
assignment.collection.array.field.from.parameter.problem.descriptor.array=Assignment to array field #ref from parameter ''{0}'' #loc
assignment.collection.array.field.from.parameter.problem.descriptor.collection=Assignment to Collection field #ref from parameter ''{0}'' #loc
assignment.collection.array.field.option=Ignore assignments in private methods
assignment.to.date.calendar.field.from.parameter.display.name=Assignment to Date or Calendar field from parameter
assignment.to.date.calendar.field.from.parameter.problem.descriptor=Assignment to ''{0}'' field #ref from parameter {1} #loc
package.visible.field.display.name=Package-visible field
package.visible.field.problem.descriptor=Package-visible field #ref #loc
package.visible.inner.class.display.name=Package-visible inner class
package.visible.inner.class.problem.descriptor=Package-visible inner class #ref #loc
package.visible.inner.class.ignore.enum.option=Ignore package-visible inner enums
package.visible.inner.class.ignore.interface.option=Ignore package-visible inner interfaces
protected.field.display.name=Protected field
protected.field.problem.descriptor=Protected field #ref #loc
protected.inner.class.display.name=Protected inner class
protected.inner.class.problem.descriptor=Protected inner class #ref #loc
protected.inner.class.ignore.enum.option=Ignore 'protected' inner enums
protected.inner.class.ignore.interface.option=Ignore 'protected' inner interfaces
public.field.display.name='public' field
public.field.problem.descriptor='public' field #ref #loc
public.field.ignore.enum.type.fields.option=Ignore 'public final' fields of an enum type
public.inner.class.display.name='public' inner class
public.inner.class.problem.descriptor='public' inner class #ref #loc
public.inner.class.ignore.enum.option=Ignore 'public' inner enums
public.inner.class.ignore.interface.option=Ignore 'public' inner interfaces
return.of.collection.array.field.display.name=Return of Collection or array field
return.of.collection.array.field.problem.descriptor.array='return' of array field #ref #loc
return.of.collection.array.field.problem.descriptor.collection='return' of Collection field #ref #loc
return.of.collection.array.field.option=Ignore private methods returning an array or collection field
return.date.calendar.field.display.name=Return of Date or Calendar field
return.date.calendar.field.problem.descriptor=Return of ''{0}'' field #ref #loc
return.date.calendar.field.quickfix=Return clone of ''{0}''
accessing.non.public.field.of.another.object.display.name=Accessing a non-public field of another object
accessing.non.public.field.of.another.object.problem.descriptor=Direct access of non-public field #ref on another object #loc
call.to.date.tostring.display.name=Call to 'Date.toString()'
call.to.date.tostring.problem.descriptor=Date.#ref() used in an internationalized context #loc
magic.character.display.name=Magic character
magic.character.problem.descriptor=Magic character #ref in an internationalized context #loc
call.to.numeric.tostring.display.name=Call to Numeric 'toString()'
call.to.numeric.tostring.problem.descriptor=Numeric #ref() called in an internationalized context #loc
instantiating.simpledateformat.without.locale.display.name=Instantiating a SimpleDateFormat without a Locale
instantiating.simpledateformat.without.locale.problem.descriptor=Instantiating a #ref without specifying a Locale in an internationalized context #loc
string.compareto.call.display.name=Call to 'String.compareTo()'
string.compareto.call.problem.descriptor=String.#ref() called using internationalized strings #loc
string.concatenation.display.name=String concatenation
string.concatenation.problem.descriptor=String concatenation #ref in an internationalized context #loc
string.concatenation.ignore.system.out.option=Ignore for 'System.out.print' arguments
string.concatenation.ignore.system.err.option=Ignore for 'System.err.print' arguments
string.concatenation.ignore.assert.option=Ignore for assert statement arguments
string.concatenation.ignore.exceptions.option=Ignore for throwable arguments
string.concatenation.ignore.constant.initializers.option=Ignore for initializers of constants
ignore.in.annotations=Ignore in annotations
ignore.in.tostring=Ignore inside toString() methods
ignore.as.initial.capacity=Ignore initial capacity for StringBuilders and Collections
string.equalsignorecase.call.display.name=Call to 'String.equalsIgnoreCase()'
string.equalsignorecase.call.problem.descriptor=String.#ref() using internationalized strings #loc
string.equals.call.display.name=Call to 'String.equals()'
string.equals.call.problem.descriptor=String.#ref() using internationalized strings #loc
string.touppercase.tolowercase.without.locale.display.name=Call to 'String.toUpperCase()' or 'toLowerCase()' without a Locale
string.touppercase.tolowercase.without.locale.problem.descriptor=String.#ref() called without specifying a Locale using internationalized strings #loc
use.stringtokenizer.display.name=Use of StringTokenizer
use.stringtokenizer.problem.descriptor=#ref in an internationalized context #loc
time.tostring.call.display.name=Call to 'Time.toString()'
time.tostring.call.problem.descriptor=Time.#ref() in an internationalized context #loc
class.escapes.defined.scope.display.name=Class escapes defined scope
class.escapes.defined.scope.problem.descriptor=Class #ref is made visible outside its defined scope #loc
field.name.hides.in.superclass.display.name=Field name hides field in superclass
field.name.hides.in.superclass.problem.descriptor=Field #ref hides field in superclass #loc
field.name.hides.in.superclass.ignore.option=Ignore superclass fields not visible from subclass
inner.class.field.hides.outer.display.name=Inner class field hides outer class field
inner.class.field.hides.outer.ignore.option=Ignore outer fields not visible from inner class
inner.class.field.hides.outer.problem.descriptor=Inner class field #ref hides outer class field #loc
local.variable.hides.member.variable.display.name=Local variable hides field
local.variable.hides.member.variable.problem.descriptor=Local variable #ref hides field in class ''{0}'' #loc
local.variable.hides.member.variable.ignore.option=Ignore local variables in static methods
method.overloads.display.name=Method overloads method of superclass
method.overloads.problem.descriptor=Method #ref() overloads a compatible method of a superclass, when overriding might have been intended #loc
method.overloads.report.incompatible.option=Report even if parameter types are not compatible
method.overrides.private.display.name=Method overrides private method of superclass
method.overrides.private.display.name.problem.descriptor=Method #ref() overrides a private method of a superclass #loc
method.overrides.static.display.name=Method overrides static method of superclass
method.overrides.static.problem.descriptor=Method #ref() overrides a static method of a superclass #loc
parameter.hides.member.variable.display.name=Parameter hides field
parameter.hides.member.variable.problem.descriptor=Parameter #ref hides field in class ''{0}'' #loc
parameter.hides.member.variable.ignore.setters.option=Ignore for property setters
parameter.hides.member.variable.ignore.superclass.option=Ignore superclass fields not visible from subclass
parameter.hides.member.variable.ignore.constructors.option=Ignore for constructors
parameter.hides.member.variable.ignore.abstract.methods.option=Ignore for abstract methods
parameter.hides.member.variable.ignore.static.parameters.option=Ignore for static method parameters hiding instance fields
type.parameter.hides.visible.type.display.name=Type parameter hides visible type
type.parameter.hides.visible.type.problem.descriptor=Type parameter #ref hides visible type ''{0}'' #loc
type.parameter.hides.type.parameter.problem.descriptor=Type parameter #ref hides type parameter ''{0}'' #loc
anonymous.class.variable.hides.containing.method.variable.display.name=Anonymous class variable hides variable in containing method
anonymous.class.parameter.hides.containing.method.variable.problem.descriptor=Anonymous class parameter #ref hides variable in containing method #loc
anonymous.class.field.hides.containing.method.variable.problem.descriptor=Anonymous class field #ref hides variable in containing method #loc
anonymous.class.variable.hides.containing.method.variable.problem.descriptor=Anonymous class local variable #ref hides variable in containing method #loc
channel.opened.not.closed.display.name=Channel opened but not safely closed
drivermanager.call.display.name=Use of DriverManager to get JDBC connection
drivermanager.call.problem.descriptor=Call to DriverManager.#ref() #loc
hibernate.resource.opened.not.closed.display.name=Hibernate resource opened but not safely closed
i.o.resource.opened.not.closed.display.name=I/O resource opened but not safely closed
resource.opened.not.closed.problem.descriptor=''{0}'' should be opened in front of a ''try'' block and closed in the corresponding ''finally'' block #loc
jdbc.resource.opened.not.closed.display.name=JDBC resource opened but not safely closed
jndi.resource.opened.not.closed.display.name=JNDI resource opened but not safely closed
socket.opened.not.closed.display.name=Socket opened but not safely closed
annotation.class.display.name=Annotation class
annotation.class.problem.descriptor=Annotation class #ref #loc
annotation.display.name=Annotation
annotation.problem.descriptor=Annotation #ref #loc
use.assert.as.identifier.display.name=Use of 'assert' as identifier
use.assert.as.identifier.problem.descriptor=Use of #ref as identifier #loc
assert.statement.display.name='assert' statement
statement.problem.descriptor=#ref statement #loc
auto.boxing.display.name=Auto-boxing
auto.boxing.problem.descriptor=Auto-boxing #ref #loc
auto.boxing.make.boxing.explicit.quickfix=Make boxing explicit
auto.boxing.ignore.added.to.collection.option=Ignore expressions added to a collection
auto.unboxing.display.name=Auto-unboxing
auto.unboxing.problem.descriptor=Auto-unboxing #ref #loc
auto.unboxing.make.unboxing.explicit.quickfix=Make unboxing explicit
use.enum.as.identifier.display.name=Use of 'enum' as identifier
use.enum.as.identifier.problem.descriptor=Use of #ref as identifier #loc
enumerated.class.display.name=Enumerated class
enumerated.class.problem.descriptor=Enumerated class #ref #loc
extended.for.statement.display.name=Extended 'for' statement
extended.for.statement.replace.quickfix=Replace with old-style 'for' statement
variable.argument.method.display.name=Variable argument method
variable.argument.method.problem.descriptor=Variable argument method #ref() #loc
variable.argument.method.quickfix=Convert variable argument parameter to array
hardcoded.file.separator.display.name=Hardcoded file separator
hardcoded.file.separator.problem.descriptor=Hardcoded file separator #ref #loc
hardcoded.file.separator.include.option=Include "example/*" in recognized MIME media types
hardcoded.line.separator.display.name=Hardcoded line separator
hardcoded.line.separator.problem.descriptor=Hardcoded line separator #ref #loc
native.method.display.name=Native method
native.method.problem.descriptor=Methods declared #ref are non-portable #loc
runtime.exec.call.display.name=Call to 'Runtime.exec()'
runtime.exec.call.problem.descriptor=Call to Runtime.#ref() is non-portable #loc
system.exit.call.display.name=Call to 'System.exit()' or related methods
system.exit.call.problem.descriptor=Call to {0}.#ref() is non-portable #loc
system.exit.call.ignore.option=Ignore in main method
system.getenv.call.display.name=Call to 'System.getenv()'
system.getenv.call.problem.descriptor=Call to System.#ref() is non-portable #loc
use.of.awt.peer.class.display.name=Use of AWT peer class
use.of.awt.peer.class.problem.descriptor=Use of AWT peer class #ref is non-portable #loc
use.of.concrete.jdbc.driver.class.display.name=Use of concrete JDBC driver class
use.of.concrete.jdbc.driver.class.problem.descriptor=Use of concrete JDBC driver class #ref is non-portable #loc
use.processbuilder.class.display.name=Use of 'java.lang.ProcessBuilder' class
use.processbuilder.class.problem.descriptor=Use of #ref is non-portable #loc
use.sun.classes.display.name=Use of sun.* classes
use.sun.classes.problem.descriptor=Use of Sun-supplied class #ref is non-portable #loc
abstract.class.with.only.one.direct.inheritor.display.name=Abstract class which has only one direct inheritor
anonymous.inner.may.be.named.static.inner.class.display.name=Anonymous inner class may be a named static inner class
anonymous.inner.may.be.named.static.inner.class.problem.descriptor=Anonymous inner class #ref may be a named static inner class #loc
array.length.in.loop.condition.display.name=Array.length in loop condition
array.length.in.loop.condition.problem.descriptor=Check of array #ref in loop condition #loc
large.array.allocation.no.outofmemoryerror.display.name=Large array allocation with no OutOfMemoryError check
large.array.allocation.no.outofmemoryerror.problem.descriptor=Large array allocation which is not checked for out-of-memory condition #loc
large.array.allocation.no.outofmemoryerror.maximum.number.of.elements.option=Maximum number of elements:
connection.opened.not.safely.closed.display.name=Connection opened but not safely closed
field.repeatedly.accessed.in.method.display.name=Field repeatedly accessed in method
field.repeatedly.accessed.in.method.problem.descriptor=Field ''{0}'' accessed repeatedly in method #ref() #loc
field.repeatedly.accessed.in.method.ignore.option=Ignore 'final' fields
interface.one.inheritor.display.name=Interface which has only one direct inheritor
interface.one.inheritor.problem.descriptor=Interface #ref has only one direct inheritor #loc
method.call.in.loop.condition.display.name=Method call in loop condition
method.call.in.loop.condition.problem.descriptor=Call to method #ref() in loop condition #loc
large.initializer.primitive.type.array.display.name=Overly large initializer for array of primitive type
large.initializer.primitive.type.array.problem.descriptor=Primitive array initializer with too many elements ({0}) #loc
large.initializer.primitive.type.array.maximum.number.of.elements.option=Maximum number of elements:
private.member.access.between.outer.and.inner.classes.display.name=Private member access between outer and inner classes
private.member.access.between.outer.and.inner.classes.problem.descriptor=Access to private member of class ''{0}'' #loc
private.member.access.between.outer.and.inner.classes.make.local.quickfix=Make ''{0}'' package-local
private.member.access.between.outer.and.inner.classes.make.constructor.package.local.quickfix=Make ''{0}'' constructor package-local
recordstore.opened.not.safely.closed.display.name=RecordStore opened but not safely closed
overly.complex.anonymous.inner.class.display.name=Overly complex anonymous inner class
cyclomatic.complexity.limit.option=Cyclomatic complexity limit:
overly.complex.anonymous.inner.class.problem.descriptor=Overly complex anonymous inner class (cyclomatic complexity = {0}) #loc
anonymous.inner.class.with.too.many.methods.display.name=Anonymous inner class with too many methods
method.count.limit.option=Method count limit:
anonymous.inner.class.with.too.many.methods.problem.descriptor=Anonymous inner class with too many methods (method count = {0}) #loc
overly.complex.class.display.name=Overly complex class
overly.complex.class.problem.descriptor=#ref is overly complex (cyclomatic complexity = {0}) #loc
overly.coupled.class.display.name=Overly coupled class
overly.coupled.class.class.coupling.limit.option=Class coupling limit:
include.java.system.classes.option=Include couplings to java system classes
include.library.classes.option=Include couplings to library classes
overly.coupled.class.problem.descriptor=#ref is overly coupled (dependencies = {0}) #loc
class.too.deep.display.name=Class too deep in inheritance tree
class.too.deep.inheritance.depth.limit.option=Inheritance depth limit:
class.too.deep.problem.descriptor=#ref is too deep in inheritance tree (inheritance depth = {0}) #loc
inner.class.too.deeply.nested.display.name=Inner class too deeply nested
inner.class.too.deeply.nested.nesting.limit.option=Nesting limit:
inner.class.too.deeply.nested.problem.descriptor=#ref is too deeply nested (nesting level = {0}) #loc
too.many.constructors.display.name=Class with too many constructors
too.many.constructors.count.limit.option=Constructor count limit:
too.many.constructors.ignore.deprecated.option=Ignore deprecated constructors
too.many.constructors.problem.descriptor=#ref has too many constructors (constructor count = {0}) #loc
too.many.fields.display.name=Class with too many fields
too.many.fields.count.limit.option=Field count limit:
too.many.fields.problem.descriptor=#ref has too many fields (field count = {0}) #loc
too.many.methods.display.name=Class with too many methods
too.many.methods.problem.descriptor=#ref has too many methods (method count = {0}) #loc
externalizable.with.serialization.methods.display.name=Externalizable class with 'readObject()' or 'writeObject()'
externalizable.with.serialization.methods.problem.descriptor.both=Externalizable class #ref defines 'readObject()' and 'writeObject()' #loc
externalizable.with.serialization.methods.problem.descriptor.write=Externalizable class #ref defines 'writeObject()' #loc
externalizable.with.serialization.methods.problem.descriptor.read=Externalizable class #ref defines 'readObject()' #loc
non.serializable.with.serialversionuid.display.name=Non-serializable class with 'serialVersionUID'
non.serializable.class.with.serialversionuid.problem.descriptor=Non-serializable class #ref defines a 'serialVersionUID' field #loc
non.serializable.interface.with.serialversionuid.problem.descriptor=Non-serializable interface #ref defines a 'serialVersionUID' field #loc
non.serializable.@interface.with.serialversionuid.problem.descriptor=Non-serializable @interface #ref defines a 'serialVersionUID' field #loc
non.serializable.anonymous.with.serialversionuid.problem.descriptor=Non-serializable anonymous class extending #ref defines a 'serialVersionUID' field #loc
non.serializable.with.serialversionuid.remove.quickfix=Remove 'serialVersionUID' field
non.serializable.class.with.readwriteobject.display.name=Non-serializable class with 'readObject()' or 'writeObject()'
non.serializable.class.with.readwriteobject.problem.descriptor.both=Non-serializable class #ref defines 'readObject()' and 'writeObject()' #loc
non.serializable.class.with.readwriteobject.problem.descriptor.write=Non-serializable class #ref defines 'writeObject()' #loc
non.serializable.class.with.readwriteobject.problem.descriptor.read=Non-serializable class #ref defines 'readObject()' #loc
non.serializable.anonymous.with.readwriteobject.problem.descriptor.both=Non-serializable anonymous class extending #ref defines 'readObject()' and 'writeObject()' #loc
non.serializable.anonymous.with.readwriteobject.problem.descriptor.write=Non-serializable anonymous class extending #ref defines 'writeObject()' #loc
non.serializable.anonymous.with.readwriteobject.problem.descriptor.read=Non-serializable anonymous class extending #ref defines 'readObject()' #loc
readwriteobject.private.display.name='readObject()' or 'writeObject()' not declared 'private'
readwriteobject.private.problem.descriptor=#ref not declared 'private' #loc
readobject.initialization.display.name=Instance field may not be initialized by 'readObject()'
readobject.initialization.problem.descriptor=Instance field #ref may not be initialized during 'readObject()' call #loc
readresolve.writereplace.protected.display.name='readResolve()' or 'writeReplace()' not declared 'protected'
readresolve.writereplace.protected.problem.descriptor=#ref() not declared 'protected' #loc
serialpersistentfields.with.wrong.signature.display.name='serialPersistentFields' field not declared 'private static final ObjectStreamField[]'
serialpersistentfields.with.wrong.signature.problem.descriptor=#ref field of a Serializable class is not declared 'private static final ObjectStreamField[]' #loc
serialversionuid.private.static.final.long.display.name='serialVersionUID' field not declared 'private static final long'
serialversionuid.private.static.final.long.problem.descriptor=#ref field of a Serializable class is not declared 'private static final long' #loc
serialversionuid.private.static.final.long.quickfix=Make serialVersionUID 'private static final'
serializable.class.without.serialversionuid.display.name=Serializable class without 'serialVersionUID'
serializable.class.without.serialversionuid.problem.descriptor=#ref does not define a 'serialVersionUID' field #loc
#dynamic
non.protected.constructor.in.abstract.class.display.name='public' constructor in 'abstract' class
unnecessary.qualifier.for.this.display.name=Unnecessary qualifier for 'this'
multiple.declaration.display.name=Multiple variables in one declaration
thread.priority.display.name=Call to 'Thread.setPriority()'
too.broad.scope.display.name=Scope of variable is too broad
infinite.loop.statement.display.name=Infinite loop statement
asserts.without.messages.display.name=Message missing on JUnit assertion
constant.naming.convention.display.name=Constant naming convention
random.double.for.random.integer.display.name=Using 'Random.nextDouble()' to get random integer
test.method.without.assertion.display.name=JUnit test method without any assertions
string.buffer.replaceable.by.string.builder.display.name='StringBuffer' may be 'StringBuilder'
comparison.of.short.and.char.display.name=Comparison of 'short' and 'char' values
unnecessary.fully.qualified.name.display.name=Unnecessary fully qualified name
unnecessary.label.on.break.statement.display.name=Unnecessary label on 'break' statement
exception.name.doesnt.end.with.exception.display.name=Exception class name does not end with 'Exception'
bad.exception.declared.display.name=Prohibited exception declared
deserializable.class.in.secure.context.display.name=Deserializable class in secure context
pointless.boolean.expression.display.name=Pointless boolean expression
class.without.constructor.display.name=Class without constructor
break.statement.display.name='break' statement
unconditional.wait.display.name=Unconditional 'wait()' call
cyclomatic.complexity.display.name=Overly complex method
string.to.string.display.name=Redundant 'String.toString()'
constant.on.lhs.of.comparison.display.name=Constant on left side of comparison
final.class.display.name='final' class
labeled.statement.display.name=Labeled statement
notify.called.on.condition.display.name='notify()' or 'notifyAll()' called on java.util.concurrent.locks.Condition object
loop.statements.that.dont.loop.display.name=Loop statement that does not loop
thread.run.display.name=Call to 'Thread.run()'
non.synchronized.method.overrides.synchronized.method.display.name=Unsynchronized method overrides synchronized method
constant.on.rhs.of.comparison.display.name=Constant on right side of comparison
synchronize.on.this.display.name=Synchronization on 'this'
switch.statement.with.too.many.branches.display.name='switch' statement with too many branches
utility.class.without.private.constructor.display.name=Utility class without private constructor
throw.caught.locally.display.name='throw' caught by containing 'try' statement
exception.from.catch.which.doesnt.wrap.display.name='throw' inside 'catch' block which ignores the caught exception
type.parameter.naming.convention.display.name=Type parameter naming convention
multiply.or.divide.by.power.of.two.display.name=Multiply or divide by power of two
multiply.or.divide.by.power.of.two.divide.option=Check divisions by a power of two also
serializable.with.unconstructable.ancestor.display.name=Serializable class with unconstructable ancestor
missorted.modifiers.display.name=Missorted modifiers
sleep.while.holding.lock.display.name=Call to 'Thread.sleep()' while synchronized
singleton.display.name=Singleton
thread.death.rethrown.display.name='java.lang.ThreadDeath' not rethrown
if.statement.with.too.many.branches.display.name='if' statement with too many branches
redundant.implements.display.name=Redundant interface declaration
nesting.depth.display.name=Overly nested method
return.this.display.name=Return of 'this'
busy.wait.display.name=Busy wait
utility.class.display.name=Utility class
instantiating.object.to.get.class.object.display.name=Instantiating object to get Class object
abstract.class.extends.concrete.class.display.name=Abstract class extends concrete class
parameter.naming.convention.display.name=Method parameter naming convention
integer.division.in.floating.point.context.display.name=Integer division in floating point context
interface.naming.convention.display.name=Interface naming convention
length.one.strings.in.concatenation.display.name=Single character string concatenation
length.one.string.in.indexof.display.name= Single character string argument in 'String.indexOf()' call
unnecessary.conditional.expression.display.name=Redundant conditional expression
thread.yield.display.name=Call to 'Thread.yield()'
confusing.floating.point.literal.display.name=Confusing floating-point literal
wait.not.in.loop.display.name='wait()' not in loop
string.concatenation.inside.string.buffer.append.display.name=String concatenation as argument to 'StringBuffer.append()' call
class.initializer.display.name=Non-'static' initializer
enumerated.class.naming.convention.display.name=Enumerated class naming convention
non.thread.safe.lazy.initialization.display.name=Unsafe lazy initialization of 'static' field
call.to.simple.setter.in.class.display.name=Call to simple setter from within class
comparison.to.nan.display.name=Comparison to Double.NaN or Float.NaN
instance.method.naming.convention.display.name=Instance method naming convention
unnecessary.semicolon.display.name=Unnecessary semicolon
fallthru.in.switch.statement.display.name=Fall-through in 'switch' statement
call.to.native.method.while.locked.display.name=Call to a native method while locked
switch.statement.display.name='switch' statement
custom.classloader.display.name=Custom ClassLoader
nested.conditional.expression.display.name=Nested conditional expression
duplicate.condition.display.name=Duplicate condition in 'if' statement
duplicate.boolean.branch.display.name=Duplicate condition on '\\&\\&' or '||'
method.with.multiple.loops.display.name=Method with multiple loops
non.comment.source.statements.display.name=Overly long method
local.variable.naming.convention.display.name=Local variable naming convention
negated.if.else.display.name='if' statement with negated condition
class.naming.convention.display.name=Class naming convention
abstract.class.naming.convention.display.name=Abstract class naming convention
serializable.inner.class.with.non.serializable.outer.class.display.name=Serializable non-'static' inner class with non-Serializable outer class
pointless.arithmetic.expression.display.name=Pointless arithmetic expression
method.name.same.as.class.name.display.name=Method name same as class name
unnecessary.temporary.on.conversion.to.string.display.name=Unnecessary temporary object in conversion to String
unnecessary.continue.display.name=Unnecessary 'continue' statement
inner.class.on.interface.display.name=Inner class of interface
unused.label.display.name=Unused label
multiple.typed.declaration.display.name=Variables of different types in one declaration
overly.complex.boolean.expression.display.name=Overly complex boolean expression
continue.statement.with.label.display.name='continue' statement with label
class.loader.instantiation.display.name=ClassLoader instantiation
return.from.finally.block.display.name='return' inside 'finally' block
unnecessary.boxing.display.name=Unnecessary boxing
annotation.naming.convention.display.name=Annotation naming convention
checked.exception.class.display.name=Checked exception class
switch.statement.with.confusing.declaration.display.name=Local variable used and declared in different 'switch' branches
cast.that.loses.precision.display.name=Numeric cast that loses precision
manual.array.copy.display.name=Manual array copy
manual.array.to.collection.copy.display.name=Manual array to collection copy
long.literals.ending.with.lowercase.l.display.name='long' literal ending with 'l' instead of 'L'
overly.complex.arithmetic.expression.display.name=Overly complex arithmetic expression
junit.abstract.test.class.naming.convention.display.name=JUnit abstract test class naming convention
unnecessary.parentheses.display.name=Unnecessary parentheses
test.case.in.product.code.display.name=JUnit TestCase in product source
test.method.in.product.code.display.name=JUnit test method in product source
serializable.class.in.secure.context.display.name=Serializable class in secure context
static.variable.naming.convention.display.name='static' field naming convention
nested.method.call.display.name=Nested method call
throw.from.finally.block.display.name='throw' inside 'finally' block
field.accessed.synchronized.and.unsynchronized.display.name=Field accessed in both synchronized and unsynchronized contexts
abstract.method.overrides.abstract.method.display.name=Abstract method overrides abstract method
static.non.final.field.display.name='static', non-'final' field
substring.zero.display.name=Redundant 'substring(0)' call
class.without.no.arg.constructor.display.name=Class without no-arg constructor
unnecessary.return.display.name=Unnecessary 'return' statement
final.static.method.display.name='static' method declared 'final'
constant.declared.in.abstract.class.display.name=Constant declared in abstract class
too.broad.catch.display.name=Overly broad 'catch' block
floating.point.equality.display.name=Floating point equality comparison
thrown.exceptions.per.method.display.name=Method with too many exceptions declared
public.static.array.field.display.name='public static' array field
await.not.in.loop.display.name='await()' not in loop
method.names.differ.only.by.case.display.name=Method names differing only by case
unsecure.random.number.generation.display.name=Insecure random number generation
parameters.per.method.display.name=Method with too many parameters
parameters.per.constructor.display.name=Constructor with too many parameters
unnecessary.unboxing.display.name=Unnecessary unboxing
extends.thread.display.name=Class explicitly extends 'java.lang.Thread'
misspelled.tear.down.display.name='teardown()' instead of 'tearDown()'
test.case.with.constructor.display.name=JUnit TestCase with non-trivial constructors
parameter.name.differs.from.overridden.parameter.display.name=Parameter name differs from parameter in overridden method
final.private.method.display.name='private' method declared 'final'
enum.switch.statement.which.misses.cases.display.name=Enum 'switch' statement that misses case
enum.switch.statement.which.misses.cases.option=Ignore switch statements with a default branch
setup.calls.super.setup.display.name='setUp()' does not call 'super.setUp()'
unconstructable.test.case.display.name=Unconstructable JUnit TestCase
volatile.long.or.double.field.display.name=Volatile long or double field
string.buffer.must.have.initial.capacity.display.name=StringBuffer or StringBuilder without initial capacity
method.may.be.static.display.name=Method may be 'static'
class.initializer.may.be.static.display.name=Class initializer may be 'static'
class.initializer.option=Only warn when the class has one or more constructors
class.initializer.move.code.to.constructor.quickfix=Move initializer code to constructor
nested.switch.statement.display.name=Nested 'switch' statement
c.style.array.declaration.display.name=C-style array declaration
final.method.in.final.class.display.name='final' method in 'final' class
extends.annotation.display.name=Class extends annotation interface
naked.notify.display.name='notify()' or 'notifyAll()' without corresponding state change
constant.if.statement.display.name=Constant 'if' statement
switch.statement.density.display.name='switch' statement with too low of a branch density
switch.statement.with.too.few.branches.display.name='switch' statement with too few branches
upper.case.field.name.not.constant.display.name=Non-constant field with upper-case name
unnecessary.label.on.continue.statement.display.name=Unnecessary label on 'continue' statement
jdbc.prepare.statement.with.non.constant.string.display.name='Connection.prepare*()' call with non-constant string
synchronize.on.non.final.field.display.name=Synchronization on a non-final field
noop.method.in.abstract.class.display.name=No-op method in abstract class
non.final.field.of.exception.display.name=Non-final field of exception class
nested.try.statement.display.name=Nested 'try' statement
condition.signal.display.name=Call to 'signal()' instead of 'signalAll()'
jdbc.execute.with.non.constant.string.display.name='Statement.execute()' call with non-constant string
system.set.security.manager.display.name=Call to 'System.setSecurityManager()'
system.set.security.manager.problem.descriptor=Call to System.#ref() may pose security concerns #loc
control.flow.statement.without.braces.display.name=Control flow statement without braces
trivial.if.display.name=Redundant 'if' statement
thread.with.default.run.method.display.name=Instantiating a Thread with default 'run()' method
while.loop.spins.on.field.display.name='while' loop spins on field
object.equals.null.display.name=Object.equals(null)
test.method.is.public.void.no.arg.display.name=Test method with incorrect signature
if.statement.with.identical.branches.display.name='if' statement with identical branches
multiple.return.points.per.method.display.name=Method with multiple return points
break.statement.with.label.display.name='break' statement with label
public.constructor.in.non.public.class.display.name='public' constructor in non-public class
questionable.name.display.name=Questionable name
empty.finally.block.display.name=Empty 'finally' block
abstract.method.overrides.concrete.method.display.name=Abstract method overrides concrete method
thread.stop.suspend.resume.display.name=Call to 'Thread.stop()', 'suspend()' or 'resume()'
constant.math.call.display.name=Constant call to 'java.lang.Math'
volatile.array.field.display.name=Volatile array field
literal.as.arg.to.string.equals.display.name='expression.equals("literal")' rather than '"literal".equals(expression)'
inner.class.may.be.static.display.name=Inner class may be 'static'
static.suite.display.name='suite()' method not declared 'static'
redundant.field.initialization.display.name=Redundant field initialization
string.buffer.to.string.in.concatenation.display.name='StringBuffer.toString()' in concatenation
utility.class.with.public.constructor.display.name=Utility class with 'public' constructor
for.loop.replaceable.by.while.display.name='for' loop may be replaced with 'while' loop
missing.deprecated.annotation.display.name=Missing @Deprecated annotation
cloneable.class.in.secure.context.display.name=Cloneable class in secure context
static.inheritance.display.name=Static inheritance
class.name.prefixed.with.package.name.display.name=Class name prefixed with package name
call.to.simple.getter.in.class.display.name=Call to simple getter from within class
class.name.differs.from.file.name.display.name=Class name differs from file name
protected.member.in.final.class.display.name='protected' member in 'final' class
load.library.with.non.constant.string.display.name=Call to 'System.loadLibrary()' with non-constant string
instanceof.catch.parameter.display.name='instanceof' on 'catch' parameter
implicit.numeric.conversion.display.name=Implicit numeric conversion
unnecessary.interface.modifier.display.name=Unnecessary interface modifier
confusing.main.method.display.name=Confusing 'main()' method
octal.literal.display.name=Octal integer
misordered.assert.equals.arguments.display.name=Misordered 'assertEquals()' arguments
unnecessary.constructor.display.name=Redundant no-arg constructor
method.name.same.as.parent.name.display.name=Method name same as parent class name
java.lang.reflect.display.name=Use of 'java.lang.reflect'
while.can.be.foreach.display.name='while' loop replaceable with 'foreach'
big.decimal.equals.display.name='equals()' called on java.math.BigDecimal
wait.not.in.synchronized.context.display.name='wait()' while not synchronized
implicit.call.to.super.display.name=Implicit call to 'super()'
empty.catch.block.display.name=Empty 'catch' block
unqualified.static.usage.display.name=Unqualified static access
simplifiable.junit.assertion.display.name=Simplifiable JUnit assertion
object.notify.display.name=Call to 'notify()' instead of 'notifyAll()'
thread.start.in.construction.display.name=Call to 'Thread.start()' during object construction
non.final.clone.display.name=Non-final 'clone()' in secure context
unnecessary.temporary.on.conversion.from.string.display.name=Unnecessary temporary object in conversion from String
unnecessary.this.display.name=Unnecessary 'this' qualifier
unnecessary.this.ignore.assignments.option=Ignore field assignments
runtime.exec.with.non.constant.string.display.name=Call to 'Runtime.exec()' with non-constant string
system.properties.display.name=Access of system properties
chained.method.call.display.name=Chained method calls
notify.not.in.synchronized.context.display.name='notify()' or 'notifyAll()' while not synchronized
safe.lock.display.name=Lock acquired but not safely unlocked
system.run.finalizers.on.exit.display.name=Call to 'System.runFinalizersOnExit()'
for.can.be.foreach.display.name='for' loop replaceable with 'foreach'
type.parameter.extends.object.display.name=Type parameter explicitly extends 'java.lang.Object'
marker.interface.display.name=Marker interface
limited.scope.inner.class.display.name=Limited-scope inner class
switch.statements.without.default.display.name='switch' statement without 'default' branch
unchecked.exception.class.display.name=Unchecked exception class
for.loop.with.missing.component.display.name='for' loop with missing components
for.loop.with.missing.component.collection.loop.option=Ignore collection iterations
double.checked.locking.display.name=Double-checked locking
double.checked.locking.problem.descriptor=Double-checked locking #loc
double.checked.locking.ignore.on.volatiles.option=Ignore double-checked locking on volatile fields
string.buffer.replaceable.by.string.display.name='StringBuffer' can be replaced with 'String'
boolean.method.name.must.start.with.question.display.name=Boolean method name must start with question word
class.name.same.as.ancestor.name.display.name=Class name same as ancestor name
error.rethrown.display.name='java.lang.Error' not rethrown
serializable.has.serialization.methods.display.name=Serializable class without 'readObject()' and 'writeObject()'
serializable.has.serialization.methods.ignore.option=Ignore classes that do not define instance fields
misspelled.set.up.display.name='setup()' instead of 'setUp()'
setup.is.public.void.no.arg.display.name='setUp()' with incorrect signature
missing.override.annotation.display.name=Missing @Override annotation
wait.while.holding.two.locks.display.name='wait()' while holding two locks
empty.class.display.name=Empty class
trivial.string.concatenation.display.name=Concatenation with empty string
empty.synchronized.statement.display.name=Empty 'synchronized' statement
unnecessary.default.display.name=Unnecessary 'default' for enum 'switch' statement
simplifiable.conditional.expression.display.name=Conditional that can be simplified to \\&\\& or ||
simplifiable.if.statement.display.name='if' statement may be replaced with \\&\\& or || expression
unnecessary.super.constructor.display.name=Unnecessary call to 'super()'
unnecessarily.qualified.static.usage.display.name=Unnecessarily qualified static access
bad.exception.caught.display.name=Prohibited exception caught
custom.security.manager.display.name=Custom SecurityManager
teardown.is.public.void.no.arg.display.name='tearDown()' with incorrect signature
string.concatenation.in.loops.display.name=String concatenation in loop
boolean.constructor.display.name=Boolean constructor call
continue.statement.display.name='continue' statement
extends.object.display.name=Class explicitly extends 'java.lang.Object'
serializable.inner.class.has.serial.version.uid.field.display.name=Serializable non-'static' inner class without 'serialVersionUID'
static.method.naming.convention.display.name='static' method naming convention
empty.try.block.display.name=Empty 'try' block
field.has.setter.but.no.getter.display.name=Field has setter but no getter
three.negations.per.method.display.name=Method with more than three negations
conditional.expression.display.name=Conditional expression (?:)
unnecessary.enum.modifier.display.name=Unnecessary enum modifier
string.equals.empty.string.display.name='String.equals("")'
teardown.calls.super.teardown.display.name='tearDown()' does not call 'super.tearDown()'
synchronize.on.lock.display.name=Synchronization on a Lock object
synchronized.on.literal.object.name=Synchronization on an object initialized with a literal
field.may.be.static.display.name=Field may be 'static'
class.may.be.interface.display.name=Abstract class may be interface
abstract.class.without.abstract.methods.display.name=Abstract class without abstract methods
divide.by.zero.display.name=Divide by zero
default.not.last.case.in.switch.display.name='default' not last case in 'switch' statement
nested.synchronized.statement.display.name=Nested 'synchronized' statement
constant.conditional.expression.display.name=Constant conditional expression
unused.catch.parameter.display.name=Unused 'catch' parameter
confusing.else.display.name=Confusing 'else' branch
public.field.accessed.in.synchronized.context.display.name=Non-private field accessed in synchronized context
string.replaceable.by.string.buffer.display.name=Non-constant String should be StringBuilder
junit.test.class.naming.convention.display.name=JUnit test class naming convention
method.coupling.display.name=Overly coupled method
collections.must.have.initial.capacity.display.name=Collection without initial capacity
anonymous.inner.class.display.name=Anonymous inner class
negated.conditional.display.name=Conditional expression with negated condition
non.reproducible.math.call.display.name=Non-reproducible call to 'java.lang.Math'
multiple.top.level.classes.in.file.display.name=Multiple top level classes in single file
set.replaceable.by.enum.set.display.name=Set replaceable with EnumSet
non.static.inner.class.in.secure.context.display.name=Non-'static' inner class in secure context
tail.recursion.display.name=Tail recursion
finally.block.cannot.complete.normally.display.name='finally' block which can not complete normally
non.atomic.operation.on.volatile.field.display.name=Non-atomic operation on volatile field
public.static.collection.field.display.name='public static' collection field
non.exception.name.ends.with.exception.display.name=Non-exception class name ends with 'Exception'
synchronized.method.display.name='synchronized' method
enumerated.constant.naming.convention.display.name=Enumerated constant naming convention
final.method.display.name='final' method
transient.field.in.non.serializable.class.display.name=Transient field in non-serializable class
bad.exception.thrown.display.name=Prohibited exception thrown
conditional.expression.with.identical.branches.display.name=Conditional expression with identical branches
raw.use.of.parameterized.type.display.name=Raw use of parameterized class
standard.variable.names.display.name=Standard variable names
instance.variable.naming.convention.display.name=Instance field naming convention
dollar.sign.in.name.display.name=Use of '$' in identifier
map.replaceable.by.enum.map.display.name=Map replaceable with EnumMap
extends.concrete.collection.display.name=Class explicitly extends a Collection class
continue.or.break.from.finally.block.display.name='continue' or 'break' inside 'finally' block
abstract.method.with.missing.implementations.display.name=Abstract method with missing implementations
object.allocation.in.loop.display.name=Object allocation in loop
wait.called.on.condition.display.name='wait()' called on java.util.concurrent.locks.Condition object
test.case.with.no.test.methods.display.name=JUnit test case with no tests
abstract.class.never.implemented.display.name=Abstract class which has no concrete subclass
interface.never.implemented.display.name=Interface which has no concrete subclass
constant.declared.in.interface.display.name=Constant declared in interface
#problem descriptors
exception.name.doesnt.end.with.exception.problem.descriptor=Exception class name #ref does not end with 'Exception' #loc
non.exception.name.ends.with.exception.problem.descriptor=Non-exception class name #ref ends with 'Exception' #loc
class.name.prefixed.with.package.name.problem.descriptor=Class name #ref begins with its package name #loc
class.name.same.as.ancestor.name.problem.descriptor=Class name #ref is the same as one of its superclass' names #loc
method.name.same.as.class.name.problem.descriptor=Method name #ref is the same as its class name #loc
method.name.same.as.parent.name.problem.descriptor=Method name #ref is the same as its parent class name #loc
boolean.method.name.must.start.with.question.problem.descriptor=Boolean method name #ref does not start with question word #loc
questionable.name.problem.descriptor=Questionable name #ref #loc
confusing.main.method.problem.descriptor=Method named #ref without signature 'public static void main(String[])' #loc
upper.case.field.name.not.constant.problem.descriptor=Non-constant field #ref with constant-style name #loc
dollar.sign.in.name.problem.descriptor=Identifier #ref contains '$' #loc
integer.division.in.floating.point.context.problem.descriptor=#ref: integer division in floating-point context #loc
comparison.of.short.and.char.problem.descriptor=Equality comparison #ref of short and char values #loc
big.decimal.equals.problem.descriptor=#ref() between BigDecimal values should probably be 'compareTo()' #loc
divide.by.zero.problem.descriptor=Division by zero #loc
non.reproducible.math.call.problem.descriptor=Math.#ref() may produce non-reproducible results #loc
constant.math.call.problem.descriptor=Constant call to #ref() can be simplified #loc
floating.point.equality.problem.descriptor=#ref: floating point values compared for exact equality #loc
fallthru.in.switch.statement.problem.descriptor=#ref fall-through in 'switch' statement #loc
switch.statements.without.default.problem.descriptor=#ref statement without 'default' branch #loc
default.not.last.case.in.switch.problem.descriptor=#ref branch not last case in 'switch' statement #loc
loop.statements.that.dont.loop.problem.descriptor=#ref statement does not loop #loc
conditional.expression.with.identical.branches.problem.descriptor=Conditional expression #ref with identical branches #loc
if.statement.with.identical.branches.problem.descriptor=#ref statement with identical branches #loc
duplicate.condition.problem.descriptor=Duplicate condition #ref #loc
duplicate.condition.ignore.method.calls.option=Ignore method calls in condition
duplicate.boolean.branch.problem.descriptor=Duplicate branch #ref #loc
iterator.next.does.not.throw.nosuchelementexception.problem.descriptor=Iterator.#ref() which can't throw 'NoSuchElementException' #loc
infinite.loop.statement.problem.descriptor=#ref statement cannot complete without throwing an exception #loc
confusing.floating.point.literal.problem.descriptor=Confusing floating point literal #ref #loc
overly.complex.arithmetic.expression.problem.descriptor=Overly complex arithmetic expression #loc
overly.complex.boolean.expression.problem.descriptor=Overly complex boolean expression ({0} terms) #loc
labeled.statement.problem.descriptor=Labeled statement #ref: #loc
break.statement.with.label.problem.descriptor=#ref statement with label #loc
continue.statement.with.label.problem.descriptor=#ref statement with label #loc
conditional.expression.problem.descriptor=Conditional expression #ref #loc
conditional.expression.option=Ignore for simple assignments and returns
nested.conditional.expression.problem.descriptor=Nested conditional expression #ref #loc
long.literals.ending.with.lowercase.l.problem.descriptor='long' literal #ref ends with lowercase 'l' #loc
nested.switch.statement.problem.descriptor=Nested #ref statement #loc
chained.method.call.problem.descriptor=Chained method call #ref() #loc
nested.method.call.problem.descriptor=Nested method call #ref() #loc
octal.literal.problem.descriptor=Octal integer #ref #loc
implicit.call.to.super.problem.descriptor=Implicit call to 'super()' #loc
negated.if.else.problem.descriptor=#ref statement with negated condition #loc
negated.conditional.problem.descriptor=Conditional expression with negated condition #loc
confusing.else.problem.descriptor=#ref branch may be unwrapped, as the 'if' branch never completes #loc
switch.statement.with.confusing.declaration.problem.descriptor=Local variable #ref declared in one 'switch' branch and used in another #loc
raw.use.of.parameterized.type.problem.descriptor=Raw use of parameterized class #ref #loc
final.class.problem.descriptor=Class declared #ref #loc
empty.class.problem.descriptor=Class #ref is empty #loc
empty.class.file.without.class.problem.descriptor=Java file does not declare any class #loc
empty.anonymous.class.problem.descriptor=Anonymous class is empty #loc
anonymous.inner.class.problem.descriptor=Anonymous inner class #ref #loc
limited.scope.inner.class.problem.descriptor=Limited-scope inner class #ref #loc
final.method.problem.descriptor=Method declared #ref #loc
class.initializer.problem.descriptor=Non-'static' initializer #loc
class.may.be.interface.problem.descriptor=Abstract class #ref may be interface #loc
non.protected.constructor.in.abstract.class.problem.descriptor=Constructor #ref() is not declared 'protected' in 'abstract' class #loc
class.without.constructor.problem.descriptor=Class #ref has no constructor #loc
abstract.class.without.abstract.methods.problem.descriptor=Class #ref is declared 'abstract', and has no 'abstract' methods #loc
final.method.in.final.class.problem.descriptor=Method declared #ref in 'final' class #loc
protected.member.in.final.class.problem.descriptor=Class member declared #ref in 'final' class #loc
utility.class.with.public.constructor.problem.descriptor=Class #ref has only 'static' members, and a 'public' constructor #loc
utility.class.without.private.constructor.problem.descriptor=Class #ref has only 'static' members, and lacks a 'private' constructor #loc
abstract.method.overrides.concrete.method.problem.descriptor=Abstract method #ref() overrides concrete method #loc
abstract.method.with.missing.implementations.problem.descriptor=Abstract method #ref() is not implemented in every subclass #loc
abstract.method.overrides.abstract.method.problem.descriptor=Abstract method #ref() overrides abstract method #loc
abstract.method.overrides.abstract.method.ignore.different.javadoc.option=Ignore methods with different JavaDoc than their super methods
abstract.method.overrides.abstract.method.ignore.different.annotations.option=Ignore methods with different annotations than their super methods
abstract.class.extends.concrete.class.problem.descriptor=Class #ref is declared 'abstract', and extends a concrete class #loc
static.non.final.field.problem.descriptor='static' non-'final' field #ref #loc
constant.declared.in.abstract.class.problem.descriptor=Constant #ref declared in abstract class #loc
constant.declared.in.interface.problem.descriptor=Constant #ref declared in interface #loc
static.inheritance.problem.descriptor=Interface #ref is implemented only for its 'static' constants #loc
utility.class.problem.descriptor=Class #ref has only 'static' members, indicating procedural construction #loc
singleton.problem.descriptor=Class #ref is a singleton #loc
final.private.method.problem.descriptor='private' method declared #ref #loc
noop.method.in.abstract.class.problem.descriptor=No-op Method #ref() should be made abstract #loc
final.static.method.problem.descriptor='static' method declared #ref #loc
class.without.no.arg.constructor.problem.descriptor=#ref has no no-arg constructor #loc
multiple.top.level.classes.in.file.problem.descriptor=Multiple top level classes in file
class.name.differs.from.file.name.problem.descriptor=Class name #ref differs from file name #loc
marker.interface.problem.descriptor=Marker interface #ref #loc
field.has.setter.but.no.getter.problem.descriptor=Field #ref has setter but no getter #loc
abstract.class.never.implemented.problem.descriptor=Abstract class #ref has no concrete subclass #loc
interface.never.implemented.problem.descriptor=Interface #ref has no concrete subclass #loc
missing.deprecated.annotation.problem.descriptor=Missing '@Deprecated' annotation on #ref() #loc
missing.override.annotation.problem.descriptor=Missing '@Override' annotation on #ref() #loc
non.thread.safe.lazy.initialization.problem.descriptor=Lazy initialization of 'static' field #ref is not thread-safe #loc
empty.catch.block.problem.descriptor=Empty #ref block #loc
unused.catch.parameter.problem.descriptor=Unused 'catch' parameter #ref #loc
used.catch.parameter.named.ignore.problem.descriptor='catch' parameter named #ref is used #loc
empty.finally.block.problem.descriptor=Empty #ref block #loc
finally.block.cannot.complete.normally.problem.descriptor=#ref block can not complete normally #loc
empty.try.block.problem.descriptor=Empty #ref block #loc
throw.from.finally.block.problem.descriptor=#ref inside 'finally' block #loc
throw.caught.locally.problem.descriptor=#ref caught by containing 'try' statement #loc
throw.caught.locally.ignore.option=Ignore rethrown exceptions
return.from.finally.block.problem.descriptor=#ref inside 'finally' block #loc
continue.or.break.from.finally.block.problem.descriptor=#ref inside 'finally' block #loc
bad.exception.declared.problem.descriptor=Prohibited exception #ref declared #loc
bad.exception.caught.problem.descriptor=Prohibited exception #ref caught #loc
checked.exception.class.problem.descriptor=Checked exception class #ref #loc
unchecked.exception.class.problem.descriptor=Unchecked exception class #ref #loc
thread.death.rethrown.problem.descriptor=ThreadDeath #ref not rethrown #loc
error.rethrown.problem.descriptor=Error #ref not rethrown #loc
nested.try.statement.problem.descriptor=Nested #ref statement #loc
exception.from.catch.which.doesnt.wrap.problem.descriptor=#ref inside 'catch' block ignores the caught exception #loc
instanceof.catch.parameter.problem.descriptor='instanceof' on 'catch' parameter #ref #loc
non.final.field.of.exception.problem.descriptor=Non-final field #ref of exception class #loc
unnecessary.label.on.break.statement.problem.descriptor=Unnecessary label on #ref statement #loc
unnecessary.label.on.continue.statement.problem.descriptor=Unnecessary label on #ref statement #loc
trivial.if.problem.descriptor=#ref statement can be simplified #loc
constant.if.statement.problem.descriptor=#ref statement can be simplified #loc
unnecessary.parentheses.problem.descriptor=Parentheses around #ref are unnecessary #loc
unnecessary.local.variable.problem.descriptor=Local variable #ref is redundant #loc
unnecessary.this.problem.descriptor=#ref is unnecessary in this context #loc
unnecessary.block.statement.problem.descriptor=Braces around this statement are unnecessary #loc
unnecessary.continue.problem.descriptor=#ref is unnecessary as the last statement in a loop #loc
unnecessary.semicolon.problem.descriptor=Unnecessary semicolon #ref #loc
unnecessary.fully.qualified.name.problem.descriptor1=Fully qualified name #ref is unnecessary, and can be replaced with an import #loc
unnecessary.fully.qualified.name.problem.descriptor2=Fully qualified name #ref is unnecessary, and the qualification can be removed #loc
unnecessary.qualifier.for.this.problem.descriptor=Qualifier #ref on 'this' is unnecessary in this context #loc
unused.label.problem.descriptor=Unused label #ref #loc
redundant.field.initialization.problem.descriptor=Field initialization to #ref is redundant #loc
redundant.implements.problem.descriptor=Redundant interface declaration #ref #loc
extends.object.problem.descriptor=Class #ref explicitly extends 'java.lang.Object' #loc
type.parameter.extends.object.problem.descriptor1=Type parameter #ref explicitly extends 'java.lang.Object' #loc
type.parameter.extends.object.problem.descriptor2=Wildcard type argument #ref explicitly extends 'java.lang.Object' #loc
unnecessary.super.constructor.problem.descriptor=#ref is unnecessary #loc
unnecessary.constructor.problem.descriptor=No-arg constructor #ref() is redundant #loc
unnecessary.constructor.annotation.option=Ignore constructors with an annotation
for.loop.replaceable.by.while.problem.descriptor=#ref loop statement may be replace by 'while' loop #loc
unnecessary.default.problem.descriptor=#ref branch is unnecessary #loc
unnecessary.boxing.problem.descriptor=Unnecessary boxing #ref #loc
unnecessary.unboxing.problem.descriptor=Unnecessary unboxing #ref #loc
unnecessary.boxing.superfluous.option=Only report truly superfluously boxed expressions
unnecessary.unboxing.superfluous.option=Only report truly superfluously unboxed expressions
for.can.be.foreach.problem.descriptor=#ref loop replaceable with 'foreach' #loc
while.can.be.foreach.problem.descriptor=#ref loop replaceable with 'foreach' #loc
too.broad.scope.problem.descriptor=Scope of variable #ref is too broad #loc
return.this.problem.descriptor=Return of #ref #loc
constant.on.lhs.of.comparison.problem.descriptor=#ref: constant on left side of comparison #loc
constant.on.rhs.of.comparison.problem.descriptor=#ref: constant on right side of comparison #loc
control.flow.statement.without.braces.problem.descriptor=#ref without braces #loc
missorted.modifiers.problem.descriptor=Missorted modifiers #ref #loc
c.style.array.declaration.problem.descriptor=C-style array declaration #ref #loc
multiple.declaration.problem.descriptor=Multiple variables in one declaration #loc
multiple.typed.declaration.problem.descriptor=Variables of different types in one declaration #loc
serializable.inner.class.has.serial.version.uid.field.problem.descriptor=Inner class #ref does not define a 'serialVersionUID' field #loc
serializable.inner.class.with.non.serializable.outer.class.problem.descriptor=Inner class #ref is serializable while its outer class is not #loc
busy.wait.problem.descriptor=Call to Thread.#ref() in a loop, probably busy-waiting #loc
sleep.while.holding.lock.problem.descriptor=Call to Thread.#ref() while synchronized #loc
non.atomic.operation.on.volatile.field.problem.descriptor=Non-atomic operation on volatile field #ref #loc
call.to.native.method.while.locked.problem.descriptor=Call to native method #ref() in a synchronized context #loc
object.notify.problem.descriptor=#ref should probably be replaced with 'notifyAll()' #loc
condition.signal.problem.descriptor=#ref should probably be replaced with 'signalAll()' #loc
thread.with.default.run.method.problem.descriptor=Instantiating a #ref with default 'run()' method #loc
extends.thread.problem.descriptor=Class #ref explicitly extends 'java.lang.Thread' #loc
anonymous.extends.thread.problem.descriptor=Anonymous class explicitly extends 'java.lang.Thread' #loc
naked.notify.problem.descriptor=Call to #ref() without corresponding state change #loc
unconditional.wait.problem.descriptor=Unconditional call to #ref() #loc
system.run.finalizers.on.exit.problem.descriptor=Call to System.#ref() #loc
thread.priority.problem.descriptor=Call to Thread.#ref() #loc
thread.yield.problem.descriptor=Call to Thread.#ref() #loc
thread.stop.suspend.resume.problem.descriptor=Call to Thread.#ref() #loc
while.loop.spins.on.field.problem.descriptor=#ref loop spins on field #loc
wait.not.in.loop.problem.descriptor=Call to #ref() is not made in a loop #loc
await.not.in.loop.problem.descriptor=Call to #ref() is not made in a loop #loc
wait.called.on.condition.problem.descriptor=Call to #ref() on Condition object #loc
notify.called.on.condition.problem.descriptor=Call to #ref() on Condition object #loc
wait.not.in.synchronized.context.problem.descriptor=Call to #ref while not synchronized on ''{0}'' #loc
wait.while.holding.two.locks.problem.descriptor=Call to #ref() is made while holding two locks #loc
notify.not.in.synchronized.context.problem.descriptor=Call to #ref() is made outside of a synchronized context #loc
thread.run.problem.descriptor=Calls to #ref() should probably be replaced with 'start()' #loc
thread.start.in.construction.problem.descriptor=Call to #ref during object construction #loc
synchronize.on.lock.problem.descriptor=Synchronization on a ''{0}'' object is unlikely to be intentional #loc
synchronized.on.literal.object.problem.descriptor=Synchronization on {0} #ref which is initialized by a literal #loc
synchronized.on.direct.literal.object.problem.descriptor=Synchronization on {0} literal #ref #loc
synchronized.on.possibly.literal.object.problem.descriptor=Synchronization on {0} #ref #loc
synchronize.on.non.final.field.problem.descriptor=Synchronization on a non-final field #ref #loc
synchronized.on.literal.object.warn.on.all.option=Warn on all possible literals
synchronize.on.this.problem.descriptor=Lock operations on 'this' may have unforeseen side-effects #loc
nested.synchronized.statement.problem.descriptor=Nested #ref statement #loc
empty.synchronized.statement.problem.descriptor=Empty #ref statement #loc
non.synchronized.method.overrides.synchronized.method.problem.descriptor=Unsynchronized method #ref() overrides synchronized method #loc
public.field.accessed.in.synchronized.context.problem.descriptor=Non-private field #ref accessed in synchronized context #loc
field.accessed.synchronized.and.unsynchronized.problem.descriptor=Field #ref is accessed in both synchronized and unsynchronized contexts #loc
extended.for.statement.problem.descriptor=Extended #ref statement #loc
object.allocation.in.loop.problem.descriptor=Object allocation new #ref() in loop #loc
instantiating.object.to.get.class.object.problem.descriptor=Instantiating object to get Class object #loc
field.may.be.static.problem.descriptor=Field #ref may be 'static' #loc
method.may.be.static.problem.descriptor=Method #ref() may be 'static' #loc
class.initializer.may.be.static.problem.descriptor=Class initializer may be 'static' #loc
map.replaceable.by.enum.map.problem.descriptor=#ref replaceable with 'EnumMap' #loc
set.replaceable.by.enum.set.problem.descriptor=#ref replaceable with 'EnumSet' #loc
inner.class.may.be.static.problem.descriptor=Inner class #ref may be 'static' #loc
string.buffer.must.have.initial.capacity.problem.descriptor=new #ref() without initial capacity #loc
string.buffer.replaceable.by.string.builder.problem.descriptor=StringBuffer #ref may be declared as 'StringBuilder' #loc
string.buffer.replaceable.by.string.problem.descriptor={0} #ref can be replaced with ''String'' #loc
new.string.buffer.replaceable.by.string.problem.descriptor=#ref can be replaced with 'String' #loc
string.replaceable.by.string.buffer.problem.descriptor=Non-constant String #ref should probably be declared as ''StringBuilder'' #loc
collections.must.have.initial.capacity.problem.descriptor=new #ref() without initial capacity #loc
string.concatenation.in.loops.problem.descriptor=String concatenation #ref in loop #loc
string.concatenation.inside.string.buffer.append.problem.descriptor=String concatenation as argument to {0}.#ref() call #loc
boolean.constructor.problem.descriptor=Boolean constructor call #loc
string.to.string.problem.descriptor=#ref is redundant #loc
substring.zero.problem.descriptor=#ref is redundant #loc
string.buffer.to.string.in.concatenation.problem.descriptor=Calls to StringBuffer.#ref() in concatenation #loc
tail.recursion.problem.descriptor=Tail recursive call #ref() #loc
string.equals.empty.string.problem.descriptor=#ref("") can be replaced with 'length()==0' #loc
string.equals.empty.string.is.empty.problem.descriptor=#ref("") can be replaced with 'isEmpty()' #loc
random.double.for.random.integer.problem.descriptor=Using Random.#ref to create random integer #loc
manual.array.copy.problem.descriptor=Manual array copy #loc
manual.array.to.collection.copy.problem.descriptor=Manual array to collection copy #loc
java.lang.reflect.problem.descriptor=Use of type #ref from 'java.lang.reflect' #loc
call.to.simple.getter.in.class.problem.descriptor=Call to simple getter #ref() from within class #loc
call.to.simple.setter.in.class.problem.descriptor=Call to simple setter #ref() from within class #loc
asserts.without.messages.problem.descriptor=JUnit #ref() without message #loc
test.case.with.constructor.problem.descriptor=Initialization logic in constructor #ref() instead of 'setUp()' #loc
test.case.with.constructor.problem.descriptor.initializer=Initialization logic in initializer instead of 'setUp()'
misspelled.set.up.problem.descriptor=#ref() probably be 'setUp()' #loc
misordered.assert.equals.arguments.problem.descriptor=Arguments to #ref() in wrong order #loc
misspelled.tear.down.problem.descriptor=#ref() method should probably be 'tearDown()' #loc
static.suite.problem.descriptor=JUnit #ref() methods not declared 'static' #loc
setup.calls.super.setup.problem.descriptor=#ref() does not call 'super.setUp()' #loc
teardown.calls.super.teardown.problem.descriptor=#ref() does not call 'super.tearDown()' #loc
setup.is.public.void.no.arg.problem.descriptor=#ref() has incorrect signature
simplifiable.junit.assertion.problem.descriptor=#ref() can be simplified to ''{0}'' #loc
teardown.is.public.void.no.arg.problem.descriptor=#ref() has incorrect signature #loc
test.method.without.assertion.problem.descriptor=JUnit test method #ref() contains no assertions #loc
test.case.with.no.test.methods.problem.descriptor=JUnit test case #ref has no tests #loc
test.case.in.product.code.problem.descriptor=Test case #ref should probably be placed in a test source tree #loc
test.method.in.product.code.problem.descriptor=Test method .#ref() should probably be placed in a test source tree #loc
unconstructable.test.case.problem.descriptor=Test case #ref is unusable by most test runners #loc
deserializable.class.in.secure.context.problem.descriptor=Class #ref may be deserialized, compromising security #loc
serializable.class.in.secure.context.problem.descriptor=Class #ref may be serialized, compromising security #loc
cloneable.class.in.secure.context.problem.descriptor=Class #ref may be cloned, compromising security #loc
non.final.clone.problem.descriptor=Non-final #ref() method, compromising security #loc
non.static.inner.class.in.secure.context.problem.descriptor=Non-'static' inner class #ref, compromising security #loc
runtime.exec.with.non.constant.string.problem.descriptor=Call to Runtime.#ref() with non-constant argument #loc
load.library.with.non.constant.string.problem.descriptor=Call to System.#ref() with non-constant argument #loc
jdbc.execute.with.non.constant.string.problem.descriptor=Call to Statement.#ref() with non-constant argument #loc
jdbc.prepare.statement.with.non.constant.string.problem.descriptor=Call to Connection.#ref() with non-constant argument #loc
custom.classloader.problem.descriptor=Custom ClassLoader class #ref #loc
custom.security.manager.problem.descriptor=Custom SecurityManager class #ref #loc
system.set.problem.descriptor=Call to System.#ref() may pose security concerns #loc
class.loader.instantiation.problem.descriptor=Instantiation of #ref may pose security concerns #loc
public.static.array.field.problem.descriptor='public static' array field #ref, compromising security #loc
public.static.collection.field.problem.descriptor='public static' collection field #ref, compromising security #loc
abstract.class.with.only.one.direct.inheritor.problem.descriptor=Abstract class #ref has only one direct inheritor #loc
#other
abstract.method.overrides.abstract.method.remove.quickfix=Remove redundant abstract method declaration
class.may.be.interface.convert.quickfix=Convert class to interface
class.without.constructor.create.quickfix=Generate empty constructor
class.without.no.arg.constructor.ignore.option=Ignore if class has default constructor
extends.annotation.problem.descriptor=Class ''{0}'' explicitly extends annotation interface #ref #loc
extends.concrete.collection.problem.descriptor=Class #ref explicitly extends ''{0}'' #loc
anonymous.extends.concrete.collection.problem.descriptor=Anonymous class explicitly extends ''{0}'' #loc
inner.class.on.interface.ignore.option=Ignore inner interfaces of interfaces
inner.class.on.interface.problem.descriptor=Interface ''{0}'' has inner class #ref #loc
missing.deprecated.annotation.add.quickfix=Add @Deprecated annotation
missing.override.annotation.add.quickfix=Add @Override annotation
non.protected.constructor.in.abstract.class.ignore.option=Ignore for non-public classes
public.constructor.in.non.public.class.problem.descriptor=Constructor is declared #ref in non-public class ''{0}'' #loc
static.inheritance.replace.quickfix=Replace inheritance with qualified references in {0}
utility.class.with.public.constructor.make.quickfix=Make {0, choice, 1#constructor|2#constructors} private
utility.class.without.private.constructor.create.quickfix=Generate empty private constructor
utility.class.without.private.constructor.make.quickfix=Make constructor 'private'
annotation.naming.convention.problem.descriptor.short=Annotation name #ref is too short #loc
annotation.naming.convention.problem.descriptor.long=Annotation name #ref is too long #loc
annotation.naming.convention.problem.descriptor.regex.mismatch=Annotation name #ref doesn''t match regex ''{0}'' #loc
class.name.convention.problem.descriptor.short=Class name #ref is too short #loc
abstract.class.name.convention.problem.descriptor.short=Abstract class name #ref is too short #loc
class.name.convention.problem.descriptor.long=Class name #ref is too long #loc
abstract.class.name.convention.problem.descriptor.long=Abstract class name #ref is too long #loc
class.name.convention.problem.descriptor.regex.mismatch=Class name #ref doesn''t match regex ''{0}'' #loc
abstract.class.name.convention.problem.descriptor.regex.mismatch=Abstract class name #ref doesn''t match regex ''{0}'' #loc
constant.naming.convention.problem.descriptor.short=Constant name #ref is too short #loc
constant.naming.convention.problem.descriptor.long=Constant name #ref is too long #loc
constant.naming.convention.problem.descriptor.regex.mismatch=Constant #ref doesn''t match regex ''{0}'' #loc
constant.naming.convention.immutables.option=Only check 'static final' fields with immutable types
enumerated.class.naming.convention.problem.descriptor.short=Enumerated class name #ref is too short #loc
enumerated.class.naming.convention.problem.descriptor.long=Enumerated class name #ref is too long #loc
enumerated.class.naming.convention.problem.descriptor.regex.mismatch=Enumerated class name #ref doesn''t match regex ''{0}'' #loc
enumerated.constant.naming.convention.problem.descriptor.short=Enumerated constant name #ref is too short #loc
enumerated.constant.naming.convention.problem.descriptor.long=Enumerated constant name #ref is too long #loc
enumerated.constant.naming.convention.problem.descriptor.regex.mismatch=Enumerated constant #ref doesn''t match regex ''{0}'' #loc
instance.method.name.convention.problem.descriptor.short=Instance method name #ref is too short #loc
instance.method.name.convention.problem.descriptor.long=Instance method name #ref is too long #loc
instance.method.name.convention.problem.descriptor.regex.mismatch=Instance method name #ref doesn''t match regex ''{0}'' #loc
instance.variable.name.convention.problem.descriptor.short=Instance field name #ref is too short #loc
instance.variable.name.convention.problem.descriptor.long=Instance field name #ref is too long #loc
instance.variable.name.convention.problem.descriptor.regex.mismatch=Instance field #ref doesn''t match regex ''{0}'' #loc
interface.name.convention.problem.descriptor.short=Interface name #ref is too short #loc
interface.name.convention.problem.descriptor.long=Interface name #ref is too long #loc
interface.name.convention.problem.descriptor.regex.mismatch=Interface name #ref doesn''t match regex ''{0}'' #loc
junit.abstract.test.class.naming.convention.problem.descriptor.short=Abstract JUnit test class name #ref is too short #loc
junit.abstract.test.class.naming.convention.problem.descriptor.long=Abstract JUnit test class name #ref is too long #loc
junit.abstract.test.class.naming.convention.problem.descriptor.regex.mismatch=Abstract JUnit test class name #ref doesn''t match regex ''{0}'' #loc
junit.test.class.naming.convention.problem.descriptor.short=JUnit test class name #ref is too short #loc
junit.test.class.naming.convention.problem.descriptor.long=JUnit test class name #ref is too long #loc
junit.test.class.naming.convention.problem.descriptor.regex.mismatch=JUnit test class name #ref doesn''t match regex ''{0}'' #loc
local.variable.naming.convention.problem.descriptor.short=Local variable name #ref is too short #loc
local.variable.naming.convention.problem.descriptor.long=Local variable name #ref is too long #loc
local.variable.naming.convention.problem.descriptor.regex.mismatch=Local variable name #ref doesn''t match regex ''{0}'' #loc
local.variable.naming.convention.ignore.option=Ignore for-loop parameters
local.variable.naming.convention.ignore.catch.option=Ignore 'catch' block parameters
method.names.differ.only.by.case.problem.descriptor=Method name #ref and method name ''{0}'' differ only by case #loc
parameter.name.differs.from.overridden.parameter.ignore.character.option=Ignore if overridden parameter contains only one character
parameter.name.differs.from.overridden.parameter.ignore.library.option=Ignore if overridden parameter is from a library
parameter.name.differs.from.overridden.parameter.problem.descriptor=Parameter name #ref is different from parameter ''{0}'' overridden #loc
parameter.naming.convention.problem.descriptor.short=Parameter name #ref is too short #loc
parameter.naming.convention.problem.descriptor.long=Parameter name #ref is too long #loc
parameter.naming.convention.problem.descriptor.regex.mismatch=Parameter name #ref doesn''t match regex ''{0}'' #loc
questionable.name.column.title=Name
standard.variable.names.problem.descriptor=Variable named #ref doesn''t have type ''{0}'' #loc
standard.variable.names.problem.descriptor2=Variable named #ref doesn''t have type ''{0}'' or ''{1}'' #loc
standard.variable.names.ignore.override.option=Ignore for parameter names identical to super method parameters
static.method.naming.convention.problem.descriptor.short='static' method name #ref is too short #loc
static.method.naming.convention.problem.descriptor.long='static' method name #ref is too long #loc
static.method.naming.convention.problem.descriptor.regex.mismatch='static' method name #ref doesn''t match regex ''{0}'' #loc
static.variable.naming.convention.problem.descriptor.short='static' field name #ref is too short #loc
static.variable.naming.convention.problem.descriptor.long='static' field name #ref is too long #loc
static.variable.naming.convention.problem.descriptor.regex.mismatch='static' field #ref doesn''t match regex ''{0}'' #loc
static.variable.naming.convention.mutable.option=Check 'static final' fields with a mutable type
type.parameter.naming.convention.problem.descriptor.short=Type parameter name #ref is too short #loc
type.parameter.naming.convention.problem.descriptor.long=Type parameter name #ref is too long #loc
boolean.method.name.must.start.with.question.table.column.name=Boolean method name prefix
conditional.expression.with.identical.branches.collapse.quickfix=Collapse conditional expression
confusing.else.unwrap.quickfix=Remove redundant 'else'
constant.conditional.expression.problem.descriptor=#ref can be simplified to ''{0}'' #loc
constant.conditional.expression.simplify.quickfix=Simplify
enum.switch.statement.which.misses.cases.problem.descriptor=#ref statement on enumerated type ''{0}'' misses cases #loc
for.loop.replaceable.by.while.ignore.option=Ignore 'infinite' for loops without conditions
for.loop.replaceable.by.while.replace.quickfix=Replace with 'while'
for.loop.with.missing.component.problem.descriptor1=#ref statement lacks initializer #loc
for.loop.with.missing.component.problem.descriptor2=#ref statement lacks condition #loc
for.loop.with.missing.component.problem.descriptor3=#ref statement lacks update #loc
for.loop.with.missing.component.problem.descriptor4=#ref statement lacks initializer and condition #loc
for.loop.with.missing.component.problem.descriptor5=#ref statement lacks initializer and update #loc
for.loop.with.missing.component.problem.descriptor6=#ref statement lacks condition and update #loc
for.loop.with.missing.component.problem.descriptor7=#ref statement lacks initializer, condition and update #loc
if.statement.with.identical.branches.collapse.quickfix=Collapse 'if' statement
foreach.replace.quickfix=Replace with 'foreach'
unnecessary.boxing.remove.quickfix=Remove boxing
unnecessary.unboxing.remove.quickfix=Remove unboxing
misordered.assert.equals.arguments.flip.quickfix=Flip compared arguments
setup.calls.super.setup.add.quickfix=Add call to 'super.setUp()'
simplify.junit.assertion.simplify.quickfix=Simplify assertion
teardown.calls.super.teardown.add.quickfix=Add call to 'super.tearDown()'
test.method.is.public.void.no.arg.problem.descriptor1=Test method #ref() should probably not have parameters #loc
test.method.is.public.void.no.arg.problem.descriptor2=Test method #ref() is not declared 'public void' #loc
test.method.is.public.void.no.arg.problem.descriptor3=Test method #ref() should not be 'static' #loc
system.properties.problem.descriptor=Call to Integer.#ref() may pose security concerns #loc
system.properties.problem.descriptor1=Call to Boolean.#ref() may pose security concerns #loc
unsecure.random.number.generation.problem.descriptor1=For security purposes, use 'java.security.SecureRandom' instead of java.lang.Math.#ref() #loc
unsecure.random.number.generation.problem.descriptor2=For security purposes, use 'java.security.SecureRandom' instead of java.util.#ref #loc
unsecure.random.number.generation.problem.descriptor3=For security purposes, use 'java.security.SecureRandom' instead of #ref #loc
serializable.has.serialization.methods.problem.descriptor=Serializable class #ref does not define 'readObject()' or 'writeObject()' #loc
serializable.has.serialization.methods.problem.descriptor1=Serializable class #ref does not define 'writeObject()' #loc
serializable.has.serialization.methods.problem.descriptor2=Serializable class #ref does not define 'readObject()' #loc
serializable.with.unconstructable.ancestor.problem.descriptor=#ref has a non-serializable ancestor ''{0}'' without no-arg constructor #loc
transient.field.in.non.serializable.class.problem.descriptor=Field ''{0}'' is marked #ref, in non-Serializable class #loc
transient.field.in.non.serializable.class.remove.quickfix=Remove 'transient'
condition.signal.replace.quickfix=Replace with 'signalAll()'
object.notify.replace.quickfix=Replace with 'notifyAll()'
safe.lock.problem.descriptor=''{0}'' should be locked in front of a ''try'' block and unlocked in the corresponding ''finally'' block #loc
synchronized.method.problem.descriptor=Method ''{0}()'' declared #ref #loc
synchronized.method.include.option=Include native methods
synchronized.method.ignore.synchronized.super.option=Ignore methods overriding a synchronized method
synchronized.method.move.quickfix=Move synchronization into method
thread.run.replace.quickfix=Replace with 'start()'
volatile.field.problem.descriptor=Volatile field #ref of type ''{0}'' #loc
string.format.choose.class=Choose Formatter class
string.format.class.column.name=Additional formatter classes
string.format.class.method.name=Additional formatter methods
exception.class.column.name=Exception class
bad.exception.thrown.problem.descriptor=Prohibited exception ''{0}'' thrown #loc
empty.catch.block.comments.option=Comments count as content
empty.catch.block.ignore.ignore.option=Ignore when 'catch' parameter is named 'ignore' or 'ignored'
too.broad.catch.problem.descriptor=''catch'' of #ref is too broad, masking exception ''{0}'' #loc
too.broad.catch.problem.descriptor1=''catch'' of #ref is too broad, masking exceptions ''{0}'' and ''{1}'' #loc
unused.catch.parameter.ignore.catch.option=Ignore when 'catch' block contains a comment
add.serialversionuidfield.quickfix=Add 'serialVersionUID' field
delete.import.quickfix=Delete unnecessary import
encapsulate.variable.quickfix=Encapsulate field ''{0}''
extract.method.quickfix=Extract method
inline.call.quickfix=Inline call
inline.variable.quickfix=Inline variable
pointless.nullcheck.display.name=Unnecessary 'null' check before 'instanceof' expression
pointless.nullcheck.problem.descriptor=Unnecessary 'null' check before 'instanceof' expression
pointless.nullcheck.simplify.quickfix=Remove unnecessary ''{0}'' condition
introduce.constant.quickfix=Introduce constant
make.initialization.explicit.quickfix=Make initialization explicit
move.anonymous.to.inner.quickfix=Convert to named inner class
anonymous.inner.may.be.named.static.inner.class.quickfix=Convert to named 'static' inner class
move.class.quickfix=Move class
normalize.declaration.quickfix=Split into multiple declarations
remove.modifier.quickfix=Remove ''{0}'' modifier
replace.inheritance.with.delegation.quickfix=Replace inheritance with delegation
big.decimal.equals.replace.quickfix=Replace with 'compareTo()==0'
cast.that.loses.precision.problem.descriptor=Cast to #ref from ''{0}'' may result in loss of precision #loc
comparison.to.nan.problem.descriptor1=Comparison to #ref is always false #loc
comparison.to.nan.problem.descriptor2=Comparison to #ref is always true #loc
comparison.to.nan.replace.quickfix=Replace with 'isNaN()'
confusing.floating.point.literal.change.quickfix=Change To canonical form
implicit.numeric.conversion.ignore.widening.conversion.option=Ignore widening conversions
implicit.numeric.conversion.ignore.char.conversion.option=Ignore conversions from and to char
implicit.numeric.conversion.ignore.constant.conversion.option=Ignore conversions from constants and literals
implicit.numeric.conversion.problem.descriptor=Implicit numeric conversion of #ref from ''{0}'' to ''{1}'' #loc
implicit.numeric.conversion.convert.quickfix=Convert to ''{0}'' literal
implicit.numeric.conversion.make.explicit.quickfix=Make conversion explicit
long.literals.ending.with.lowercase.l.replace.quickfix=Replace 'l' with 'L'
non.reproducible.math.call.replace.quickfix=Replace with 'StrictMath' call
overly.complex.arithmetic.expression.max.number.option=Maximum number of terms:
expression.can.be.replaced.problem.descriptor=#ref can be replaced with ''{0}'' #loc
method.complexity.limit.option=Method complexity limit:
cyclomatic.complexity.problem.descriptor=#ref is overly complex (cyclomatic complexity = {0}) #loc
method.coupling.limit.option=Method coupling limit:
method.coupling.problem.descriptor=#ref is overly coupled (# referenced classes = {0}) #loc
method.with.multiple.loops.problem.descriptor=#ref contains {0} loops #loc
return.point.limit.option=&Return point limit:
multiple.return.points.per.method.problem.descriptor=#ref has {0} return points #loc
nesting.depth.limit.option=Nesting depth limit:
nesting.depth.problem.descriptor=#ref is overly nested (maximum nesting depth = {0}) #loc
non.comment.source.statements.limit.option=Non-comment source statements limit:
non.comment.source.statements.problem.descriptor=#ref is too long (# Non-comment source statements = {0}) #loc
parameters.per.method.problem.descriptor=#ref() has too many parameters (num parameters = {0}) #loc
parameters.per.constructor.problem.descriptor=#ref() has too many parameters (num parameters = {0}) #loc
parameter.limit.option=Parameter limit:
constructor.visibility.option=Ignore constructors with visibility:
three.negations.per.method.ignore.option=Ignore negations in 'equals()' methods
three.negations.per.method.ignore.assert.option=Ignore negations in 'assert' statements
three.negations.per.method.problem.descriptor=#ref contains {0} negations #loc
thrown.exceptions.per.method.problem.descriptor=#ref has too many exceptions declared (num exceptions = {0}) #loc
thrown.exceptions.per.method.limit.option=Exceptions thrown limit:
call.to.simple.getter.in.class.ignore.option=Ignore getter calls on other objects
call.to.private.simple.getter.in.class.option=Only report getter is private
call.to.simple.getter.in.class.inline.quickfix=Inline call to getter
call.to.simple.setter.in.class.ignore.option=Ignore setter calls on other objects
call.to.private.setter.in.class.option=Only report when setter is private
call.to.simple.setter.in.class.inline.quickfix=Inline call to setter
make.static.quickfix=Make static
length.one.strings.in.concatenation.replace.quickfix=Replace with character
multiply.or.divide.by.power.of.two.replace.quickfix=Replace with shift
boolean.expression.can.be.simplified.problem.descriptor=#ref can be simplified to ''{0}'' #loc
trivial.string.concatenation.problem.descriptor=Empty string used in concatenation
string.replace.quickfix=Replace concatenation with ''{0}''
instantiating.object.to.get.class.object.replace.quickfix=Replace with direct class object access
manual.array.copy.replace.quickfix=Replace with 'System.arraycopy()'
manual.array.to.collection.copy.replace.quickfix=Replace with 'Collections.addAll(...,...)'
method.may.be.static.only.option=Only check 'private' or 'final' methods
method.may.be.static.empty.option=Ignore empty methods
random.double.for.random.integer.replace.quickfix=Replace with 'nextInt()'
string.buffer.replaceable.by.string.builder.replace.quickfix=Replace with 'StringBuilder'
string.buffer.to.string.in.concatenation.remove.quickfix=Remove 'toString()'
string.concatenation.in.loops.only.option=Only warn if string is repeatedly appended
string.concatenation.inside.string.buffer.append.replace.quickfix=Replace with chained 'append()' calls
string.equals.empty.string.quickfix=Replace with 'length()==0'
string.equals.empty.string.isempty.quickfix=Replace with 'isEmpty()'
tail.recursion.replace.quickfix=Replace tail recursion with iteration
if.statement.with.too.many.branches.max.option=Maximum number of branches:
if.statement.with.too.many.branches.problem.descriptor='#ref' has too many branches ({0}) #loc
negated.conditional.ignore.option=Ignore '!= null' comparisons
negated.conditional.invert.quickfix=Invert condition
negated.if.else.ignore.negated.null.option=Ignore '!= null' comparisons
negated.if.else.ignore.negated.zero.option=Ignore '!= 0' comparisons
negated.if.else.invert.quickfix=Invert If Condition
overly.complex.boolean.expression.max.terms.option=Maximum number of terms:
pointless.boolean.expression.ignore.option=Ignore named constants in determining pointless expressions
simplifiable.conditional.expression.problem.descriptor=#ref can be simplified to ''{0}'' #loc
simplifiable.if.statement.problem.descriptor=#ref statement can be replaced with ''{0}'' #loc
switch.statement.density.min.option=Minimum density of branches: %
switch.statement.density.problem.descriptor='#ref' has too low of a branch density ({0}%) #loc
switch.statement.with.too.few.branches.min.option=Minimum number of branches:
switch.statement.with.too.few.branches.problem.descriptor='#ref' has too few branches ({0}), and should probably be replaced with an ''if'' statement #loc
switch.statement.without.default.ignore.option=Ignore if all cases of an enumerated type are covered
unnecessary.label.remove.quickfix=Remove label
unnecessary.return.problem.descriptor=#ref is unnecessary as the last statement in a 'void' method #loc
unnecessary.return.constructor.problem.descriptor=#ref is unnecessary as the last statement in a constructor #loc
unused.label.remove.quickfix=Remove unused label
unnecessarily.qualified.static.usage.problem.descriptor=Unnecessarily qualified static method call {0}() #loc
unnecessarily.qualified.static.usage.problem.descriptor1=Unnecessarily qualified static access {0} #loc
unnecessarily.qualified.static.usage.ignore.field.option=Ignore unnecessarily qualified field accesses
unnecessarily.qualified.static.usage.ignore.method.option=Ignore unnecessarily qualified method calls
unnecessary.interface.modifier.problem.descriptor=Modifier #ref is redundant for interfaces #loc
unnecessary.interface.modifier.inner.interface.of.interface.problem.descriptor=Modifier #ref is redundant for inner interfaces #loc
unnecessary.interface.modifier.problem.descriptor2=Modifier #ref is redundant for interface methods #loc
unnecessary.interface.modifier.problem.descriptor3=Modifier #ref is redundant for inner classes of interfaces #loc
unnecessary.interface.modifier.problem.descriptor4=Modifier #ref is redundant for interface fields #loc
smth.unnecessary.remove.quickfix=Remove unnecessary ''{0}''
unqualified.static.usage.problem.descriptor=Unqualified static method call #ref() #loc
unqualified.static.usage.problem.descriptor1=Unqualified static field access #ref #loc
unqualified.static.usage.ignore.field.option=Ignore unqualified field accesses
unqualified.static.usage.ignore.method.option=Ignore unqualified method calls
unqualified.static.usage.qualify.field.quickfix=Qualify static field access
unqualified.static.usage.qualify.method.quickfix=Qualify static method call
too.broad.scope.allow.option=Allow initializer of variables to construct objects.
(Potentially unsafe: quick fix may modify semantics if the constructor has non-local side-effects)
too.broad.scope.only.blocks.option=Only report variables that can be moved into inner blocks
too.broad.scope.narrow.quickfix=Narrow scope of ''{0}''
press.escape.to.remove.highlighting.message=Press Escape to remove the highlighting
unnecessary.enum.modifier.problem.descriptor=Modifier #ref is redundant for enum constructors #loc
unnecessary.enum.modifier.problem.descriptor1=Modifier #ref is redundant for inner enums #loc
literal.as.arg.to.string.equals.problem.descriptor=#ref is argument of ''{0}()'', instead of its target #loc
literal.as.arg.to.string.equals.flip.quickfix=Flip 'equals()'
c.style.array.declaration.replace.quickfix=Replace with Java-style array declaration
chained.method.call.ignore.option=Ignore chained method calls in field initializers
chained.method.call.ignore.this.super.option=Ignore chained method calls in 'this()' and 'super()' calls
introduce.variable.quickfix=Introduce variable
introduce.variable.may.change.semantics.quickfix=Introduce variable (may change semantics)
flip.comparison.quickfix=Flip comparison
control.flow.statement.without.braces.add.quickfix=Add braces
extends.object.remove.quickfix=Remove redundant 'extends Object'
implicit.call.to.super.ignore.option=Ignore for direct subclasses of 'java.lang.Object'
implicit.call.to.super.make.explicit.quickfix=Make call to 'super()' explicit
missorted.modifiers.require.option=Require annotations to be sorted before keywords
missorted.modifiers.sort.quickfix=Sort modifiers
nested.method.call.ignore.option=Ignore nested method calls in field initializers
redundant.field.initialization.remove.quickfix=Remove initializer
redundant.implements.remove.quickfix=Remove redundant interface declaration
unnecessary.constructor.remove.quickfix=Remove redundant constructor
unnecessary.fully.qualified.name.replace.quickfix=Replace with import
unnecessary.fully.qualified.name.remove.quickfix=Remove qualification
unnecessary.fully.qualified.name.status.bar.escape.highlighting.message1=1 fully qualified name replaced with import (press Escape to remove highlighting)
unnecessary.fully.qualified.name.status.bar.escape.highlighting.message2={0} fully qualified names replaced with import (press Escape to remove highlighting)
unnecessary.parentheses.remove.quickfix=Remove unnecessary parentheses
unnecessary.qualifier.for.this.remove.quickfix=Remove unnecessary qualifier
unnecessary.semicolon.remove.quickfix=Remove unnecessary semicolon
unnecessary.super.constructor.remove.quickfix=Remove unnecessary 'super()'
unnecessary.this.remove.quickfix=Remove unnecessary 'this' qualifier
overly.strong.type.cast.problem.descriptor=Cast to #ref can be weakened to ''{0}'' #loc
field.count.inspection.include.constant.fields.in.count.checkbox=Include constant fields in count
field.count.inspection.static.final.fields.count.as.constant.checkbox='static final' fields count as constant
field.count.inspection.include.enum.constants.in.count=Include enum constants in count
make.method.final.fix.name=Make method ''{0}()'' ''final''
make.class.final.fix.name=Make class ''{0}'' ''final''
non.boolean.method.name.must.not.start.with.question.display.name=Non-boolean method name must not start with question word
non.boolean.method.name.must.not.start.with.question.problem.descriptor=Non-boolean method name #ref starts with a question word #loc
boolean.constructor.simplify.quickfix=Simplify
unnecessary.temporary.on.conversion.from.string.problem.descriptor=#ref #loc can be simplified to ''{0}''
unnecessary.temporary.on.conversion.from.string.fix.name=Replace with ''{0}''
only.report.qualified.static.usages.option=Only report qualified static access from a static context
unqualified,static.usage.only.report.static.usages.option=Only report static access from a non-static context
assignment.to.catch.block.parameter.problem.descriptor=Assignment to 'catch' block parameter #ref #loc
assignment.to.method.parameter.problem.descriptor=Assignment to method parameter #ref #loc
value.of.post.increment.problem.descriptor=Value of post-increment expression #ref is used #loc
value.of.post.decrement.problem.descriptor=Value of post-decrement expression #ref is used #loc
value.of.pre.increment.problem.descriptor=Value of pre-increment expression #ref is used #loc
value.of.pre.decrement.problem.descriptor=Value of pre-decrement expression #ref is used #loc
assignment.replaceable.with.operator.assignment.problem.descriptor=#ref could be simplified to ''{0}'' #loc
assignment.replaceable.with.operator.assignment.ignore.conditional.operators.option=Ignore conditional operators
assignment.replaceable.with.operator.assignment.ignore.obscure.operators.option=Ignore the obscure ^ and % operators
assignment.replaceable.with.operator.replace.quickfix=Replace '=' with ''{0}=''
object.equality.ignore.between.objects.of.a.type.with.only.private.constructors.option=Ignore '==' between objects of a type with only private constructors
redundant.method.override.display.name=Method is identical to its super method
redundant.method.override.problem.descriptor=Method #ref() is identical to its super method #loc
redundant.method.override.quickfix=Remove redundant method
refused.bequest.problem.descriptor=Method #ref() ignores defined method in superclass #loc
refused.bequest.ignore.empty.super.methods.option=Ignore empty super methods
overly.complex.boolean.expression.ignore.option=Ignore pure conjunctions and disjunctions
pointless.indexof.comparison.display.name=Pointless 'indexOf()' comparison
pointless.indexof.comparison.always.true.problem.descriptor=#ref is always true #loc
pointless.indexof.comparison.always.false.problem.descriptor=#ref is always false #loc
reuse.of.local.variable.problem.descriptor=Reuse of local variable #ref #loc
single.character.startswith.display.name=Single character 'startsWith()' or 'endsWith()'
single.character.startswith.problem.descriptor=Single character #ref() could be replaced with 'charAt()' expression #loc
indexof.replaceable.by.contains.display.name='indexOf()' expression is replaceable with 'contains()'
replace.indexof.with.contains.quickfix=Replace 'indexOf()' with 'contains()'
overloaded.methods.with.same.number.parameters.problem.descriptor=Multiple methods named #ref with the same number of parameters #loc
overloaded.vararg.method.problem.descriptor=Overloaded variable argument method #ref() #loc
overloaded.vararg.constructor.problem.descriptor=Overloaded variable argument constructor #ref() #loc
cached.number.constructor.call.display.name=Number constructor call with primitive argument
cached.number.constructor.call.problem.descriptor=Number constructor call with primitive argument #loc
cached.number.constructor.call.quickfix=Replace with ''{0}.valueOf()'' call
cached.number.constructor.call.ignore.string.arguments.option=Ignore new number expressions with a String argument
chained.equality.comparisons.problem.descriptor=Chained equality comparison #ref #loc
confusing.octal.escape.sequence.problem.descriptor=Octal escape sequence #ref immediately followed by digit #loc
field.accessed.synchronized.and.unsynchronized.option=Simple getters and setters are considered field accesses too
method.overrides.package.local.method.display.name=Method overrides package-local method of superclass located in other package
method.overrides.package.local.method.problem.descriptor=Method #ref() overrides a package-local method of a superclass located in another package #loc
suspicious.to.array.call.display.name=Suspicious 'Collection.toArray()' call
suspicious.to.array.call.problem.descriptor=Array of type ''{0}[]'' expected #loc
suspicious.system.arraycopy.display.name=Suspicious 'System.arraycopy()' call
suspicious.system.arraycopy.problem.descriptor1=Parameter 'srcPos' may not be negative #loc
suspicious.system.arraycopy.problem.descriptor2=Parameter 'destPos' may not be negative #loc
suspicious.system.arraycopy.problem.descriptor3=Parameter 'length' may not be negative #loc
suspicious.system.arraycopy.problem.descriptor4=#ref is not of an array type #loc
suspicious.system.arraycopy.problem.descriptor5=#ref is not of an array type #loc
suspicious.system.arraycopy.problem.descriptor6=Source parameter type ''{0}'' is not assignable to destination parameter #ref of type ''{1}'' #loc
raw.use.of.parameterized.type.ignore.new.objects.option=Ignore construction of new objects
raw.use.of.parameterized.type.ignore.type.casts.option=Ignore type casts
raw.use.of.parameterized.type.ignore.uncompilable.option=Ignore where a type parameter would not compile
raw.use.of.parameterized.type.ignore.overridden.parameter.option=Ignore parameter types of overriding methods
method.only.used.from.inner.class.display.name=Private method only used from inner class
method.only.used.from.inner.class.problem.descriptor.anonymous.extending=Method #ref()#loc is only used from an anonymous class extending ''{0}'' #loc
method.only.used.from.inner.class.problem.descriptor.anonymous.implementing=Method #ref()#loc is only used from an anonymous class implementing ''{0}'' #loc
method.only.used.from.inner.class.problem.descriptor=Method #ref()#loc is only used from inner class ''{0}'' #loc
method.only.used.from.inner.class.ignore.option=Ignore methods accessed from an &anonymous class
ignore.static.methods.accessed.from.a.non.static.inner.class=Ignore '&static' methods accessed from a non-'static' inner class
only.report.static.methods=&Only report 'static' methods
format.decode.error.requires.both.0.and.1=requires both {0} and {1}
format.decode.any=any
format.decode.date.time=Date/Time
format.decode.char=char
format.decode.integer.type=integer type
format.decode.floating.point=floating point
single.character.startswith.quickfix=Replace with 'charAt()'
interface.never.implemented.option=Ignore interfaces which only declare constants
size.replaceable.by.isempty.display.name='size() == 0' replaceable with 'isEmpty()'
size.replaceable.by.isempty.quickfix=Replace with 'isEmpty()'
size.replaceable.by.isempty.negation.ignore.option=Ignore expressions which would be replaced with '!isEmpty()'
ignored.classes.table=Ignored classes
choose.class.type.to.ignore=Choose class type to ignore
loop.condition.not.updated.inside.loop.display.name=Loop variable not updated inside loop
loop.variable.not.updated.inside.loop.problem.descriptor=Variable '#ref' is not updated inside loop #loc
loop.condition.not.updated.inside.loop.problem.descriptor=Condition '#ref' is not updated inside loop #loc
utility.class.without.private.constructor.option=Ignore classes with only a main method
super.class.logger.option=Ignore classes with an accessible logger declared in a superclass
static.method.only.used.in.one.class.display.name=Static method only used from one other class
static.method.only.used.in.one.class.problem.descriptor=Static method #ref() is only used from class ''{0}'' #loc
static.method.only.used.in.one.class.problem.descriptor.anonymous.implementing=Static method #ref() is only used from an anonymous class implementing ''{0}'' #loc
static.method.only.used.in.one.class.problem.descriptor.anonymous.extending=Static method #ref() is only used from an anonymous class extending ''{0}'' #loc
static.method.only.used.in.one.class.quickfix=Move method
static.method.only.used.in.one.class.ignore.test.option=Ignore when only used from a test class
unary.plus.display.name=Unary plus
unary.plus.problem.descriptor=Unary #ref operator #loc
await.without.corresponding.signal.display.name='await()' without corresponding 'signal()'
await.without.corresponding.signal.problem.descriptor=Call to #ref without corresponding signal() or signalAll() #loc
signal.without.corresponding.await.display.name='signal()' without corresponding 'await()'
signal.without.corresponding.await.problem.descriptor=Call to #ref without corresponding await() #loc
wait.without.corresponding.notify.display.name='wait()' without corresponding 'notify()'
wait.without.corresponding.notify.problem.descriptor=Call to #ref without corresponding notify() or notifyAll() #loc
notify.without.corresponding.wait.display.name='notify()' without corresponding 'wait()'
notify.without.corresponding.wait.problem.descriptor=Call to #ref without corresponding wait() #loc
integer.multiplication.implicit.cast.to.long.display.name=Integer multiplication or shift implicitly cast to long
integer.multiplication.implicit.cast.to.long.problem.descriptor=#ref: integer multiplication or shift implicitly cast to long #loc
integer.multiplication.implicit.cast.to.long.option=Ignore compile time constant expressions which do not overflow
wait.or.await.without.timeout.display.name='wait()' or 'await()' without timeout
wait.or.await.without.timeout.problem.descriptor=#ref without timeout #loc
method.return.always.constant.display.name=Method returns per-class constant
method.return.always.constant.problem.descriptor=Method #ref() returns a per-class constant
class.with.too.many.dependencies.display.name=Class with too many dependencies
class.with.too.many.dependencies.problem.descriptor=Class ''{0}'' has too many dependencies ({1} > {2})
class.with.too.many.transitive.dependencies.display.name=Class with too many transitive dependencies
class.with.too.many.transitive.dependencies.problem.descriptor=Class ''{0}'' has too many transitive dependencies ({1} > {2})
class.with.too.many.dependents.display.name=Class with too many dependents
class.with.too.many.dependents.problem.descriptor=Class ''{0}'' has too many dependents ({1} > {2})
class.with.too.many.transitive.dependents.display.name=Class with too many transitive dependents
class.with.too.many.transitive.dependents.problem.descriptor=Class ''{0}'' has too many transitive dependencies ({1} > {2})
class.with.too.many.dependencies.max.option=Maximum number of dependencies
class.with.too.many.dependents.max.option=Maximum number of dependents
class.with.too.many.transitive.dependencies.max.option=Maximum number of transitive dependencies
class.with.too.many.transitive.dependents.max.option=Maximum number of transitive dependents
cyclic.class.dependency.display.name=Cyclic class dependency
cyclic.class.dependency.problem.descriptor=Class ''{0}'' is cyclically dependent on {1} other classes
cyclic.class.dependency.1.problem.descriptor=Class ''{0}'' is cyclically dependent on class ''{1}''
cyclic.class.dependency.2.problem.descriptor=Class ''{0}'' is cyclically dependent on classes ''{1}'' and ''{2}''
cyclic.package.dependency.display.name=Cyclic package dependency
cyclic.package.dependency.problem.descriptor=Package ''{0}'' is cyclically dependent on {1} other packages
cyclic.package.dependency.1.problem.descriptor=Package ''{0}'' is cyclically dependent on package ''{1}''
cyclic.package.dependency.2.problem.descriptor=Package ''{0}'' is cyclically dependent on packages ''{1}'' and ''{2}''
class.unconnected.to.package.display.name=Class independent of its package
class.unconnected.to.package.problem.descriptor=Class #ref has no dependencies or dependents in its package
package.with.too.many.classes.display.name=Package with too many classes
package.with.too.many.classes.problem.descriptor=Package ''{0}'' contains too many classes ({1} > {2})
package.with.too.many.classes.max.option=Maximum number of classes:
package.with.too.few.classes.display.name=Package with too few classes
package.with.too.few.classes.problem.descriptor=Package ''{0}'' contains too few classes ({1} < {2})
package.with.too.few.classes.min.option=Minimum number of classes:
module.with.too.many.classes.display.name=Module with too many classes
module.with.too.many.classes.problem.descriptor=Module ''{0}'' contains too many classes ({1} > {2})
module.with.too.many.classes.max.option=Maximum number of classes:
module.with.too.few.classes.display.name=Module with too few classes
module.with.too.few.classes.problem.descriptor=Module ''{0}'' contains too few classes ({1} < {2})
module.with.too.few.classes.min.option=Minimum number of classes:
package.in.multiple.modules.display.name=Package with classes in multiple modules
package.in.multiple.modules.problem.descriptor=Package ''{0}'' has classes in multiple modules
disjoint.package.display.name=Package with disjoint dependency graph
disjoint.package.problem.descriptor=Package {0} can be decomposed into {1} independent packages
package.naming.convention.display.name=Package naming convention
package.naming.convention.problem.descriptor.short=Package name {0} is too short
package.naming.convention.problem.descriptor.long=Package name {0} is too long
package.naming.convention.problem.descriptor.regex.mismatch=Package name {0} doesn''t match regex ''{1}''
cyclic.class.initialization.display.name=Cyclic class initialization dependency
cyclic.class.initialization.problem.descriptor=Initialization of class ''{0}'' is cyclically dependent on {1} other classes
before.or.after.is.public.void.no.arg.display.name=Malformed @Before or @After method
before.or.after.is.public.void.no.arg.problem.descriptor=#ref() has incorrect signature for a @Before or @After method #loc
before.class.or.after.class.is.public.static.void.no.arg.display.name=Malformed @BeforeClass or @AfterClass method
before.class.or.after.class.is.public.static.void.no.arg.problem.descriptor=#ref() has incorrect signature for a @BeforeClass or @AfterClass method #loc
string.constructor.display.name=Redundant String constructor call
string.constructor.problem.descriptor=#ref is redundant #loc
string.constructor.replace.arg.quickfix=Replace with arg
string.constructor.replace.empty.quickfix=Replace with empty string
string.constructor.substring.parameter.option=Ignore string constructor calls with a 'substring()' call argument
design.for.extension.display.name=Design for extension
design.for.extension.problem.descriptor=Method #ref() may be overridden and its functionality ignored #loc
bad.oddness.display.name=Suspicious test for oddness
bad.oddness.problem.descriptor=Test for oddness #ref will fail on negative values #loc
comparator.not.serializable.display.name=Comparator class not declared Serializable
comparator.not.serializable.problem.descriptor=Comparator class #ref is not declared as Serializable #loc
non.serializable.field.in.serializable.class.display.name=Non-serializable field in a Serializable class
non.serializable.field.in.serializable.class.problem.descriptor=Non-serializable field '#ref' in a Serializable class #loc
non.serializable.object.passed.to.object.stream.display.name=Non-serializable object passed to ObjectOutputStream
non.serializable.object.passed.to.object.stream.problem.descriptor=Non-serializable object passed to ObjectOutputStream #loc
non.serializable.object.bound.to.http.session.display.name=Non-serializable object bound to HttpSession
non.serializable.object.bound.to.http.session.problem.descriptor=Non-serializable object bound to HttpSession #loc
reflection.for.unavailable.annotation.display.name=Reflective access to a source-only annotation
reflection.for.unavailable.annotation.problem.descriptor=Annotation '#ref' is not retained for reflective access #loc
access.to.static.field.locked.on.instance.display.name=Access to static field locked on instance data
access.to.static.field.locked.on.instance.problem.descriptor=Access to static field #ref locked on instance data #loc
make.method.ctr.quickfix=Make method constructor
replace.all.dot.display.name=Call to String.replaceAll(".", ...)
replace.all.dot.problem.descriptor=Call to String.#ref(".", ...) #loc
constant.string.intern.display.name=Call to 'intern()' on String constant
constant.string.intern.problem.descriptor=.#ref() on compile-time constant is unnecessary #loc
constant.string.intern.quickfix=Remove 'intern()' call
class.extends.utility.class.display.name=Class extends utility class
class.extends.utility.class.problem.descriptor=Class #ref extends utility class ''{0}'' #loc
class.extends.utility.class.ignore.utility.class.option=Ignore if overriding class is a utility class
public.constructor.in.non.public.class.quickfix=Make constructor ''{0}''
assignment.to.method.parameter.ignore.transformation.option=Ignore if assignment is a transformation of the original parameter
type.parameter.extends.final.class.display.name=Type parameter extends final class
type.parameter.extends.final.class.problem.descriptor1=Type parameter #ref extends ''final'' class ''{0}'' #loc
type.parameter.extends.final.class.problem.descriptor2=Wildcard type argument #ref extends ''final'' class ''{0}'' #loc
type.parameter.extends.final.class.quickfix=Replace type parameter with actual class
double.negation.display.name=Double negation
double.negation.problem.descriptor=Double negation in #ref #loc
double.negation.quickfix=Remove double negation
exception.from.catch.which.doesntwrap.ignore.option=Ignore if result of exception method call is used
exception.from.catch.which.doesntwrap.ignore.cant.wrap.option=Ignore if thrown exception cannot wrap an exception
comparable.implemented.but.equals.not.overridden.display.name=Comparable implemented but 'equals()' not overridden
comparable.implemented.but.equals.not.overridden.problem.descriptor=Class #ref implements 'java.lang.Comparable' but does not override 'equals()' #loc
unqualified.field.access.display.name=Instance field access not qualified with 'this'
unqualified.field.access.problem.descriptor=Instance field access #ref is not qualified with 'this' #loc
unqualified.method.access.display.name=Instance method call not qualified with 'this'
unqualified.method.access.problem.descriptor=Instance method call #ref is not qualified with 'this' #loc
add.this.qualifier.quickfix=Add 'this' qualifier
while.loop.spins.on.field.ignore.non.empty.loops.option=Only warn if the loop is empty
method.may.be.synchronized.problem.descriptor=Method #ref() with synchronized block could be synchronized method #loc
method.may.be.synchronized.display.name=Method with synchronized block could be synchronized method
method.may.be.synchronized.quickfix=Make method synchronized and remove synchronized block
fallthru.in.switch.statement.quickfix=Add 'break'
law.of.demeter.display.name=Method call violates Law of Demeter
law.of.demeter.problem.descriptor=#ref() call violates Law of Demeter #loc
law.of.demeter.ignore.library.calls.option=Ignore calls on library methods
assertequals.between.inconvertible.types.display.name='assertEquals()' between objects of inconvertible types
assertequals.between.inconvertible.types.problem.descriptor=#ref() between objects of inconvertible types ''{0}'' and ''{1}'' #loc
enumeration.can.be.iteration.display.name=Enumeration can be iteration
enumeration.can.be.iteration.problem.descriptor=#ref() can be replaced with ''{0}'' construct #loc
enumeration.can.be.iteration.quickfix=Replace with 'Iterator' construct
equals.hashcode.called.on.url.display.name='equals()' or 'hashCode()' called on java.net.URL object
equals.hashcode.called.on.url.problem.descriptor=Call to #ref() on URL object #loc
collection.contains.url.problem.decriptor={0} #ref may contain URL objects #loc
collection.contains.url.display.name=Map or Set may contain java.net.URL objects
implicit.array.to.string.problem.descriptor=Implicit call to 'toString()' on array #ref #loc
explicit.array.to.string.problem.descriptor=Call to '#ref()' on array #loc
implicit.array.to.string.method.call.problem.descriptor=Implicit call to 'toString()' on array returned by call to #ref #loc
implicit.array.to.string.display.name=Call to 'toString()' on array
implicit.array.to.string.quickfix=Wrap with ''{0}'' expression
suspicious.indent.after.control.statement.problem.descriptor=#ref statement has suspicious indentation #loc
suspicious.indent.after.control.statement.display.name=Suspicious indentation after control statement without braces
unpredictable.big.decimal.constructor.call.display.name=Unpredictable BigDecimal constructor call
unpredictable.big.decimal.constructor.call.problem.descriptor=Unpredictable new #ref() call #loc
unpredictable.big.decimal.constructor.call.ignore.references.option=Ignore constructor calls with variable or method call arguments
unpredictable.big.decimal.constructor.call.ignore.complex.literals.option=Ignore constructor calls with multiple literals (e.g. 0.1 + 0.2)
unpredictable.big.decimal.constructor.call.quickfix=Replace with ''{0}''
unnecessary.unary.minus.display.name=Unnecessary unary minus
unnecessary.unary.minus.problem.descriptor=Unnecessary unary minus #loc
unnecessary.unary.minus.quickfix=Remove unary minus and invert parent operation sign
make.field.final.quickfix=Make ''{0}'' ''final''
increment.decrement.used.as.expression.quickfix=Extract ''{0}'' to separate statement
ignore.classes.in.hierarchy.column.name=Ignore subclasses of
overly.strong.type.cast.ignore.in.matching.instanceof.option=Ignore casts with a matching instanceof expression
return.of.collection.field.quickfix=Replace with ''{0}''
access.to.non.thread.safe.static.field.from.instance.display.name=Non thread-safe static field access
access.to.non.thread.safe.static.field.from.instance.field.problem.descriptor=Access to non thread-safe static field #ref of type ''{0}'' #loc
access.to.non.thread.safe.static.field.from.instance.option.title=Non thread safe classes
access.to.non.thread.safe.static.field.from.instance.class.chooser.title=Choose non thread safe class
transient.field.not.initialized.display.name=Transient field is not initialized on deserialization
transient.field.not.initialized.problem.descriptor=Transient field #ref not initialized on deserialization #loc
call.to.string.concat.can.be.replaced.by.operator.display.name=Call to 'String.concat()' can be replaced with '+'
call.to.string.concat.can.be.replaced.by.operator.problem.descriptor=Call to #ref() can be replaced with '+' expression #loc
call.to.string.concat.can.be.replaced.by.operator.quickfix=Replace 'concat()' call with '+'
new.string.buffer.with.char.argument.display.name=StringBuffer constructor call with 'char' argument
new.string.buffer.with.char.argument.problem.descriptor=new #ref() with argument of type 'char' #loc
new.string.buffer.with.char.argument.quickfix=Replace char argument with String literal
comparator.method.parameter.not.used.display.name='Comparator.compare()' method does not use parameter
comparator.method.parameter.not.used.problem.descriptor='compare()' parameter #ref is not used #loc
to.array.call.with.zero.length.array.argument.display.name=Call to 'Collection.toArray()' with zero-length array argument
to.array.call.with.zero.length.array.argument.problem.descriptor=Call to #ref() with zero-length array argument ''{0}'' #loc
to.array.call.with.zero.length.array.argument.quickfix=Replace argument with correctly sized array
throwable.instance.never.thrown.display.name=Throwable instance not thrown
throwable.instance.never.thrown.runtime.exception.problem.descriptor=Runtime exception instance #ref is not thrown #loc
throwable.instance.never.thrown.checked.exception.problem.descriptor=Checked exception instance #ref is not thrown #loc
throwable.instance.never.thrown.error.problem.descriptor=Error instance #ref is not thrown #loc
throwable.instance.never.thrown.problem.descriptor=Throwable instance #ref is not thrown #loc
type.may.be.weakened.display.name=Type may be weakened
type.may.be.weakened.problem.descriptor=Type of variable #ref may be weakened to {0} #loc
type.may.be.weakened.method.problem.descriptor=Return type of method #ref() may be weakened to {0} #loc
type.may.be.weakened.parameter.problem.descriptor=Type of parameter #ref may be weakened to {0} #loc
type.may.be.weakened.field.problem.descriptor=Type of field #ref may be weakened to {0} #loc
type.may.be.weakened.quickfix=Weaken type to ''{0}''
type.may.be.weakened.ignore.option=Use &righthand type as weakest type in assignments
type.may.be.weakened.collection.method.option=Use ¶meterized type of collection for method call arguments
type.may.be.weakened.do.not.weaken.to.object.option=Do not &weaken to 'java.lang.Object'
ignore.guard.clauses.option=Ignore &guard clauses
ignore.for.equals.methods.option=Ignore for '&equals()' methods
caught.exception.immediately.rethrown.display.name=Caught exception is immediately rethrown
caught.exception.immediately.rethrown.problem.descriptor=Caught exception #ref is immediately rethrown #loc
delete.catch.section.quickfix=Delete 'catch' section
remove.try.catch.quickfix=Remove 'try catch' statement
loop.with.implicit.termination.condition.display.name=Loop with implicit termination condition
loop.with.implicit.termination.condition.dowhile.problem.descriptor=#ref-while loop with implicit termination condition #loc
loop.with.implicit.termination.condition.problem.descriptor=#ref loop with implicit termination condition #loc
loop.with.implicit.termination.condition.quickfix=Make condition explicit
ignore.iterator.loop.variables=Ignore java.util.Iterator loop variables
rename.catch.parameter.to.ignored=Rename 'catch' parameter to 'ignored'
unnecessary.super.qualifier.display.name=Unnecessary 'super' qualifier
unnecessary.super.qualifier.problem.descriptor=Qualifier #ref is unnecessary in this context #loc
unnecessary.super.qualifier.quickfix=Remove unnecessary 'super' qualifier
collections.field.access.replaceable.by.method.call.display.name=Collections.EMPTY_* field access replaceable with 'Collections.empty*()' method call
collections.field.access.replaceable.by.method.call.problem.descriptor=#ref replaceable with ''Collections.{0}'' #loc
collections.field.access.replaceable.by.method.call.quickfix=Replace with ''{0}''
synchronization.on.local.variable.or.method.parameter.display.name=Synchronization on local variable or method parameter
synchronization.on.local.variable.problem.descriptor=Synchronization on local variable #ref #loc
synchronization.on.method.parameter.problem.descriptor=Synchronization on method parameter #ref #loc
too.broad.catch.quickfix=Add ''catch'' clause for ''{0}''
replace.with.catch.clause.for.runtime.exception.quickfix=Replace with 'catch' clause for 'RuntimeException'
too.broad.catch.option=&Only warn on RuntimeException, Exception, Error or Throwable
unnecessary.call.to.string.valueof.display.name=Unnecessary call to 'String.valueOf()'
unnecessary.tostring.call.display.name=Unnecessary call to 'toString()'
unnecessary.call.to.string.valueof.problem.descriptor=#ref can be simplified to ''{0}'' #loc
unnecessary.tostring.call.problem.descriptor=Unnecessary #ref() call #loc
unnecessary.call.to.string.valueof.quickfix=Replace with ''{0}''
throwable.result.of.method.call.ignored.display.name=Throwable result of method call ignored
throwable.result.of.method.call.ignored.problem.descriptor=Result of #ref() not thrown #loc
char.used.in.arithmetic.context.display.name=Char expression used in arithmetic context
char.used.in.arithmetic.context.problem.descriptor='char' #ref used in arithmetic context #loc
char.used.in.arithmetic.context.quickfix=Convert to String literal
char.used.in.arithmetic.context.cast.quickfix=Insert cast to {0}
unnecessary.constant.array.creation.expression.display.name=Constant array creation expression can be replaced with array initializer
unnecessary.constant.array.creation.expression.problem.descriptor=#ref can be replaced with array initializer expression #loc
unnecessary.constant.array.creation.expression.quickfix=Replace with array initializer expression
ambiguous.method.call.display.name=Inherited method called, while local method might have been expected
ambiguous.method.call.problem.descriptor=Method #ref() from superclass ''{0}'' called, when method from class ''{1}'' might have been expected #loc
ambiguous.method.call.quickfix=Add 'super' qualifier to method call
change.modifier.quickfix=Make ''{0}''
the.whole.project=the whole project
this.class=this class
assertequals.may.be.assertsame.display.name='assertEquals()' may be 'assertSame()'
assertequals.may.be.assertsame.problem.descriptor=#ref() may be 'assertSame()' #loc
logger.initialized.with.foreign.class.quickfix=Replace with ''{0}.class''
logger.initialized.with.foreign.class.problem.descriptor=Logger initialized with foreign class #ref #loc
logger.initialized.with.foreign.class.display.name=Logger initialized with foreign class
logger.factory.method.name=Logger factory method name
logger.factory.class.name=Logger factory class name
make.static.final.quickfix=Make ''{0}'' static final
logging.condition.disagrees.with.log.statement.display.name=Log condition does not match logging call
logging.condition.disagrees.with.log.statement.problem.descriptor=Log condition #ref() does not match ''{0}()'' logging call #loc
log.statement.guarded.by.log.condition.display.name=Logging call not guarded by log condition
log.statement.guarded.by.log.condition.problem.descriptor=#ref() logging calls not guarded by log condition #loc
log.statement.guarded.by.log.condition.quickfix=Surround with log condition
log.statement.guarded.by.log.condition.flag.all.unguarded.option=Flag all unguarded logging calls
key.set.iteration.may.use.entry.set.display.name=Iteration over 'keySet()' may be replaced with 'entrySet()' iteration
key.set.iteration.may.use.entry.set.problem.descriptor=Iteration over #ref may be replaced with 'entrySet()' iteration #loc
key.set.iteration.may.use.entry.set.quickfix=Replace with 'entrySet()' iteration
string.replaceable.by.string.buffer.in.loop.option=Only warn when appending in a loop
declare.collection.as.interface.quickfix=Weaken to ''{0}''
non.exception.name.ends.with.exception.quickfix=Make ''{0}'' extend ''java.lang.Exception''
constant.value.variable.use.display.name=Use of variable whose value is known to be constant
constant.value.variable.use.problem.descriptor=Value of #ref is known to be constant #loc
replace.reference.with.expression.quickfix=Replace with ''{0}''
unnecessary.parentheses.option=Ignore clarifying parentheses
unnecessary.parentheses.conditional.option=Ignore parentheses around the condition of conditional expressions
field.may.be.final.display.name=Field may be 'final'
field.may.be.final.problem.descriptor=Field #ref may be 'final' #loc
cast.that.loses.precision.option=Ignore casts from int to char
variable.not.used.inside.if.display.name=Reference checked for 'null' is not used inside 'if'
variable.not.used.inside.if.problem.descriptor=#ref checked for 'null' is not used inside 'if' #loc
variable.not.used.inside.conditional.problem.descriptor=#ref checked for 'null' is not used inside conditional #loc
if.may.be.conditional.display.name='if' statement could be replaced with conditional expression
if.may.be.conditional.problem.descriptor=#ref could be replaced with conditional expression #loc
if.may.be.conditional.quickfix=Replace with conditional expression
if.may.be.conditional.report.method.calls.option=Report if statements containing method calls
redundant.string.format.call.display.name=Redundant call to 'String.format()'
redundant.string.format.call.problem.descriptor=Redundant call to #ref #loc
redundant.string.format.call.quickfix=Remove redundant call to 'String.format()'
junit4.test.method.in.class.extending.junit3.testcase.display.name=JUnit 4 test method in class extending JUnit 3 TestCase
junit4.test.method.in.class.extending.junit3.testcase.problem.descriptor=Method #ref() annotated with '@Test' inside class extending JUnit 3 TestCase #loc
ignore.test.method.in.class.extending.junit3.testcase.problem.descriptor=JUnit 3 test method #ref() annotated with '@Ignore' won't be ignored #loc
ignore.test.method.in.class.extending.junit3.testcase.quickfix=Remove ''@Ignore'' and rename method to ''{0}''
convert.junit3.test.class.quickfix=Convert JUnit 3 class ''{0}'' to JUnit 4
remove.junit4.test.annotation.quickfix=Remove '@Test' annotation
remove.junit4.test.annotation.and.rename.quickfix=Remove '@Test' annotation and rename to ''{0}''
equals.called.on.enum.constant.display.name='equals()' called on Enum value
equals.called.on.enum.constant.problem.descriptor=#ref() called on Enum value #loc
equals.called.on.enum.constant.quickfix=Replace 'equals()' with '=='
int.literal.may.be.long.literal.display.name='int' literal cast to 'long' could be 'long' literal
int.literal.may.be.long.literal.problem.descriptor=#ref could be replaced with ''{0}'' #loc
int.literal.may.be.long.literal.quickfix=Replace with ''{0}''
constant.assert.condition.display.name='assert' statement condition is constant
constant.assert.condition.problem.descriptor=Assert condition #ref is constant #loc
assert.with.side.effects.display.name='assert' statement with side effects
assert.with.side.effects.problem.descriptor=#ref has side effects #loc
method.count.ignore.getters.setters.option=&Ignore simple getter and setter methods
class.new.instance.display.name=Unsafe call to 'Class.newInstance()'
class.new.instance.problem.descriptor=Call to #ref() may throw undeclared checked exceptions #loc
class.new.instance.quickfix=Replace with 'Class.getConstructor().newInstance()' call
dynamic.regex.replaceable.by.compiled.pattern.display.name=Dynamic regular expression could be replaced by compiled Pattern
dynamic.regex.replaceable.by.compiled.pattern.problem.descriptor=#ref() could be replaced with compiled java.util.regex.Pattern construct #loc
dynamic.regex.replaceable.by.compiled.pattern.quickfix=Replace with call to method of compiled 'Pattern' constant
ignore.serializable.option=Ignore java.io.Serializable
ignore.cloneable.option=Ignore 'java.lang.Cloneable'
listener.may.use.adapter.display.name=Class may extend adapter instead of implementing listener
listener.may.use.adapter.problem.descriptor=Class ''{0}'' may extend ''{1}'' instead of implementing #ref #loc
listener.may.use.adapter.quickfix=Replace with ''extends {0}''
listener.may.use.adapter.emtpy.methods.option=&Only warn when empty implementing methods are found
unnecessary.inherit.doc.display.name=Unnecessary {@inheritDoc} Javadoc Comment
unnecessary.inherit.doc.problem.descriptor=Javadoc comment containing only #ref is unnecessary #loc
unnecessary.inherit.doc.quickfix=Remove unnecessary @inheritDoc
multiple.exceptions.declared.on.test.method.display.name=Multiple exceptions declared on test method
multiple.exceptions.declared.on.test.method.problem.descriptor=#ref could be replaced with 'throws Exception' #loc
multiple.exceptions.declared.on.test.method.quickfix=Replace with 'throws Exception'
unnecessary.javadoc.link.display.name=Unnecessary Javadoc link
unnecessary.javadoc.link.super.method.problem.descriptor=#ref pointing to super method is unnecessary #loc
unnecessary.javadoc.link.this.method.problem.descriptor=#ref pointing to this method is unnecessary #loc
unnecessary.javadoc.link.this.class.problem.descriptor=#ref pointing to containing class is unnecessary #loc
unnecessary.javadoc.link.quickfix=Remove unnecessary '{0}'
thread.local.not.static.final.display.name=ThreadLocal field not declared static final
thread.local.not.static.final.problem.descriptor=ThreadLocal #ref is not declared 'static final' #loc
remove.try.finally.block.quickfix=Remove 'try-finally' block
remove.finally.block.quickfix=Remove 'finally' block
remove.leading.zero.to.make.decimal.quickfix=Remove leading zero to make decimal
convert.octal.literal.to.decimal.literal.quickfix=Convert octal literal to decimal literal
ignore.single.field.static.imports.option=Ignore single &field static imports
ignore.single.method.static.imports.option=Ignore single &method static imports
ignore.methods.with.boolean.return.type.option=Ignore methods with &Boolean return type
ignore.boolean.methods.in.an.interface.option=Ignore boolean methods in an @&interface
ignore.methods.overriding.super.method=Ignore methods &overriding/implementing a super method
ignore.nullable.parameters.option=Ignore @Nullable parameters
ignored.io.resource.types=Ignored I/O resource types
choose.io.resource.type.to.ignore=Choose I/O resource type to ignore
ignore.accesses.from.the.same.class=Ignore accesses from the same class
ignore.accesses.from.equals.method=Ignore accesses from 'equals()' method
ignore.branches.of.switch.statements=Ignore branches of 'switch' statements
ignore.equals.hashcode.and.tostring=Ignore 'equals()', 'hashCode()' and 'toString()' methods
ignore.methods.in.anonymous.classes=Ignore methods in anonymous classes
class.name=Class name
method.name.pattern=Method name pattern
query.column.name=Query names start with
update.column.name=Update names start with
assert.keyword.is.considered.an.assertion='assert' keyword is considered an assertion
expected.exception.never.thrown.display.name=Expected exception never thrown in test method body
expected.exception.never.thrown.problem.descriptor=Expected #ref never thrown in body of ''{0}()'' #loc
choose.logger.class=Choose logger class
logger.class.name=Logger class name
ignore.exceptions.declared.on.library.override.option=Ignore exceptions declared on methods overriding a &library method
allow.resource.to.be.opened.inside.a.try.block=Allow resource to be opened inside a 'try' block
log.method.name=Logging method name
log.condition.text=Log condition text
ignore.if.annotated.by=Ignore if annotated by
only.weaken.to.an.interface=Only weaken to an interface
unqualified.inner.class.access.display.name=Unqualified inner class access
unqualified.inner.class.access.problem.descriptor=#ref is not qualified with outer class #loc
unqualified.inner.class.access.quickfix=Qualify with outer class
unnecessarily.qualified.inner.class.access.problem.descriptor=''{0}'' is unnecessarily qualified with #ref #loc
unnecessarily.qualified.inner.class.access.display.name=Unnecessarily qualified inner class access
unnecessarily.qualified.inner.class.access.quickfix=Remove qualifier
synchronization.on.static.field.display.name=Synchronization on 'static' field
synchronization.on.static.field.problem.descriptor=Synchronization on 'static' field #ref #loc
assertequals.called.on.arrays.display.name='assertEquals()' called on array
assertequals.called.on.arrays.problem.descriptor=#ref() called on array #loc
assertequals.called.on.arrays.quickfix=Replace with 'assertArrayEquals()'
overly.broad.throws.clause.display.name=Overly broad 'throws' clause
overly.broad.throws.clause.problem.descriptor1=throws #ref is too broad, masking exception ''{0}'' #loc
overly.broad.throws.clause.problem.descriptor2=throws #ref is too broad, masking exceptions ''{0}'' and ''{1}'' #loc
overly.broad.throws.clause.quickfix1=Add specific exceptions
overly.broad.throws.clause.quickfix2=Replace with specific exceptions
overly.broad.throws.clause.ignore.thrown.option=Ignore exceptions which &hide others but are themselves thrown
unnecessarily.qualified.statically.imported.element.display.name=Unnecessarily qualified statically imported element
unnecessarily.qualified.statically.imported.element.problem.descriptor=Statically imported element ''{0}'' is unnecessarily qualified with #ref #loc
unnecessarily.qualified.statically.imported.element.quickfix=Remove unnecessary qualifier
ignore.instanceof.on.library.classes=Ignore instanceof on library classes
assertequals.may.be.assertsame.quickfix=Replace with 'assertSame()'
for.can.be.foreach.option=Report indexed 'java.util.List' loops
for.can.be.foreach.option2=Do not report iterations over untyped collections
cast.conflicts.with.instanceof.quickfix1=Replace ''{0}'' with ''{1}'' in cast
cast.conflicts.with.instanceof.quickfix2=Replace ''{0}'' with ''{1}'' in instanceof
double.checked.locking.quickfix=Make ''{0}'' 'volatile'
double.literal.may.be.float.literal.display.name='double' literal cast to 'float' could be 'float' literal
double.literal.may.be.float.literal.problem.descriptor=#ref could be replaced with ''{0}'' #loc
double.literal.may.be.float.literal.quickfix=Replace with ''{0}''
multiple.declaration.option=Ignore 'for' loop declarations
simplifiable.annotation.display.name=Simplifiable annotation
simplifiable.annotation.problem.descriptor=Unnecessary #ref in annotation #loc
simplifiable.annotation.whitespace.problem.descriptor=Unnecessary whitespace in annotation #loc
simplifiable.annotation.quickfix=Simplify annotation
overloaded.methods.with.same.number.parameters.option=Ignore overloaded methods whose parameter types are definitely incompatible
string.concatenation.in.format.call.display.name=String concatenation as argument to 'format()' call
string.concatenation.in.format.call.problem.descriptor=#ref() call has a String concatenation argument #loc
string.concatenation.in.format.call.quickfix=Replace concatenation with separate argument
string.concatenation.in.format.call.plural.quickfix=Replace concatenation with separate arguments
string.concatenation.in.message.format.call.display.name=String concatenation as argument to 'MessageFormat.format()' call
string.concatenation.in.message.format.call.problem.descriptor=String concatenation as argument to 'MessageFormat.format()' call #loc
shift.out.of.range.quickfix=Replace ''{0}'' with ''{1}''
boxing.boxed.value.display.name=Boxing of already boxed value
boxing.boxed.value.problem.descriptor=Boxing of already boxed #ref #loc
boxing.boxed.value.quickfix=Remove unnecessary boxing
unnecessary.javadoc.link.option=Ignore inline links to super methods
constant.junit.assert.argument.display.name=Constant JUnit assert argument
constant.junit.assert.argument.problem.descriptor=Argument #ref is constant #loc
test.case.with.no.test.methods.option=Ignore test cases which have superclasses with test methods
package.dot.html.may.be.package.info.display.name='package.html' may be converted to 'package-info.java'
package.dot.html.may.be.package.info.exists.problem.descriptor=package.html is ignored because package-info.java exists
package.dot.html.may.be.package.info.problem.descriptor=package.html may be converted to package-info.java
package.dot.html.may.be.package.info.delete.quickfix=Delete 'package.html'
package.dot.html.delete.command=package.html deletion
package.dot.html.may.be.package.info.convert.quickfix=Convert to 'package-info.java'
package.dot.html.convert.command=package.html to package-info.java conversion
choose.super.class.to.ignore=Choose class
ignore.anonymous.inner.classes=Ignore anonymous inner classes
try.with.identical.catches.display.name=Identical 'catch' branches in 'try' statement
try.with.identical.catches.problem.descriptor='catch' branch identical to ''{0}'' branch #loc
if.can.be.switch.display.name='if' replaceable with 'switch'
if.can.be.switch.problem.descriptor=#ref statement replaceable with 'switch' statement #loc
if.can.be.switch.quickfix=Replace with 'switch'
if.can.be.switch.minimum.branch.option=Minimum number of branches:
if.can.be.switch.int.option=Suggest switch on numbers
if.can.be.switch.enum.option=Suggest switch on enums
if.can.be.switch.null.safe.option=Only suggest on null-safe expressions
unnecessarily.qualified.inner.class.access.option=Ignore references for which an import is needed
unqualified.inner.class.access.option=Ignore references to local inner classes
try.with.identical.catches.quickfix=Collapse 'catch' blocks
confusing.else.option=Also report when there are no more statements after the 'if' statement
html.tag.can.be.javadoc.tag.display.name=... can be replaced with {@code ...}
html.tag.can.be.javadoc.tag.problem.descriptor=#ref...\\</code\\> can be replaced with '{@code ...}' #loc
html.tag.can.be.javadoc.tag.quickfix=Replace with '{@code ...}'
try.finally.can.be.try.with.resources.display.name='try finally' replaceable with 'try' with resources
try.finally.can.be.try.with.resources.problem.descriptor=#ref can use automatic resource management #loc
try.finally.can.be.try.with.resources.quickfix=Replace with 'try' with resources
array.comparison.display.name=Array comparison using '==', instead of 'Arrays.equals()'
array.comparison.problem.descriptor=Array objects are compared using #ref, not 'Arrays.equals()' #loc
array.hash.code.display.name='hashCode()' called on array
array.hash.code.problem.descriptor=#ref() called on array should probably be 'Arrays.hashCode()' #loc
arrays.deep.hash.code.quickfix=Replace with 'Arrays.deepHashCode()'
arrays.hash.code.quickfix=Replace with 'Arrays.hashCode()'
method.can.be.variable.arity.method.display.name=Method can be variable arity method
method.can.be.variable.arity.method.problem.descriptor=#ref() can be converted to variable arity method #loc
method.can.be.variable.arity.method.ignore.byte.short.option=Ignore methods with a last parameter of type byte[] or short[]
method.can.be.variable.arity.method.ignore.multiple.arrays.option=Ignore methods with multiple array parameters
convert.to.variable.arity.method.quickfix=Convert to varargs method
mismatched.string.builder.query.update.display.name=Mismatched query and update of StringBuilder
mismatched.string.builder.updated.problem.descriptor=Contents of {0} #ref are updated, but never queried #loc
mismatched.string.builder.queried.problem.descriptor=Contents of {0} #ref are queried, but never updated #loc
math.random.cast.to.int.display.name='Math.random()' cast to 'int'
math.random.cast.to.int.problem.descriptor=#ref cast to 'int' is always rounded down to '0' #loc
math.random.cast.to.int.quickfix=Add parentheses to perform multiplication before cast
boolean.variable.always.inverted.display.name=Boolean variable is always inverted
boolean.field.always.inverted.problem.descriptor=Boolean field #ref is always inverted #loc
boolean.variable.always.inverted.problem.descriptor=Boolean variable #ref is always inverted #loc
unnecessary.explicit.numeric.cast.display.name=Unnecessary explicit numeric cast
unnecessary.explicit.numeric.cast.problem.descriptor=''{0}'' unnecessarily cast to #ref #loc
unnecessary.explicit.numeric.cast.quickfix=Remove cast
null.thrown.display.name='null' thrown
null.thrown.problem.descriptor=#ref thrown #loc
null.thrown.quickfix=Replace with 'new NullPointerException()'
element.only.used.from.test.code.display.name=Symbol only used from test code
class.only.used.from.test.code.problem.descriptor=class #ref only used from test code #loc
method.only.used.from.test.code.problem.descriptor=method #ref() only called from test code #loc
field.only.used.from.test.code.problem.descriptor=field #ref only accessed from test code #loc
unnecessary.final.on.local.variable.or.parameter.display.name=Unnecessary 'final' on local variable or parameter
unnecessary.final.on.local.variable.problem.descriptor=Unnecessary #ref on variable ''{0}'' #loc
unnecessary.final.on.parameter.problem.descriptor=Unnecessary #ref on parameter ''{0}'' #loc
unnecessary.final.report.local.variables.option=Report local variables
unnecessary.final.report.parameters.option=Report parameters
unnecessary.final.on.parameter.only.interface.option=Only warn on abstract or interface methods
choose.exception.class=Choose Exception class
class.independent.of.module.display.name=Class independent of its module
class.independent.of.module.problem.descriptor=Class #ref has no dependencies or dependents in its module #loc
class.only.used.in.one.module.display.name=Class only used from one other module
class.only.used.in.one.module.problem.descriptor=Class #ref has only dependencies on and/or dependents in module ''{0}'' #loc
empty.directory.display.name=Empty directory
empty.directories.problem.descriptor=Empty directory {0}
empty.directories.only.under.source.roots.option=Only report empty directories located under a source folder
empty.directories.delete.quickfix=Delete empty directory ''{0}''
simplifiable.equals.expression.display.name=Unnecessary 'null' check before 'equals()' call
simplifiable.equals.expression.problem.descriptor=Unnecessary ''null'' check before ''{0}()'' call #loc
simplifiable.equals.expression.quickfix=Flip ''.{0}()'' and remove unnecessary ''null'' check
cast.to.concrete.class.option=Ignore casts to an abstract class type
cast.to.concrete.class.ignore.equals.option=Ignore in equals()
instanceof.interfaces.option=Ignore instanceof abstract class
instance.variable.of.concrete.class.option=Ignore instance fields whose type is an abstract class
local.variable.of.concrete.class.option=Ignore local variables whose type is an abstract class
method.return.of.concrete.class.option=Ignore methods whose return type is an abstract class
parameter.of.concrete.class.option=Ignore parameters whose type is abstract class
static.variable.of.concrete.class.option=Ignore static fields whose type is an abstract class
class.only.used.in.one.package.display.name=Class only used from one other package
class.only.used.in.one.package.problem.descriptor=Class #ref has only dependencies on and/or dependents in package ''{0}'' #loc
unnecessary.return.option=Ignore in then branch of 'if' statement with 'else' branch
usage.of.obsolete.assert.display.name=Usage of obsolete 'junit.framework.Assert'
use.of.obsolete.assert.problem.descriptor=Call to #ref() from 'junit.framework.Assert' should be replaced with call to method from 'org.junit.Assert' #loc
use.of.obsolete.assert.quickfix=Replace with 'org.junit.Assert' method call
properties.object.as.hashtable.set.quickfix=Replace with call to 'setProperty()'
properties.object.as.hashtable.get.quickfix=Replace with call to 'getProperty()'
ignored.junit.test.display.name=JUnit test annotated with '@Ignore'
ignored.junit.test.classproblem.descriptor=Test class ''{0}'' annotated with #ref #loc
ignored.junit.test.method.problem.descriptor=Test method ''{0}()'' annotated with #ref #loc
unclear.binary.expression.display.name=Unclear expression
unclear.binary.expression.problem.descriptor=Expression could use clarifying parentheses #loc
unclear.binary.expression.quickfix=Add clarifying parentheses
new.exception.without.arguments.display.name=Exception constructor called without arguments
new.exception.without.arguments.problem.descriptor=new #ref() without arguments #loc
new.exception.without.arguments.ignore.option=Ignore for exceptions that have no constructors with parameters
absolute.alignment.in.user.interface.display.name=Absolute alignment used in AWT/Swing code
absolute.alignment.in.user.interface.problem.descriptor=Absolute alignment constant {0}.#ref used #loc
absolute.alignment.in.user.interface.quickfix=Replace with ''{0}.{1}''
throws.runtime.exception.display.name=Unchecked exception declared in 'throws' clause
throws.runtime.exception.problem.descriptor=Unchecked exception #ref declared in 'throws' clause #loc
throws.runtime.exception.quickfix=Remove ''{0}'' from ''throws'' clause
throws.runtime.exception.move.quickfix=Move ''{0}'' to Javadoc ''@throws'' tag
empty.class.ignore.parameterization.option=Ignore class if it is a parameterization of a super type
ambiguous.field.access.display.name=Inherited field accessed while local variable, parameter or field access from surrounding class might be expected
ambiguous.field.access.hides.local.variable.problem.descriptor=Field #ref from superclass ''{0}'' accessed, while local variable access might be expected #loc
ambiguous.field.access.hides.parameter.problem.descriptor=Field #ref from superclass ''{0}'' accessed, while parameter access might be expected #loc
ambiguous.field.access.hides.field.problem.descriptor=Field #ref from superclass ''{0}'' accessed, while field access from surrounding class might be expected #loc
ambiguous.field.access.quickfix=Add 'super' qualifier to field access
string.builder.replaceable.by.string.quickfix=Replace 'StringBuilder' with 'String'
string.buffer.replaceable.by.string.quickfix=Replace 'StringBuffer' with 'String'
add.0.to.ignore.if.annotated.by.list.quickfix=Add ''{0}'' to ''Ignore if annotated by'' list
non.final.field.in.enum.display.name=Non-'final' field in enum
non.final.field.in.enum.problem.descriptor=non-''final'' field #ref in enum ''{0}'' #loc
externalizable.without.public.no.arg.constructor.display.name=Externalizable class without public no-arg constructor
externalizable.without.public.no.arg.constructor.problem.descriptor=Externalizable class #ref has no public no-arg constructor #loc
make.constructor.public=Make constructor 'public'
string.concatenation.missing.whitespace.display.name=String literal concatenation missing whitespace
string.concatenation.missing.whitespace.problem.descriptor=String literal concatenation missing whitespace #loc
string.concatenation.missing.whitespace.option=Ignore when one or both sides are not literals
negated.equality.expression.display.name=Negated equality expression
negated.equality.expression.problem.descriptor=Negating ''{0}'' #loc
negated.equality.expression.quickfix=Remove negation
negated.conditional.expression.display.name=Negated conditional expression
negated.conditional.expression.problem.descriptor=Negating conditional expression #loc
negated.conditional.expression.quickfix=Remove negation
suspicious.array.cast.display.name=Suspicious array cast
suspicious.array.cast.problem.descriptor=Suspicious cast to #ref #loc
public.constructor.display.name='public' constructor
public.default.constructor.problem.descriptor=Class #ref has public default constructor
public.constructor.problem.descriptor=Public constructor #ref() #loc
public.constructor.quickfix=Replace constructor with factory method
junit3.style.test.method.in.junit4.class.display.name=Old style JUnit test method in JUnit 4 class
junit3.style.test.method.in.junit4.class.problem.descriptor=Old style JUnit test method #ref() in JUnit 4 class #loc
none=none
private=private
package.local.private=package local \\& private
protected.package.local.private=protected, package local \\& private
non.final.utility.class.display.name=Utility class is not final
non.final.utility.class.problem.descriptor=Utility class #ref is not 'final' #loc
0.will.no.longer.be.overridable.by.1={0} will no longer be overridable by {1}
0.will.have.incompatible.access.privileges.with.super.1={0} will have incompatible access privileges with super {1}
0.will.no.longer.be.visible.from.overriding.1={0} will no longer be visible from overriding {1}
make.private.quickfix=Make 'private'
arrays.as.list.with.zero.or.one.argument.display.name=Call to 'Arrays.asList()' with too few arguments
arrays.as.list.with.one.argument.problem.descriptor=Call to #ref with only one argument #loc
arrays.as.list.with.zero.arguments.problem.descriptor=Call to #ref with zero arguments #loc
arrays.as.list.with.one.argument.quickfix=Replace with call to 'Collections.singletonList()'
arrays.as.list.with.zero.arguments.quickfix=Replace with call to 'Collections.emptyList()'
ignore.classes.extending.throwable.option=Ignore classes extending 'Throwable'
string.concatenation.argument.to.log.call.display.name=Non-constant string concatenation as argument to logging call
string.concatenation.argument.to.log.call.problem.descriptor=Non-constant string concatenation as argument to #ref() logging call #loc
string.concatenation.argument.to.log.call.quickfix=Replace concatenation with parameterized log message
placeholder.count.matches.argument.count.display.name=Number of placeholders does not match number of arguments in logging call
placeholder.count.matches.argument.count.more.problem.descriptor=More arguments provided ({0}) than placeholders specified ({1}) in ''{2}'' #loc
placeholder.count.matches.argument.count.fewer.problem.descriptor=Fewer arguments provided ({0}) than placeholders specified ({1}) in ''{2}'' #loc
assignment.to.superclass.field.display.name=Constructor assigns value to field defined in superclass
assignment.to.superclass.field.problem.descriptor=Assignment to field ''{0}'' defined in superclass ''{1}'' #loc
junit.rule.display.name=Malformed @Rule/@ClassRule field
junit.rule.problem.descriptor=Fields annotated with @{0} should be {1}
junit.rule.type.problem.descriptor=Field type should be subtype of org.junit.rules.TestRule
junit.datapoint.display.name=Malformed @DataPoint field
junit.datapoint.problem.descriptor={1}s annotated with @DataPoint should be {0}
inner.class.referenced.via.subclass.display.name=Inner class referenced via subclass
inner.class.referenced.via.subclass.problem.descriptor=Inner class #ref declared in class ''{0}'' but referenced via subclass ''{1}'' #loc
inner.class.referenced.via.subclass.quickfix=Rationalize inner class access
boolean.parameter.display.name='public' method with 'boolean' parameter
boolean.parameter.problem.descriptor='public' method #ref() with 'boolean' parameter #loc
boolean.parameters.problem.descriptor='public' method #ref() with 'boolean' parameters #loc
boolean.parameter.constructor.problem.descriptor='public' constructor #ref() with 'boolean' parameter #loc
boolean.parameters.constructor.problem.descriptor='public' constructor #ref() with 'boolean' parameters #loc
boolean.parameter.only.report.multiple.option=Only report methods with multiple boolean parameters
unnecessary.unicode.escape.display.name=Unnecessary unicode escape sequence
unnecessary.unicode.escape.problem.descriptor=Unicode escape sequence #ref can be replaced with ''{0}'' #loc
missing.package.info.display.name=Missing 'package-info.java'
missing.package.info.problem.descriptor=Package ''{0}'' is missing a package-info.java file
missing.package.html.problem.descriptor=Package ''{0}'' is missing a package.html file
package.info.java.without.package.display.name='package-info.java' without 'package' statement
package.info.without.package.problem.descriptor='package-info.java' does not have a package statement
package.info.without.package.quickfix=add ''package {0};''
package.info.without.package.family.quickfix=add package statement
auto.closeable.resource.display.name=AutoCloseable used without 'try'-with-resources
auto.closeable.resource.problem.descriptor=''{0}'' used without ''try''-with-resources statement #loc
auto.closeable.resource.returned.option=Ignore AutoCloseable instances returned from method calls
problematic.whitespace.display.name=Problematic whitespace
problematic.whitespace.tabs.problem.descriptor=File ''{0}'' uses tabs for indentation
problematic.whitespace.spaces.problem.descriptor=File ''{0}'' uses spaces for indentation
problematic.whitespace.show.whitespaces.quickfix=Toggle show whitespace in the editor
problematic.varargs.method.display.name=Non-varargs method overrides varargs method
problematic.varargs.method.override.problem.descriptor=Non-varargs method #ref() overrides varargs method #loc
negatively.named.boolean.variable.problem.descriptor=Boolean variable #ref is negatively named #loc
negatively.named.boolean.variable.display.name=Negatively named boolean variable
invert.quickfix.family.name=Invert boolean
invert.method.quickfix=Invert method
invert.quickfix=Invert ''{0}''
throwable.printed.to.system.out.display.name='Throwable' printed to 'System.out'
throwable.printed.to.system.out.problem.descriptor='Throwable' argument #ref to ''System.{0}.{1}()'' call
suppress.for.tests.scope.quickfix=Suppress for 'Tests' scope
implicit.default.charset.usage.display.name=Implicit usage of platform's default charset
implicit.default.charset.usage.problem.descriptor=Call to #ref() uses the platform's default charset
implicit.default.charset.usage.constructor.problem.descriptor=new #ref() call uses the platform's default charset
interface.may.be.annotated.functional.display.name=Interface may be annotated @FunctionalInterface
interface.may.be.annotated.functional.problem.descriptor=Interface #ref may be annotated with @FunctionalInterface
only.report.public.methods.option=Only report 'public' methods
lambda.parameter.hides.member.variable.display.name=Lambda parameter hides field
lambda.parameter.hides.member.variable.problem.descriptor=Lambda parameter #ref hides field in class ''{0}'' #loc
shared.thread.local.random.display.name='ThreadLocalRandom' instance might be shared
shared.thread.local.random.problem.descriptor='ThreadLocalRandom' instance might be shared between threads
native.method.naming.convention.display.name='native' method naming convention
native.method.naming.convention.problem.descriptor.short='native' method name #ref is too short #loc
native.method.naming.convention.problem.descriptor.long='native' method name #ref is too long #loc
native.method.naming.convention.problem.descriptor.regex.mismatch=''native'' method name #ref doesn''t match regex ''{0}'' #loc
use.of.obsolete.date.time.api.display.name=Use of obsolete date-time API
use.of.obsolete.date.time.api.problem.descriptor=Obsolete date-time type #ref used #loc
warn.on.label=Warn on:
all.levels.option=all log levels
warn.level.and.lower.option=warn level and lower
info.level.and.lower.option=info level and lower
debug.level.and.lower.option=debug level and lower
trace.level.option=trace level
ignored.autocloseable.types.column.label=Ignored AutoCloseable resource types
choose.autocloseable.type.to.ignore.title=Choose AutoCloseable resource type to ignore
big.decimal.method.without.rounding.called.display.name=Call to 'BigDecimal' method without a rounding mode argument
big.decimal.method.without.rounding.called.problem.descriptor='BigDecimal.#ref()' called without a rounding mode argument
bigdecimal.legacy.method.display.name='BigDecimal' legacy method called
bigdecimal.legacy.method.problem.descriptor=Call to 'BigDecimal.#ref()' can use 'RoundingMode' enum constant
bigdecimal.legacy.method.quickfix=Use 'RoundingMode' enum constant
serializable.stores.non.serializable.display.name=Serializable object implicitly stores non-Serializable object
serializable.lambda.stores.non.serializable.problem.descriptor=Serializable lambda implicitly stores non-Serializable object of type ''{0}''
serializable.local.class.stores.non.serializable.problem.descriptor=Serializable local class ''{1}'' implicitly stores non-Serializable object of type ''{0}''
serializable.anonymous.class.stores.non.serializable.problem.descriptor=Serializable anonymous class implicitly stores non-Serializable object of type ''{0}''
assignment.to.lambda.parameter.display.name=Assignment to lambda parameter
assignment.to.lambda.parameter.problem.descriptor=Assignment to lambda parameter #ref #loc
class.with.only.private.constructors.display.name=Class with only 'private' constructors should be declared 'final'
class.with.only.private.constructors.problem.descriptor=Class #ref with only 'private' constructors should be declared 'final'
property.value.set.to.itself.display.name=Property value set to itself
equals.with.itself.display.name='equals()' called on itself
equals.with.itself.problem.descriptor=Identical qualifier and argument to #ref() call
junit4.method.naming.convention.display.name=JUnit 4 test method naming convention
junit4.method.naming.convention.problem.descriptor.short=JUnit 4 test method name #ref is too short ({0} < {1}) #loc
junit4.method.naming.convention.problem.descriptor.long=JUnit 4 test method name #ref is too long ({0} > {1}) #loc
junit4.method.naming.convention.problem.descriptor.regex.mismatch=JUnit 4 test method name #ref doesn''t match regex ''{0}'' #loc
junit3.method.naming.convention.display.name=JUnit 3 test method naming convention
junit3.method.naming.convention.problem.descriptor.short=JUnit 3 test method name #ref is too short ({0} < {1}) #loc
junit3.method.naming.convention.problem.descriptor.long=JUnit 3 test method name #ref is too long ({0} > {1}) #loc
junit3.method.naming.convention.problem.descriptor.regex.mismatch=JUnit 3 test method name #ref doesn''t match regex ''{0}'' #loc