1 plugin.InspectionGadgets.description=Adds over 500 new automated code inspections for IntelliJ IDEA.
2 error.message.regexp.malformed.naming.pattern=Malformed Naming Pattern
3 error.message.regexp.malformed.pattern=Malformed Regular Expression Pattern
4 cast.to.concrete.class.display.name=Cast to a concrete class
5 cast.to.concrete.class.problem.descriptor=Cast to concrete class <code>#ref</code> #loc
6 class.references.subclass.display.name=Class references one of its subclasses
7 class.references.subclass.problem.descriptor=Class ''{0}'' references subclass <code>#ref</code> #loc
8 class.references.subclass.problem.descriptor.anonymous=Anonymous class references subclass <code>#ref</code> #loc
9 collection.declared.by.class.display.name=Collection declared by class, not interface
10 #{0} - name of the interface
11 collection.declared.by.class.problem.descriptor=Declaration of <code>#ref</code> should probably be weakened to ''{0}'' #loc
12 collection.declared.by.class.ignore.locals.option=Ignore local variables
13 collection.declared.by.class.ignore.private.members.option=Ignore private fields and methods
14 feature.envy.display.name=Feature envy
15 feature.envy.problem.descriptor=Class ''{0}'' accessed repeatedly in method <code>#ref()</code> #loc
16 instance.variable.of.concrete.class.display.name=Instance variable of concrete class
17 instance.variable.of.concrete.class.problem.descriptor=Instance variable ''{0}'' of concrete class <code>#ref</code> #loc
18 chain.of.instanceof.checks.display.name=Chain of 'instanceof' checks
19 chain.of.instanceof.checks.problem.descriptor=Chain of 'instanceof' checks indicates abstraction failure #loc
20 instanceof.concrete.class.display.name='instanceof' a concrete class
21 instanceof.concrete.class.problem.descriptor='instanceof' concrete class <code>#ref</code> #loc
22 instanceof.check.for.this.display.name='instanceof' check for 'this'
23 instanceof.check.for.this.problem.descriptor='instanceof' check for <code>#ref</code> #loc
24 local.variable.of.concrete.class.display.name=Local variable of concrete class
25 local.variable.of.concrete.class.problem.descriptor=Local variable ''{0}'' of concrete class <code>#ref</code> #loc
26 magic.number.display.name="Magic number"
27 magic.number.problem.descriptor=Magic number <code>#ref</code> #loc
28 magic.number.ignore.option=Ignore constants in 'hashCode()' methods
29 method.return.concrete.class.display.name=Method return of concrete class
30 method.return.concrete.class.problem.descriptor=Method returns a concrete class <code>#ref</code> #loc
31 overly.strong.type.cast.display.name=Overly-strong type cast
32 overly.strong.type.cast.weaken.quickfix=Weaken overly-strong cast
33 concrete.class.method.parameter.display.name=Method parameter of concrete class
34 concrete.class.method.parameter.problem.descriptor=Parameter ''{0}'' of concrete class <code>#ref</code> #loc
35 public.method.not.in.interface.display.name='public' method not exposed in interface
36 public.method.not.in.interface.problem.descriptor='public' method <code>#ref()</code> is not exposed via an interface #loc
37 static.variable.of.concrete.class.display.name=Static variable of concrete class
38 static.variable.of.concrete.class.problem.descriptor=Static variable ''{0}'' of concrete class <code>#ref</code> #loc
39 incompatible.mask.operation.display.name=Incompatible bitwise mask operation
40 incompatible.mask.operation.problem.descriptor.always.false=<code>#ref</code> is always false #loc
41 incompatible.mask.operation.problem.descriptor.always.true=<code>#ref</code> is always true #loc
42 pointless.bitwise.expression.display.name=Pointless bitwise expression
43 pointless.bitwise.expression.ignore.option=Ignore named constants in determinining pointless expressions
44 pointless.bitwise.expression.problem.descriptor=<code>#ref</code> can be replaced with ''{0}'' #loc
45 pointless.bitwise.expression.simplify.quickfix=Simplify
46 shift.operation.by.inappropriate.constant.display.name=Shift operation by inappropriate constant
47 shift.operation.by.inappropriate.constant.problem.descriptor.too.large=Shift operation <code>#ref</code> by overly large constant value #loc
48 shift.operation.by.inappropriate.constant.problem.descriptor.negative=Shift operation <code>#ref</code> by negative constant value #loc
49 archaic.system.property.accessors.display.name=Use of archaic system property accessors
50 archaic.system.property.accessors.problem.descriptor.Integer=Call to <code>Integer.#ref()</code> accesses system properties, perhaps confusingly #loc
51 archaic.system.property.accessors.problem.descriptor.Long=Call to <code>Long.#ref()</code> accesses system properties, perhaps confusingly #loc
52 archaic.system.property.accessors.problem.descriptor.Boolean=Call to <code>Boolean.#ref()</code> accesses system properties, perhaps confusingly #loc
53 archaic.system.property.accessors.replace.parse.quickfix=Replace with parse method
54 archaic.system.property.accessors.replace.standard.quickfix=Replace with standard property access
55 equals.called.on.array.display.name='equals()' called on array type
56 equals.called.on.array.problem.descriptor=<code>#ref()</code> between arrays should probably be 'Arrays.equals()' #loc
57 equals.called.on.array.replace.quickfix=replace with 'Arrays.equals()'
58 assignment.to.null.display.name=Assignment to 'null'
59 assignment.to.null.problem.descriptor=Assignment of variable <code>#ref</code> to null #loc
60 assignment.to.static.field.from.instance.method.display.name=Assignment to static field from instance method
61 assignment.to.static.field.from.instance.method.problem.descriptor=Assignment to static field <code>#ref</code> from an instance method #loc
62 assignment.used.as.condition.display.name=Assignment used as condition
63 assignment.used.as.condition.problem.descriptor=<code>#ref</code> used as condition #loc
64 assignment.used.as.condition.replace.quickfix=replace '=' with '=='
65 cast.conflicts.with.instanceof.display.name=Cast conflicts with 'instanceof'
66 cast.conflicts.with.instanceof.problem.descriptor=Cast to <code>#ref</code> conflicts with surrounding 'instanceof' check #loc
67 casting.to.incompatible.interface.display.name=Casting to incompatible interface
68 casting.to.incompatible.interface.problem.descriptor=Cast to incompatible interface <code>#ref</code> #loc
69 collection.added.to.self.display.name=Collection added to self
70 collection.added.to.self.problem.descriptor=Collection <code>#ref</code> is added to self #loc
71 non.final.field.compareto.display.name=Non-final field referenced in 'compareTo()'
72 non.final.field.compareto.problem.descriptor=Non-final field <code>#ref</code> accessed in 'compareTo()' #loc
73 covariant.compareto.display.name=Covariant 'compareTo()'
74 covariant.compareto.problem.descriptor=<code>#ref()</code> should take 'Object' as its argument #loc
75 covariant.equals.display.name=Covariant 'equals()'
76 covariant.equals.problem.descriptor=<code>#ref()</code> should take 'Object' as its argument #loc
77 empty.class.initializer.display.name=Empty class initializer
78 empty.class.initializer.problem.descriptor=Empty class initializer #loc
79 empty.class.initializer.delete.quickfix=Delete empty class initializer
80 statement.with.empty.body.display.name=Statement with empty body
81 statement.with.empty.body.problem.descriptor=<code>#ref</code> statement has empty body #loc
82 statement.with.empty.body.include.option=Include statement bodies that are empty code blocks
83 equals.between.inconvertible.types.display.name='equals()' between objects of inconvertible types
84 equals.between.inconvertible.types.problem.descriptor=<code>#ref()</code> between objects of inconvertible types ''{0}'' and ''{1}'' #loc
85 non.final.field.in.equals.display.name=Non-final field referenced in 'equals()'
86 non.final.field.in.equals.problem.descriptor=Non-final field <code>#ref</code> accessed in 'equals()' #loc
87 equals.doesnt.check.class.parameter.display.name='equals()' method which does not check class of parameter
88 equals.doesnt.check.class.parameter.problem.descriptor=<code>#ref()</code> should check the class of its parameter #loc
89 for.loop.not.use.loop.variable.display.name='for' loop where update or condition does not use loop variable
90 for.loop.not.use.loop.variable.problem.descriptor.condition=<code>#ref</code> statement has condition which does not use the for loop variable #loc
91 for.loop.not.use.loop.variable.problem.descriptor.update=<code>#ref</code> statement has update which does not use the for loop variable #loc
92 for.loop.not.use.loop.variable.problem.descriptor.both.condition.and.update=<code>#ref</code> statement has condition and update which do not use the for loop variable #loc
93 non.final.field.in.hashcode.display.name=Non-final field referenced in 'hashCode()'
94 non.final.field.in.hashcode.problem.descriptor=Non-final field <code>#ref</code> accessed in 'hashCode()' #loc
95 result.of.method.call.ignored.display.name=Result of method call ignored
96 result.of.method.call.ignored.problem.descriptor=result of <code>{0}.#ref()</code> is ignored #loc
97 result.of.method.call.ignored.class.column.title=Class name
98 result.of.method.call.ignored.method.column.title=Method name
99 result.of.method.call.ignored.non.library.option=Report all ignored non-library calls
100 infinite.recursion.display.name=Infinite recursion
101 infinite.recursion.problem.descriptor=Method <code>#ref()</code> recurses infinitely, and can only end by throwing an exception #loc
102 instanceof.with.incompatible.interface.display.name='instanceof' with incompatible interface
103 instanceof.with.incompatible.interface.problem.descriptor='instanceof' incompatible interface <code>#ref</code> #loc
104 instantiation.utility.class.display.name=Instantiation of utility class
105 instantiation.utility.class.problem.descriptor=Instantiation of utility class <code>#ref</code> #loc
106 iterator.hasnext.which.calls.next.display.name='Iterator.hasNext()' which calls 'next()'
107 iterator.hasnext.which.calls.next.problem.descriptor=<code>Iterator.#ref()</code> contains call to 'next()' #loc
108 iterator.next.does.not.throw.nosuchelementexception.display.name='Iterator.next()' which can't throw 'NoSuchElementException'
109 malformed.format.string.display.name=Malformed format string
110 malformed.format.string.problem.descriptor.malformed=Format string #ref is malformed #loc
111 malformed.format.string.problem.descriptor.too.many.arguments=Too many arguments for format string #ref #loc
112 malformed.format.string.problem.descriptor.too.few.arguments=Too few arguments for format string #ref #loc
113 malformed.format.string.problem.descriptor.arguments.do.not.match.type=Format string #ref does not match the type of its arguments #loc
114 malformed.regular.expression.display.name=Malformed regular expression
115 malformed.regular.expression.problem.descriptor1=Regular expression <code>#ref</code> is malformed #loc
116 malformed.regular.expression.problem.descriptor2=Regular expression <code>#ref</code> is malformed: {0} #loc
117 malformed.xpath.expression.display.name=Malformed XPath expression
118 malformed.xpath.expression.problem.description=XPath expression <code>#ref</code> is malformed #loc
119 mismatched.read.write.array.display.name=Mismatched read and write of array
120 mismatched.read.write.array.problem.descriptor.write.not.read=Contents of array <code>#ref</code> are written to, but never read #loc
121 mismatched.read.write.array.problem.descriptor.read.not.write=Contents of array <code>#ref</code> are read, but never written to #loc
122 mismatched.update.collection.display.name=Mismatched query and update of collection
123 mismatched.update.collection.problem.descriptor.updated.not.queried=Contents of collection <code>#ref</code> are updated, but never queried #loc
124 mismatched.update.collection.problem.description.queried.not.updated=Contents of collection <code>#ref</code> are queried, but never updated #loc
125 misspelled.compareto.display.name='compareto()' instead of 'compareTo()'
126 misspelled.compareto.problem.descriptor=<code>#ref()</code> method should probably be 'compareTo()' #loc
127 rename.quickfix=Rename
128 renameto.quickfix=Rename to ''{0}''
129 misspelled.equals.display.name='equal()' instead of 'equals()'
130 misspelled.equals.problem.descriptor=<code>#ref()</code> method should probably be equals() #loc
131 misspelled.hashcode.display.name='hashcode()' instead of 'hashCode()'
132 misspelled.hashcode.problem.descriptor=<code>#ref()</code> should probably be hashCode() #loc
133 misspelled.tostring.display.name='tostring()' instead of 'toString()'
134 misspelled.tostring.problem.descriptor=<code>#ref()</code> method should probably be 'toString()' #loc
135 non.short.circuit.boolean.expression.display.name=Non-short-circuit boolean expression
136 non.short.circuit.boolean.expression.problem.descriptor=Non-short-circuit boolean expression <code>#ref</code> #loc
137 non.short.circuit.boolean.expression.replace.quickfix=Replace with short circuit expression
138 null.argument.to.var.arg.method.display.name=Confusing 'null' argument to var-arg method
139 null.argument.to.var.arg.method.problem.descriptor=Confusing <code>#ref</code> argument to var-arg method #loc
140 primitive.array.argument.to.var.arg.method.display.name=Confusing primitive array argument to var-arg method
141 primitive.array.argument.to.var.arg.method.problem.descriptor=Confusing primitive array argument to var-arg method #loc
142 object.comparison.display.name=Object comparison using ==, instead of 'equals()'
143 object.comparison.enumerated.ignore.option=Ignore == between enumerated types
144 object.comparison.klass.ignore.option=Ignore == on java.lang.Class objects
145 object.comparison.problem.description=Object values are compared using <code>#ref</code>, not 'equals()' #loc
146 object.comparison.replace.quickfix=Replace with equals()
147 object.equals.null.problem.descriptor=<code>.equals(#ref)</code> is probably not what was intended #loc
148 default.tostring.call.display.name=Call to default 'toString()'
149 default.tostring.call.problem.descriptor=Call to default 'toString()' on <code>#ref</code> #loc
150 octal.and.decimal.integers.in.same.array.display.name=Octal and decimal integers in same array
151 octal.and.decimal.integers.in.same.array.problem.descriptor=Octal and decimal integers in the same array initializer #loc
152 result.of.object.allocation.ignored.display.name=Result of object allocation ignored
153 result.of.object.allocation.ignored.problem.descriptor=result of <code>new #ref()</code> is ignored. #loc
154 use.0index.in.jdbc.resultset.display.name=Use of index 0 in JDBC ResultSet
155 use.0index.in.jdbc.resultset.problem.descriptor=Use of index '0' in JDBC ResultSet #loc
156 return.of.null.display.name=Return of 'null'
157 return.of.null.problem.descriptor=Return of <code>#ref</code> #loc
158 return.of.null.arrays.option=Methods that return arrays
159 return.of.null.quickfix=Annotate method as @Nullable
160 return.of.null.objects.option=Methods that return objects
161 return.of.null.collections.option=Methods that return collection objects
162 static.method.via.subclass.display.name=Static method referenced via subclass
163 static.method.via.subclass.problem.descriptor=Static method <code>#ref()</code> declared on class ''{0}'' but referenced via class ''{1}'' #loc
164 static.method.via.subclass.rationalize.quickfix=Rationalize static method call
165 static.field.via.subclass.display.name=Static field referenced via subclass
166 static.field.via.subclass.problem.descriptor=Static field <code>#ref</code> declared on class ''{0}'' but referenced via class ''{1}'' #loc
167 static.field.via.subclass.rationalize.quickfix=Rationalize static field access
168 string.comparison.display.name=String comparison using '==', instead of 'equals()'
169 number.comparison.display.name=Number comparison using '==', instead of 'equals()'
170 string.comparison.problem.descriptor=String values are compared using <code>#ref</code>, not '.equals()' #loc
171 number.comparison.problem.descriptor=Number objects are compared using <code>#ref</code>, not '.equals()' #loc
172 subtraction.in.compareto.display.name=Subtraction in compareTo()
173 subtraction.in.compareto.problem.descriptor=Subtraction <code>#ref</code> in compareTo() may result in overflow errors #loc
174 text.label.in.switch.statement.display.name=Text label in 'switch' statement
175 text.label.in.switch.statement.problem.descriptor=Text label <code>#ref:</code> in 'switch' statement #loc
176 properties.object.as.hashtable.display.name=Use of Properties object as a Hashtable
177 properties.object.as.hashtable.problem.descriptor=Call to <code>Hashtable.#ref()</code> on properties object #loc
178 assignment.replaceable.with.operator.assignment.display.name=Assignment replaceable with operator assignment
179 unnecessary.code.block.display.name=Unnecessary code block
180 unnecessary.code.block.unwrap.quickfix=Unwrap block
181 redundant.local.variable.display.name=Redundant local variable
182 redundant.local.variable.ignore.option=Ignore immediately returned or thrown variables
183 redundant.local.variable.annotation.option=Ignore variables which have an annotation (JDK 5.0 only)
184 static.collection.display.name=Static collection
185 static.collection.problem.descriptor=Static collection <code>#ref</code> #loc
186 static.collection.ignore.option=Ignore weak static collections or maps
187 #field of type java.lang.StringBuffer
188 stringbuffer.field.display.name=StringBuffer field
189 #{0} - concrete field type
190 stringbuffer.field.problem.descriptor=''{0}'' field <code>#ref</code> #loc
191 gc.call.display.name=Calls to 'System.gc()' or 'Runtime.gc()'
192 gc.call.problem.descriptor=<code>#ref</code> should not be called in production code #loc
193 array.allocation.zero.length.display.name=Zero-length array allocation
194 array.allocation.zero.length.problem.descriptor=Allocation of zero length array #loc
195 multiple.loggers.display.name=Class with multiple loggers
196 logger.name.option=Logger &class name:
197 multiple.loggers.problem.descriptor=Class <code>#ref</code> declares multiple loggers #loc
198 no.logger.display.name=Class without logger
199 no.logger.problem.descriptor=Class <code>#ref</code> does not declare a logger #loc
200 non.constant.logger.display.name=Non-constant logger
201 non.constant.logger.problem.descriptor=Non-constant logger field <code>#ref</code> #loc
202 public.method.without.logging.display.name='public' method without logging
203 public.method.without.logging.problem.descriptor='public' method without logging <code>#ref</code> #loc
204 action.reset.telemetry.description=Reset telemetry data
206 telemetry.table.column.inspection.name=Inspection Name
207 telemetry.table.column.total.time=Total Run Time (msecs)
208 telemetry.table.column.average.time=Average Run Time (msecs)
209 telemetry.table.column.run.count=Total Run Count
210 telemetry.toolwindow.title=IG Telemetry
211 action.telemetry.refresh.description=Refresh telemetry display
212 finalize.doesnt.call.super.display.name='finalize()' does not call 'super.finalize()'
213 finalize.doesnt.call.super.ignore.option=Ignore for direct subclasses of java.lang.Object
214 finalize.doesnt.call.super.problem.descriptor=<code>#ref()</code>#loc does not call 'super.finalize()'
215 finalize.declaration.display.name='finalize()' declaration
216 finalize.declaration.problem.descriptor=<code>#ref()</code> declared #loc
217 finalize.not.declared.protected.display.name='finalize()' not declared 'protected'
218 finalize.not.declared.protected.problem.descriptor=<code>#ref()</code> not declared 'protected' #loc
219 make.protected.quickfix=Make 'protected'
220 finalize.called.explicitly.display.name='finalize()' called explicitly
221 finalize.called.explicitly.problem.descriptor=<code>#ref()</code> called explicitly #loc
222 java.lang.import.display.name=java.lang import
223 java.lang.import.problem.descriptor=Unnecessary import from package java.lang #loc
224 import.display.name=* import
225 import.problem.descriptor=Package import <code>#ref</code> #loc
226 redundant.import.display.name=Redundant import
227 redundant.import.problem.descriptor=Redundant import <code>#ref</code> #loc
228 import.from.same.package.display.name=Import from same package
229 import.from.same.package.problem.descriptor=Unnecessary import from same package <code>#ref</code> #loc
230 single.class.import.display.name=Single class import
231 single.class.import.problem.descriptor=Single class import <code>#ref</code> #loc
232 static.import.display.name=Static import
233 static.import.problem.descriptor=Static import <code>#ref</code> #loc
234 static.import.replace.quickfix=Replace with non-static import
235 unused.import.display.name=Unused import
236 unused.import.problem.descriptor=Unused import <code>#ref</code> #loc
237 clone.instantiates.objects.with.constructor.display.name='clone()' instantiates objects with constructor
238 clone.instantiates.objects.with.constructor.problem.descriptor='clone()' creates new <code>#ref</code> instances #loc
239 clone.doesnt.call.super.clone.display.name='clone()' does not call 'super.clone()'
240 clone.doesnt.call.super.clone.problem.descriptor=<code>#ref()</code> does not call 'super.clone()'
241 clone.doesnt.declare.clonenotsupportedexception.display.name='clone()' does not declare 'CloneNotSupportedException'
242 clone.doesnt.declare.clonenotsupportedexception.problem.descriptor=<code>#ref()</code>#loc does not declare 'CloneNotSupportedException'
243 clone.doesnt.declare.clonenotsupportedexception.declare.quickfix=Declare 'CloneNotSupportedException'
244 clone.method.in.non.cloneable.class.display.name='clone()' method in non-Cloneable class
245 clone.method.in.non.cloneable.class.problem.descriptor=<code>#ref()</code> defined in non-Cloneable class #loc
246 cloneable.class.without.clone.display.name=Cloneable class without 'clone()'
247 cloneable.class.without.clone.problem.descriptor=<code>#ref</code> does not define 'clone()' #loc
248 cloneable.class.without.clone.ignore.option=Ignore classes cloneable due to inheritance
249 class.without.tostring.display.name=Class without 'toString()'
250 class.without.tostring.problem.descriptor=Class <code>#ref</code> should probably implement 'toString()', for debugging purposes
251 use.obsolete.collection.type.display.name=Use of obsolete collection type
252 use.obsolete.collection.type.problem.descriptor=Obsolete collection type <code>#ref</code> used #loc
253 use.obsolete.collection.type.ignore.library.arguments.option=Ignore obsolete collection types where they are required
254 inspection.suppression.annotation.display.name=Inspection suppression annotation
255 inspection.suppression.annotation.problem.descriptor=Inspection suppression annotation <code>#ref</code> #loc
256 use.system.out.err.display.name=Use of System.out or System.err
257 use.system.out.err.problem.descriptor=Uses of 'System.out' and 'System.err' should probably be replaced with more robust logging #loc
258 dumpstack.call.display.name=Call to 'Thread.dumpStack()'
259 dumpstack.call.problem.descriptor=Call to <code>Thread.#ref()</code> should probably be replaced with more robust logging #loc
260 printstacktrace.call.display.name=Call to 'printStackTrace()'
261 printstacktrace.call.problem.descriptor=Call to <code>#ref()</code> should probably be replaced with more robust logging #loc
262 todo.comment.display.name=TODO comment
263 todo.comment.problem.descriptor=TODO comment <code>#ref</code> #loc
264 abstract.method.call.in.constructor.display.name=Abstract method call in constructor
265 abstract.method.call.in.constructor.problem.descriptor=Call to abstract method <code>#ref()</code> during object construction #loc
266 instance.variable.may.not.be.initialized.display.name=Instance variable may not be initialized
267 instance.variable.may.not.be.initialized.problem.descriptor=Instance variable <code>#ref</code> may not be initialized during object construction #loc
268 instance.Variable.may.not.be.initialized.problem.descriptor.junit=Instance variable <code>#ref</code> may not be initialized during object construction or 'setUp()' call #loc
269 primitive.fields.ignore.option=Ignore primitive fields
270 instance.variable.used.before.initialized.display.name=Instance variable used before initialized
271 instance.variable.used.before.initialized.problem.descriptor=Instance variable <code>#ref</code> used before initialized #loc
272 non.final.static.variable.initialization.display.name=Non-final static variable is used during class initialization
273 non.final.static.variable.initialization.problem.descriptor=Non-final static variable <code>#ref</code> used during class initialization #loc
274 overridable.method.call.in.constructor.display.name=Overridable method call during object construction
275 overridable.method.call.in.constructor.problem.descriptor=Call to overridable method during object construction #loc
276 overridden.method.call.in.constructor.display.name=Overridden method call during object construction
277 overridden.method.call.in.constructor.problem.descriptor=Call to overridden method <code>#ref()</code> during object construction #loc
278 static.variable.may.not.be.initialized.display.name=Static variable may not be initialized
279 static.variable.may.not.be.initialized.problem.descriptor=Static variable <code>#ref</code> may not be initialized during class initialization #loc
280 static.variable.used.before.initialization.display.name=Static variable used before initialization
281 static.variable.used.before.initialization.problem.descriptor=Static variable <code>#ref</code> used before initialization #loc
282 this.reference.escaped.in.construction.display.name='this' reference escaped in object construction
283 this.reference.escaped.in.construction.problem.descriptor=Escape of <code>#ref</code> during object construction #loc
284 assignment.to.catch.block.parameter.display.name=Assignment to catch block parameter
285 extract.parameter.as.local.variable.quickfix=Extract parameter as local variable
286 assignment.to.for.loop.parameter.display.name=Assignment to 'for' loop parameter
287 assignment.to.for.loop.parameter.check.foreach.option=Check foreach parameters
288 assignment.to.for.loop.parameter.problem.descriptor=Assignment to for-loop parameter <code>#ref</code> #loc
289 assignment.to.method.parameter.display.name=Assignment to method parameter
290 chained.equality.comparisons.display.name=Chained equality comparisons
291 confusing.octal.escape.sequence.display.name=Confusing octal escape sequence
292 increment.decrement.display.name=Value of ++ or -- used
293 nested.assignment.display.name=Nested assignment
294 nested.assignment.problem.descriptor=Nested assignment <code>#ref</code> #loc
295 overloaded.methods.with.same.number.parameters.display.name=Overloaded methods with same number of parameters
296 overloaded.vararg.method.display.name=Overloaded variable argument method
297 refused.bequest.display.name=Refused bequest
298 reuse.of.local.variable.display.name=Reuse of local variable
299 reuse.of.local.variable.split.quickfix=Split local variable
300 character.comparison.display.name=Character comparison
301 character.comparison.problem.descriptor=Character comparison <code>#ref</code> in an internationalized context #loc
302 assignment.collection.array.field.from.parameter.display.name=Assignment to Collection or array field from parameter
303 assignment.collection.array.field.from.parameter.problem.descriptor.array=Assignment to array field <code>#ref</code> from parameter ''{0}''#loc
304 assignment.collection.array.field.from.parameter.problem.descriptor.collection=Assignment to Collection field <code>#ref</code> from parameter ''{0}''#loc
305 assignment.collection.array.field.option=Ignore assignments in private methods
306 assignment.to.date.calendar.field.from.parameter.display.name=Assignment to Date or Calendar field from parameter
307 assignment.to.date.calendar.field.from.parameter.problem.descriptor=Assignment to ''{0}'' field <code>#ref</code> from parameter {1}#loc
308 package.visible.field.display.name=Package-visible field
309 package.visible.field.problem.descriptor=Package-visible field <code>#ref</code> #loc
310 package.visible.inner.class.display.name=Package-visible inner class
311 package.visible.inner.class.problem.descriptor=Package-visible inner class <code>#ref</code> #loc
312 package.visible.inner.class.ignore.enum.option=Ignore package-visible inner enums
313 protected.field.display.name=Protected field
314 protected.field.problem.descriptor=Protected field <code>#ref</code> #loc
315 protected.inner.class.display.name=Protected inner class
316 protected.inner.class.problem.descriptor=Protected inner class <code>#ref</code> #loc
317 protected.inner.class.ignore.enum.option=Ignore 'protected' inner enums
318 public.field.display.name='public' field
319 public.field.problem.descriptor='public' field <code>#ref</code> #loc
320 public.field.ignore.enum.type.fields.option=Ignore 'public' fields of an enum type
321 public.inner.class.display.name='public' inner class
322 public.inner.class.problem.descriptor='public' inner class <code>#ref</code> #loc
323 public.inner.class.ignore.enum.option=Ignore 'public' inner enums
324 return.of.collection.array.field.display.name=Return of Collection or array field
325 return.of.collection.array.field.problem.descriptor.array='return' of array field <code>#ref</code> #loc
326 return.of.collection.array.field.problem.descriptor.collection='return' of Collection field <code>#ref</code> #loc
327 return.of.collection.array.field.option=Ignore private methods returning an array or collection field
328 return.date.calendar.field.display.name=Return of Date or Calendar field
329 return.date.calendar.field.problem.descriptor=Return of ''{0}'' field <code>#ref</code> #loc
330 accessing.non.public.field.of.another.object.display.name=Accessing a non-public field of another object
331 accessing.non.public.field.of.another.object.problem.descriptor=Direct access of non-public field <code>#ref</code> on another object #loc
332 call.to.date.tostring.display.name=Call to 'Date.toString()'
333 call.to.date.tostring.problem.descriptor=<code>Date.#ref()</code> used in an internationalized context #loc
334 magic.character.display.name="Magic character"
335 magic.character.problem.descriptor="Magic character" <code>#ref</code> in an internationalized context #loc
336 call.to.numeric.tostring.display.name=Call to Numeric 'toString()'
337 call.to.numeric.tostring.problem.descriptor=Numeric <code>#ref()</code> called in an internationalized context #loc
338 instantiating.simpledateformat.without.locale.display.name=Instantiating a SimpleDateFormat without a Locale
339 instantiating.simpledateformat.without.locale.problem.descriptor=Instantiating a <code>#ref</code> without specifying a Locale in an internationalized context #loc
340 string.compareto.call.display.name=Call to 'String.compareTo()'
341 string.compareto.call.problem.descriptor=<code>String.#ref()</code> called using internationalized strings #loc
342 string.concatenation.display.name=String concatenation
343 string.concatenation.problem.descriptor=String concatenation <code>#ref</code> in an internationalized context #loc
344 string.concatenation.ignore.system.out.option=Ignore for 'System.out.print' arguments
345 string.concatenation.ignore.system.err.option=Ignore for 'System.err.print' arguments
346 string.concatenation.ignore.assert.option=Ignore for assert statement arguments
347 string.equalsignorecase.call.display.name=Call to 'String.equalsIgnoreCase()'
348 string.equalsignorecase.call.problem.descriptor=<code>String.#ref()</code> using internationalized strings #loc
349 string.equals.call.display.name=Call to 'String.equals()'
350 string.equals.call.problem.descriptor=<code>String.#ref()</code> using internationalized strings #loc
351 string.touppercase.tolowercase.without.locale.display.name=Call to 'String.toUpperCase()' or 'toLowerCase()' without a Locale
352 string.touppercase.tolowercase.without.locale.problem.descriptor=<code>String.#ref()</code> called without specifying a Locale using internationalized strings #loc
353 use.stringtokenizer.display.name=Use of StringTokenizer
354 use.stringtokenizer.problem.descriptor=<code>#ref</code> in an internationalized context #loc
355 time.tostring.call.display.name=Call to 'Time.toString()'
356 time.tostring.call.problem.descriptor=<code>Time.#ref()</code> in an internationalized context #loc
357 class.escapes.defined.scope.display.name=Class escapes defined scope
358 class.escapes.defined.scope.problem.descriptor=Class <code>#ref</code> is made visible outside its defined scope #loc
359 field.name.hides.in.superclass.display.name=Field name hides field in superclass
360 field.name.hides.in.superclass.problem.descriptor=Field <code>#ref</code> hides field in superclass #loc
361 field.name.hides.in.superclass.ignore.option=Ignore superclass fields not visible from subclass
362 inner.class.field.hides.outer.display.name=Inner class field hides outer class field
363 inner.class.field.hides.outer.ignore.option=Ignore outer fields not visible from inner class
364 inner.class.field.hides.outer.problem.descriptor=Inner class field <code>#ref</code> hides outer class field #loc
365 local.variable.hides.member.variable.display.name=Local variable hides member variable
366 local.variable.hides.member.variable.problem.descriptor=Local variable <code>#ref</code> hides member variable #loc
367 local.variable.hides.member.variable.ignore.option=Ignore local variables in static methods
368 method.overloads.display.name=Method overloads method of superclass
369 method.overloads.problem.descriptor=Method <code>#ref()</code> overloads a compatible method of a superclass, when overriding might have been intended #loc
370 method.overrides.private.display.name=Method overrides private method of superclass
371 method.overrides.private.display.name.problem.descriptor=Method <code>#ref()</code> overrides a private method of a superclass #loc
372 method.overrides.static.display.name=Method overrides static method of superclass
373 method.overrides.static.problem.descriptor=Method <code>#ref()</code> overrides a static method of a superclass #loc
374 parameter.hides.member.variable.display.name=Parameter hides member variable
375 parameter.hides.member.variable.problem.descriptor=Parameter <code>#ref</code> hides member variable #loc
376 parameter.hides.member.variable.ignore.setters.option=Ignore for property setters
377 parameter.hides.member.variable.ignore.superclass.option=Ignore superclass fields not visible from subclass
378 parameter.hides.member.variable.ignore.constructors.option=Ignore for constructors
379 parameter.hides.member.variable.ignore.abstract.methods.option=Ignore for abstract methods
380 parameter.hides.member.variable.ignore.static.parameters.option=Ignore for static method parameters hiding instance fields
381 type.parameter.hides.visible.type.display.name=Type parameter hides visible type
382 type.parameter.hides.visible.type.problem.descriptor=Type parameter <code>#ref</code> hides a visible type ''{0}''#loc
383 anonymous.class.variable.hides.containing.method.variable.display.name=Anonymous class variable hides variable in containing method
384 anonymous.class.parameter.hides.containing.method.variable.problem.descriptor=Anonymous class parameter <code>#ref</code> hides variable in containing method
385 anonymous.class.field.hides.containing.method.variable.problem.descriptor=Anonymous class field <code>#ref</code> hides variable in containing method
386 anonymous.class.variable.hides.containing.method.variable.problem.descriptor=Anonymous class local variable <code>#ref</code> hides variable in containing method
387 channel.opened.not.closed.display.name=Channel opened but not safely closed
388 channel.opened.not.closed.problem.descriptor=''{0}'' should be opened in front of a try block and closed in the corresponding finally block #loc
389 drivermanager.call.display.name=Use of DriverManager to get JDBC connection
390 drivermanager.call.problem.descriptor=Call to <code>DriverManager.#ref()</code> #loc
391 hibernate.resource.opened.not.closed.display.name=Hibernate resource opened but not safely closed
392 hibernate.resource.opened.not.closed.problem.descriptor=''{0}'' should be opened in front of a try block and closed in the corresponding finally block #loc
393 i.o.resource.opened.not.closed.display.name=I/O resource opened but not safely closed
394 resource.opened.not.closed.problem.descriptor=''{0}'' should be opened in front of a try block and closed in the corresponding finally block #loc
395 jdbc.resource.opened.not.closed.display.name=JDBC resource opened but not safely closed
396 jdbc.resource.opened.not.closed.problem.descriptor=JDBC ''{0}'' should be opened in front of a try block and closed in the corresponding finally block #loc
397 jndi.resource.opened.not.closed.display.name=JNDI resource opened but not safely closed
398 socket.opened.not.closed.display.name=Socket opened but not safely closed
399 annotation.class.display.name=Annotation class
400 annotation.class.problem.descriptor=Annotation class <code>#ref</code> #loc
401 annotation.display.name=Annotation
402 annotation.problem.descriptor=Annotation <code>#ref</code> #loc
403 use.assert.as.identifier.display.name=Use of 'assert' as identifier
404 use.assert.as.identifier.problem.descriptor=Use of <code>#ref</code> as identifier #loc
405 assert.statement.display.name='assert' statement
406 statement.problem.descriptor=<code>#ref</code> statement #loc
407 auto.boxing.display.name=Auto-boxing
408 auto.boxing.problem.descriptor=Auto-boxing <code>#ref</code> #loc
409 auto.boxing.make.boxing.explicit.quickfix=Make boxing explicit
410 auto.boxing.ignore.added.to.collection.option=Ignore expressions added to a collection
411 auto.unboxing.display.name=Auto-unboxing
412 auto.unboxing.problem.descriptor=Auto-unboxing <code>#ref</code> #loc
413 auto.unboxing.make.unboxing.explicit.quickfix=Make unboxing explicit
414 use.enum.as.identifier.display.name=Use of 'enum' as identifier
415 use.enum.as.identifier.problem.descriptor=Use of <code>#ref</code> as identifier #loc
416 enumerated.class.display.name=Enumerated class
417 enumerated.class.problem.descriptor=Enumerated class <code>#ref</code> #loc
418 extended.for.statement.display.name=Extended 'for' statement
419 extended.for.statement.replace.quickfix=Replace with old-style 'for' statement
420 variable.argument.method.display.name=Variable argument method
421 variable.argument.method.problem.descriptor=Variable argument method <code>#ref()</code> #loc
422 variable.argument.method.quickfix=Convert variable argument parameter to array
423 hardcoded.file.separator.display.name=Hardcoded file separator
424 hardcoded.file.separator.problem.descriptor=Hardcoded file separator <code>#ref</code> #loc
425 hardcoded.file.separator.include.option=Include "example/*" in recognized MIME media types
426 hardcoded.line.separator.display.name=Hardcoded line separator
427 hardcoded.line.separator.problem.descriptor=Hardcoded line separator <code>#ref</code> #loc
428 native.method.display.name=Native method
429 native.method.problem.descriptor=Methods declared <code>#ref</code> are non-portable #loc
430 runtime.exec.call.display.name=Call to 'Runtime.exec()'
431 runtime.exec.call.problem.descriptor=Call to <code>Runtime.#ref()</code> is non-portable #loc
432 system.exit.call.display.name=Call to 'System.exit()' or related methods
433 system.exit.call.problem.descriptor=Call to <code>{0}.#ref()</code> is non-portable #loc
434 system.getenv.call.display.name=Call to 'System.getenv()'
435 system.getenv.call.problem.descriptor=Call to <code>System.#ref()</code> is non-portable #loc
436 use.of.awt.peer.class.display.name=Use of AWT peer class
437 use.of.awt.peer.class.problem.descriptor=Use of AWT peer class <code>#ref</code> is non-portable #loc
438 use.of.concrete.jdbc.driver.class.display.name=Use of concrete JDBC driver class
439 use.of.concrete.jdbc.driver.class.problem.descriptor=Use of concrete JDBC driver class <code>#ref</code> is non-portable #loc
440 use.processbuilder.class.display.name=Use of java.lang.ProcessBuilder class
441 use.processbuilder.class.problem.descriptor=Use of <code>#ref</code> is non-portable #loc
442 use.sun.classes.display.name=Use of sun.* classes
443 use.sun.classes.problem.descriptor=Use of Sun-supplied class <code>#ref</code> is non-portable #loc
444 abstract.class.with.only.one.direct.inheritor.display.name=Abstract class which has only one direct inheritor
445 anonymous.inner.may.be.named.static.inner.class.display.name=Anonymous inner class may be a named static inner class
446 anonymous.inner.may.be.named.static.inner.class.problem.descriptor=Anonymous inner class <code>#ref</code> may be a named static inner class #loc
447 array.length.in.loop.condition.display.name=Array.length in loop condition
448 array.length.in.loop.condition.problem.descriptor=Check of array <code>#ref</code> in loop condition #loc
449 large.array.allocation.no.outofmemoryerror.display.name=Large array allocation with no OutOfMemoryError check
450 large.array.allocation.no.outofmemoryerror.problem.descriptor=Large array allocation which is not checked for out-of-memory condition #loc
451 large.array.allocation.no.outofmemoryerror.maximum.number.of.elements.option=Maximum number of elements
452 connection.opened.not.safely.closed.display.name=Connection opened but not safely closed
453 field.repeatedly.accessed.in.method.display.name=Field repeatedly accessed in method
454 field.repeatedly.accessed.in.method.problem.descriptor=Field ''{0}'' accessed repeatedly in method <code>#ref(0</code> #loc
455 field.repeatedly.accessed.in.method.ignore.option=Ignore final fields
456 interface.one.inheritor.display.name=Interface which has only one direct inheritor
457 interface.one.inheritor.problem.descriptor=Interface <code>#ref</code> has only one direct inheritor #loc
458 method.call.in.loop.condition.display.name=Method call in loop condition
459 method.call.in.loop.condition.problem.descriptor=Call to method <code>#ref()</code> in loop condition #loc
460 large.initializer.primitive.type.array.display.name=Overly large initializer for array of primitive type
461 large.initializer.primitive.type.array.problem.descriptor=Primitive array initializer with too many elements ({0}) #loc
462 large.initializer.primitive.type.array.maximum.number.of.elements.option=Maximum number of elements
463 private.member.access.between.outer.and.inner.classes.display.name=Private member access between outer and inner classes
464 private.member.access.between.outer.and.inner.classes.problem.descriptor=Access to private member of class ''{0}'' #loc
465 private.member.access.between.outer.and.inner.classes.make.local.quickfix=Make ''{0}'' package local
466 recordstore.opened.not.safely.closed.display.name=RecordStore opened but not safely closed
467 overly.complex.anonymous.inner.class.display.name=Overly complex anonymous inner class
468 cyclomatic.complexity.limit.option=Cyclomatic complexity limit:
469 overly.complex.anonymous.inner.class.problem.descriptor=Overly complex anonymous inner class (cyclomatic complexity = {0}) #loc
470 anonymous.inner.class.with.too.many.methods.display.name=Anonymous inner class with too many methods
471 method.count.limit.option=Method count limit:
472 anonymous.inner.class.with.too.many.methods.problem.descriptor=Anonymous inner class with too many methods (method count = {0}) #loc
473 overly.complex.class.display.name=Overly complex class
474 overly.complex.class.problem.descriptor=<code>#ref</code> is overly complex (cyclomatic complexity = {0}) #loc
475 overly.coupled.class.display.name=Overly coupled class
476 overly.coupled.class.class.coupling.limit.option=Class coupling limit:
477 include.java.system.classes.option=Include couplings to java system classes
478 include.library.classes.option=Include couplings to library classes
479 overly.coupled.class.problem.descriptor=<code>#ref</code> is overly coupled (dependencies = {0}) #loc
480 class.too.deep.display.name=Class too deep in inheritance tree
481 class.too.deep.inheritance.depth.limit.option=Inheritance depth limit:
482 class.too.deep.problem.descriptor=<code>#ref</code> is too deep in inheritance tree (inheritance depth = {0}) #loc
483 inner.class.too.deeply.nested.display.name=Inner class too deeply nested
484 inner.class.too.deeply.nested.nesting.limit.option=Nesting limit:
485 inner.class.too.deeply.nested.problem.descriptor=<code>#ref</code> is too deeply nested (nesting level = {0}) #loc
486 too.many.constructors.display.name=Class with too many constructors
487 too.many.constructors.count.limit.option=Constructor count limit:
488 too.many.constructors.problem.descriptor=<code>#ref</code> has too many constructors (constructor count = {0}) #loc
489 too.many.fields.display.name=Class with too many fields
490 too.many.fields.count.limit.option=Field count limit:
491 too.many.fields.problem.descriptor=<code>#ref</code> has too many fields (field count = {0}) #loc
492 too.many.methods.display.name=Class with too many methods
493 too.many.methods.problem.descriptor=<code>#ref</code> has too many methods (method count = {0}) #loc
494 externalizable.with.serialization.methods.display.name=Externalizable class with 'readObject()' or 'writeObject()'
495 externalizable.with.serialization.methods.problem.descriptor.both=Externalizable class <code>#ref</code> defines readObject() and writeObject() #loc
496 externalizable.with.serialization.methods.problem.descriptor.write=Externalizable class <code>#ref</code> defines writeObject() #loc
497 externalizable.with.serialization.methods.problem.descriptor.read=Externalizable class <code>#ref</code> defines readObject() #loc
498 non.serializable.with.serialversionuid.display.name=Non-serializable class with 'serialVersionUID'
499 non.serializable.class.with.serialversionuid.problem.descriptor=Non-serializable class <code>#ref</code> defines a 'serialVersionUID' field #loc
500 non.serializable.interface.with.serialversionuid.problem.descriptor=Non-serializable interface <code>#ref</code> defines a 'serialVersionUID' field #loc
501 non.serializable.@interface.with.serialversionuid.problem.descriptor=Non-serializable @interface <code>#ref</code> defines a 'serialVersionUID' field #loc
502 non.serializable.anonymous.with.serialversionuid.problem.descriptor=Non-serializable anonymous class extending <code>#ref</code> defines a 'serialVersionUID' field #loc
503 non.serializable.with.serialversionuid.remove.quickfix=Remove 'serialVersionUID' field
504 non.serializable.class.with.readwriteobject.display.name=Non-serializable class with 'readObject()' or 'writeObject()'
505 non.serializable.class.with.readwriteobject.problem.descriptor.both=Non-serializable class <code>#ref</code> defines readObject() and writeObject() #loc
506 non.serializable.class.with.readwriteobject.problem.descriptor.write=Non-serializable class <code>#ref</code> defines writeObject() #loc
507 non.serializable.class.with.readwriteobject.problem.descriptor.read=Non-serializable class <code>#ref</code> defines readObject() #loc
508 non.serializable.anonymous.with.readwriteobject.problem.descriptor.both=Non-serializable anonymous class extending <code>#ref</code> defines readObject() and writeObject() #loc
509 non.serializable.anonymous.with.readwriteobject.problem.descriptor.write=Non-serializable anonymous class extending <code>#ref</code> defines writeObject() #loc
510 non.serializable.anonymous.with.readwriteobject.problem.descriptor.read=Non-serializable anonymous class extending <code>#ref</code> defines readObject() #loc
511 readwriteobject.private.display.name='readObject()' or 'writeObject()' not declared 'private'
512 readwriteobject.private.problem.descriptor=<code>#ref</code> not declared 'private' #loc
513 readobject.initialization.display.name=Instance variable may not be initialized by 'readObject()'
514 readobject.initialization.problem.descriptor=Instance variable <code>#ref</code> may not be initialized during 'readObject()' call #loc
515 readresolve.writereplace.protected.display.name='readResolve()' or 'writeReplace()' not declared 'protected'
516 readresolve.writereplace.protected.problem.descriptor=<code>#ref()</code> not declared 'protected' #loc
517 serialpersistentfields.with.wrong.signature.display.name='serialPersistentFields' field not declared 'private static final ObjectStreamField[]'
518 serialpersistentfields.with.wrong.signature.problem.descriptor=<code>#ref</code> field of a Serializable class is not declared 'private static final ObjectStreamField[]' #loc
519 serialversionuid.private.static.final.long.display.name='serialVersionUID' field not declared 'private static final long'
520 serialversionuid.private.static.final.long.problem.descriptor=<code>#ref</code> field of a Serializable class is not declared 'private static final long' #loc
521 serializable.class.without.serialversionuid.display.name=Serializable class without 'serialVersionUID'
522 serializable.class.without.serialversionuid.problem.descriptor=<code>#ref</code> does not define a 'serialVersionUID' field #loc
523 serializable.class.without.serialversionuid.ignore.option=Ignore classes serializable due to inheritance
526 non.protected.constructor.in.abstract.class.display.name='public' constructor 'abstract' class
527 unnecessary.qualifier.for.this.display.name=Unnecessary qualifier for 'this'
528 multiple.declaration.display.name=Multiple variables in one declaration
529 thread.priority.display.name=Call to 'Thread.setPriority()'
530 too.broad.scope.display.name=Scope of variable is too broad
531 infinite.loop.statement.display.name=Infinite loop statement
532 asserts.without.messages.display.name=Message missing on JUnit assertion
533 constant.naming.convention.display.name=Constant naming convention
534 random.double.for.random.integer.display.name=Using 'Random.nextDouble()' to get random integer
535 test.method.without.assertion.display.name=JUnit test method without any assertions
536 string.buffer.replaceable.by.string.builder.display.name='StringBuffer' may be 'StringBuilder' (JDK 5.0 only)
537 comparison.of.short.and.char.display.name=Comparison of 'short' and 'char' values
538 unnecessary.fully.qualified.name.display.name=Unnecessary fully qualified name
539 unnecessary.label.on.break.statement.display.name=Unnecessary label on 'break' statement
540 exception.name.doesnt.end.with.exception.display.name=Exception class name does not end with 'Exception'
541 bad.exception.declared.display.name=Prohibited exception declared
542 deserializable.class.in.secure.context.display.name=Deserializable class in secure context
543 pointless.boolean.expression.display.name=Pointless boolean expression
544 class.without.constructor.display.name=Class without constructor
545 break.statement.display.name='break' statement
546 unconditional.wait.display.name=Unconditional 'wait()' call
547 cyclomatic.complexity.display.name=Overly complex method
548 string.to.string.display.name=Redundant 'String.toString()'
549 constant.on.lhs.of.comparison.display.name=Constant on left side of comparison
550 final.class.display.name='final' class
551 labeled.statement.display.name=Labeled statement
552 notify.called.on.condition.display.name='notify()' or 'notifyAll()' called on java.util.concurrent.locks.Condition object
553 loop.statements.that.dont.loop.display.name=Loop statement that does not loop
554 thread.run.display.name=Call to 'Thread.run()'
555 non.synchronized.method.overrides.synchronized.method.display.name=Unsynchronized method overrides synchronized method
556 constant.on.rhs.of.comparison.display.name=Constant on right side of comparison
557 synchronize.on.this.display.name=Synchronization on 'this'
558 switch.statement.with.too.many.branches.display.name='switch' statement with too many branches
559 utility.class.without.private.constructor.display.name=Utility class without private constructor
560 throw.caught.locally.display.name='throw' caught by containing 'try' statement
561 exception.from.catch.which.doesnt.wrap.display.name='throw' inside 'catch' block which ignores the caught exception
562 type.parameter.naming.convention.display.name=Type parameter naming convention
563 multiply.or.divide.by.power.of.two.display.name=Multiply or divide by power of two
564 multiply.or.divide.by.power.of.two.divide.option=Check divisions by a power of two also
565 serializable.with.unconstructable.ancestor.display.name=Serializable class with unconstructable ancestor
566 missorted.modifiers.display.name=Missorted modifers
567 sleep.while.holding.lock.display.name=Call to 'Thread.sleep()' while synchronized
568 singleton.display.name=Singleton
569 unnecessary.final.on.parameter.display.name=Unnecessary 'final' for method parameter
570 thread.death.rethrown.display.name=java.lang.ThreadDeath not rethrown
571 if.statement.with.too.many.branches.display.name='if' statement with too many branches
572 redundant.implements.display.name=Redundant interface declaration
573 nesting.depth.display.name=Overly nested method
574 return.this.display.name=Return of 'this'
575 busy.wait.display.name=Busy wait
576 utility.class.display.name=Utility class
577 instantiating.object.to.get.class.object.display.name=Instantiating object to get Class object
578 abstract.class.extends.concrete.class.display.name=Abstract class extends concrete class
579 parameter.naming.convention.display.name=Method parameter naming convention
580 integer.division.in.floating.point.context.display.name=Integer division in floating point context
581 interface.naming.convention.display.name=Interface naming convention
582 length.one.strings.in.concatenation.display.name=Single character string concatenation
583 length.one.string.in.indexof.display.name= Single character string argument in 'String.indexOf()' call
584 unnecessary.conditional.expression.display.name=Redundant conditional expression
585 thread.yield.display.name=Call to 'Thread.yield()'
586 confusing.floating.point.literal.display.name=Confusing floating-point literal
587 wait.not.in.loop.display.name='wait()' not in loop
588 string.concatenation.inside.string.buffer.append.display.name=String concatenation inside 'StringBuffer.append()'
589 class.initializer.display.name=Non-static initializer
590 enumerated.class.naming.convention.display.name=Enumerated class naming convention
591 non.thread.safe.lazy.initialization.display.name=Unsafe lazy initialization of static field
592 call.to.simple.setter.in.class.display.name=Call to simple setter from within class
593 comparison.to.nan.display.name=Comparison to Double.NaN or Float.NaN
594 instance.method.naming.convention.display.name=Instance method naming convention
595 unnecessary.semicolon.display.name=Unnecessary semicolon
596 fallthru.in.switch.statement.display.name=Fallthrough in 'switch' statement
597 call.to.native.method.while.locked.display.name=Call to a native method while locked
598 switch.statement.display.name='switch' statement
599 custom.classloader.display.name=Custom ClassLoader
600 nested.conditional.expression.display.name=Nested conditional expression
601 duplicate.condition.display.name=Duplicate condition in 'if' statement
602 duplicate.boolean.branch.display.name=Duplicate condition on '\\&\\&' or '||'
603 method.with.multiple.loops.display.name=Method with multiple loops
604 non.comment.source.statements.display.name=Overly long method
605 local.variable.naming.convention.display.name=Local variable naming convention
606 negated.if.else.display.name='if' statement with negated condition
607 class.naming.convention.display.name=Class naming convention
608 serializable.inner.class.with.non.serializable.outer.class.display.name=Serializable non-static inner class with non-Serializable outer class
609 pointless.arithmetic.expression.display.name=Pointless arithmetic expression
610 method.name.same.as.class.name.display.name=Method name same as class name
611 unnecessary.temporary.on.conversion.to.string.display.name=Unnecessary temporary object in conversion to String
612 unnecessary.continue.display.name=Unnecessary 'continue' statement
613 inner.class.on.interface.display.name=Inner class of interface
614 unused.label.display.name=Unused label
615 multiple.typed.declaration.display.name=Variables of different types in one declaration
616 overly.complex.boolean.expression.display.name=Overly complex boolean expression
617 continue.statement.with.label.display.name='continue' statement with label
618 class.loader.instantiation.display.name=ClassLoader instantiation
619 return.from.finally.block.display.name='return' inside 'finally' block
620 unnecessary.boxing.display.name=Unnecessary boxing
621 annotation.naming.convention.display.name=Annotation naming convention
622 checked.exception.class.display.name=Checked exception class
623 switch.statement.with.confusing.declaration.display.name=Local variable used and declared in different 'switch' branches
624 cast.that.loses.precision.display.name=Numeric cast that loses precision
625 manual.array.copy.display.name=Manual array copy
626 manual.array.to.collection.copy.display.name=Manual array to collection copy
627 long.literals.ending.with.lowercase.l.display.name=Long literal ending with 'l' instead of 'L'
628 overly.complex.arithmetic.expression.display.name=Overly complex arithmetic expression
629 j.unit.abstract.test.class.naming.convention.display.name=JUnit abstract test class naming convention
630 unnecessary.parentheses.display.name=Unnecessary parentheses
631 test.case.in.product.code.display.name=JUnit TestCase in product source
632 test.method.in.product.code.display.name=JUnit test method in product source
633 serializable.class.in.secure.context.display.name=Serializable class in secure context
634 static.variable.naming.convention.display.name=Static variable naming convention
635 nested.method.call.display.name=Nested method call
636 throw.from.finally.block.display.name='throw' inside 'finally' block
637 field.accessed.synchronized.and.unsynchronized.display.name=Field accessed in both synchronized and unsynchronized contexts
638 catch.generic.class.display.name='catch' generic class
639 abstract.method.overrides.abstract.method.display.name=Abstract method overrides abstract method
640 static.non.final.field.display.name='static', non-'final' field
641 substring.zero.display.name=Redundant '.substring(0)'
642 class.without.no.arg.constructor.display.name=Class without no-arg constructor
643 unnecessary.return.display.name=Unnecessary 'return' statement
644 final.static.method.display.name='static' method declared 'final'
645 constant.declared.in.abstract.class.display.name=Constant declared in abstract class
646 too.broad.catch.display.name=Overly broad 'catch' block
647 floating.point.equality.display.name=Floating point equality comparison
648 thrown.exceptions.per.method.display.name=Method with too many exceptions declared
649 public.static.array.field.display.name='public static' array field
650 await.not.in.loop.display.name='await()' not in loop
651 method.names.differ.only.by.case.display.name=Method names differing only by case
652 unsecure.random.number.generation.display.name=Insecure random number generation
653 parameters.per.method.display.name=Method with too many parameters
654 parameters.per.constructor.display.name=Constructor with too many parameters
655 unnecessary.unboxing.display.name=Unnecessary unboxing
656 extends.thread.display.name=Class explicitly extends java.lang.Thread
657 misspelled.tear.down.display.name='teardown()' instead of 'tearDown()'
658 test.case.with.constructor.display.name=JUnit TestCase with non-trivial constructors
659 parameter.name.differs.from.overridden.parameter.display.name=Parameter name differs from parameter in overridden method
660 final.private.method.display.name='private' method declared 'final'
661 enum.switch.statement.which.misses.cases.display.name=Enum 'switch' statement that misses case
662 enum.switch.statement.which.misses.cases.option=Ignore switch statements with a default branch
663 setup.calls.super.setup.display.name='setUp()' does not call 'super.setUp()'
664 unconstructable.test.case.display.name=Unconstructable JUnit TestCase
665 volatile.long.or.double.field.display.name=Volatile long or double field
666 string.buffer.must.have.initial.capacity.display.name=StringBuffer or StringBuilder without initial capacity
667 method.may.be.static.display.name=Method may be 'static'
668 class.initializer.may.be.static.display.name=Class initializer may be 'static'
669 nested.switch.statement.display.name=Nested 'switch' statement
670 c.style.array.declaration.display.name=C-style array declaration
671 final.method.in.final.class.display.name='final' method in 'final' class
672 extends.annotation.display.name=Class extends annotation interface
673 naked.notify.display.name='notify()' or 'notifyAll()' without corresponding state change
674 constant.if.statement.display.name=Constant if statement
675 switch.statement.density.display.name='switch' statement with too low of a branch density
676 switch.statement.with.too.few.branches.display.name='switch' statement with too few branches
677 upper.case.field.name.not.constant.display.name=Non-constant field with upper-case name
678 unnecessary.label.on.continue.statement.display.name=Unnecessary label on 'continue' statement
679 jdbc.prepare.statement.with.non.constant.string.display.name='Connection.prepare*()' call with non-constant string
680 synchronize.on.non.final.field.display.name=Synchronization on a non-final field
681 noop.method.in.abstract.class.display.name=No-op method in abstract class
682 non.final.field.of.exception.display.name=Non-final field of exception class
683 nested.try.statement.display.name=Nested 'try' statement
684 condition.signal.display.name=Call to 'signal()' instead of 'signalAll()'
685 jdbc.execute.with.non.constant.string.display.name='Statement.execute()' call with non-constant string
686 system.set.security.manager.display.name=Call to 'System.setSecurityManager()'
687 system.set.security.manager.problem.descriptor=Call to <code>System.#ref()</code> may pose security concerns #loc
688 control.flow.statement.without.braces.display.name=Control flow statement without braces
689 trivial.if.display.name=Redundant 'if' statement
690 thread.with.default.run.method.display.name=Instantiating a Thread with default 'run()' method
691 while.loop.spins.on.field.display.name=While loop spins on field
692 object.equals.null.display.name=Object.equals(null)
693 test.method.is.public.void.no.arg.display.name=Test method with incorrect signature
694 if.statement.with.identical.branches.display.name='if' statement with identical branches
695 multiple.return.points.per.method.display.name=Method with multiple return points.
696 break.statement.with.label.display.name='break' statement with label
697 public.constructor.in.non.public.class.display.name='public' constructor in non-public class
698 questionable.name.display.name=Questionable name
699 empty.finally.block.display.name=Empty 'finally' block
700 abstract.method.overrides.concrete.method.display.name=Abstract method overrides concrete method
701 thread.stop.suspend.resume.display.name=Call to 'Thread.stop()', 'suspend()' or 'resume()'
702 constant.math.call.display.name=Constant call to java.lang.Math or StrictMath
703 volatile.array.field.display.name=Volatile array field
704 literal.as.arg.to.string.equals.display.name=expression.equals("literal") rather than "literal".equals(expression)
705 unnecessary.final.on.local.variable.display.name=Unnecessary 'final' for local variable
706 inner.class.may.be.static.display.name=Inner class may be 'static'
707 static.suite.display.name='suite()' method not declared 'static'
708 redundant.field.initialization.display.name=Redundant field initialization
709 string.buffer.to.string.in.concatenation.display.name='StringBuffer.toString()' in concatenation
710 utility.class.with.public.constructor.display.name=Utility class with 'public' constructor
711 for.loop.replaceable.by.while.display.name='for' loop may be replaced with 'while' loop
712 missing.deprecated.annotation.display.name=Missing @Deprecated annotation
713 cloneable.class.in.secure.context.display.name=Cloneable class in secure context
714 static.inheritance.display.name=Static inheritance
715 class.name.prefixed.with.package.name.display.name=Class name prefixed with package name
716 call.to.simple.getter.in.class.display.name=Call to simple getter from within class
717 class.name.differs.from.file.name.display.name=Class name differs from file name
718 protected.member.in.final.class.display.name='protected' member in 'final' class
719 load.library.with.non.constant.string.display.name=Call to 'System.loadLibrary()' with non-constant string
720 instanceof.catch.parameter.display.name='instanceof' on 'catch' parameter
721 implicit.numeric.conversion.display.name=Implicit numeric conversion
722 unnecessary.interface.modifier.display.name=Unnecessary interface modifier
723 confusing.main.method.display.name=Confusing 'main()' method
724 octal.literal.display.name=Octal integer
725 misordered.assert.equals.parameters.display.name=Misordered 'assertEquals()' parameters
726 unnecessary.constructor.display.name=Redundant no-arg constructor
727 method.name.same.as.parent.name.display.name=Method name same as parent class name
728 java.lang.reflect.display.name=Use of java.lang.reflect
729 while.can.be.foreach.display.name='while' loop replaceable with 'for each'
730 big.decimal.equals.display.name='equals()' called on java.math.BigDecimal
731 wait.not.in.synchronized.context.display.name='wait()' while not synchronized
732 implicit.call.to.super.display.name=Implicit call to 'super()'
733 empty.catch.block.display.name=Empty 'catch' block
734 unqualified.static.usage.display.name=Unqualified static usage
735 simplifiable.junit.assertion.display.name=Simplifiable JUnit assertion
736 object.notify.display.name=Call to 'notify()' instead of 'notifyAll()'
737 thread.start.in.construction.display.name=Call to 'Thread.start()' during object construction
738 non.final.clone.display.name=Non-final 'clone()' in secure context
739 unnecessary.temporary.on.conversion.from.string.display.name=Unnecessary temporary object in conversion from String
740 unnecessary.this.display.name=Unnecessary 'this' qualifier
741 runtime.exec.with.non.constant.string.display.name=Call to 'Runtime.exec()' with non-constant string
742 system.properties.display.name=Access of system properties
743 chained.method.call.display.name=Chained method calls
744 notify.not.in.synchronized.context.display.name='notify()' or 'notifyAll()' while not synced
745 safe.lock.display.name=Lock acquired but not safely unlocked
746 system.run.finalizers.on.exit.display.name=Call to 'System.runFinalizersOnExit()'
747 for.can.be.foreach.display.name='for' loop replaceable with 'for each'
748 type.parameter.extends.object.display.name=Type parameter explicitly extends 'java.lang.Object'
749 marker.interface.display.name=Marker interface
750 limited.scope.inner.class.display.name=Limited-scope inner class
751 switch.statements.without.default.display.name='switch' statement without 'default' branch
752 unchecked.exception.class.display.name=Unchecked exception class
753 for.loop.with.missing.component.display.name='for' loop with missing components
754 for.loop.with.missing.component.collection.loop.option=Ignore collection iterations
755 double.checked.locking.display.name=Double-checked locking
756 double.checked.locking.problem.descriptor=Double-checked locking #loc
757 double.checked.locking.ignore.on.volatiles.option=Ignore double-checked locking on volatile fields
758 string.buffer.replaceable.by.string.display.name=Constant StringBuffer may be String
759 boolean.method.name.must.start.with.question.display.name=Boolean method name must start with question word
760 class.name.same.as.ancestor.name.display.name=Class name same as ancestor name
761 error.rethrown.display.name=java.lang.Error not rethrown
762 serializable.has.serialization.methods.display.name=Serializable class without 'readObject()' and 'writeObject()'
763 misspelled.set.up.display.name='setup()' instead of 'setUp()'
764 setup.is.public.void.no.arg.display.name='setUp()' with incorrect signature
765 missing.override.annotation.display.name=Missing @Override annotation
766 wait.while.holding.two.locks.display.name='wait()' while holding two locks
767 empty.class.display.name=Empty class
768 trivial.string.concatenation.display.name=Concatenation with empty string
769 empty.synchronized.statement.display.name=Empty 'synchronized' statement
770 unnecessary.default.display.name=Unnecessary 'default' for enum switch statement
771 simplifiable.conditional.expression.display.name=Conditional that can be simplified to \\&\\& or ||
772 simplifiable.if.statement.display.name=If statement may be replaced with \\&\\& or || expression
773 unnecessary.super.constructor.display.name=Unnecessary call to 'super()'
774 unnecessarily.qualified.static.usage.display.name=Unnecessarily qualified static usage
775 bad.exception.caught.display.name=Prohibited exception caught
776 custom.security.manager.display.name=Custom SecurityManager
777 teardown.is.public.void.no.arg.display.name='tearDown()' with incorrect signature
778 string.concatenation.in.loops.display.name=String concatenation in loop
779 comparing.references.display.name=== used instead of equals()
780 boolean.constructor.display.name=Boolean constructor call
781 continue.statement.display.name='continue' statement
782 extends.object.display.name=Class explicitly extends java.lang.Object
783 serializable.inner.class.has.serial.version.uid.field.display.name=Serializable non-static inner class without 'serialVersionUID'
784 static.method.naming.convention.display.name=Static method naming convention
785 empty.try.block.display.name=Empty 'try' block
786 field.has.setter.but.no.getter.display.name=Field has setter but no getter
787 three.negations.per.method.display.name=Method with more than three negations
788 conditional.expression.display.name=Conditional expression (?:)
789 unnecessary.enum.modifier.display.name=Unnecessary enum modifier
790 string.equals.empty.string.display.name='String.equals("")'
791 teardown.calls.super.teardown.display.name='tearDown()' does not call 'super.tearDown()'
792 synchronize.on.lock.display.name=Synchronization on a Lock object
793 synchronized.on.literal.object.name=Synchronization on an object initialized with a literal
794 field.may.be.static.display.name=Field may be 'static'
795 class.may.be.interface.display.name=Class may be interface
796 abstract.class.without.abstract.methods.display.name=Abstract class without abstract methods
797 divide.by.zero.display.name=Division by zero
798 default.not.last.case.in.switch.display.name='default' not last case in 'switch'
799 nested.synchronized.statement.display.name=Nested 'synchronized' statement
800 constant.conditional.expression.display.name=Constant conditional expression
801 unused.catch.parameter.display.name=Unused 'catch' parameter
802 class.in.top.level.package.display.name=Class without package statement
803 confusing.else.display.name=Confusing 'else' branch
804 public.field.accessed.in.synchronized.context.display.name=Non-private field accessed in synchronized context
805 string.replaceable.by.string.buffer.display.name=Non-constant String should be StringBuilder
806 j.unit.test.class.naming.convention.display.name=JUnit test class naming convention
807 method.coupling.display.name=Overly coupled method
808 collections.must.have.initial.capacity.display.name=Collection without initial capacity
809 anonymous.inner.class.display.name=Anonymous inner class
810 negated.conditional.display.name=Conditional expression with negated condition
811 non.reproducible.math.call.display.name=Non-reproducible call to java.lang.Math
812 multiple.top.level.classes.in.file.display.name=Multiple top level classes in single file
813 set.replaceable.by.enum.set.display.name=Set replaceable with EnumSet
814 non.static.inner.class.in.secure.context.display.name=Non-static inner class in secure context
815 tail.recursion.display.name=Tail recursion
816 finally.block.cannot.complete.normally.display.name='finally' block which can not complete normally
817 arithmetic.on.volatile.field.display.name=Arithmetic operation on volatile field
818 public.static.collection.field.display.name='public static' collection field
819 non.exception.name.ends.with.exception.display.name=Non-exception class name ends with 'Exception'
820 synchronized.method.display.name='synchronized' method
821 enumerated.constant.naming.convention.display.name=Enumerated constant naming convention
822 final.method.display.name='final' method
823 transient.field.in.non.serializable.class.display.name=Transient field in non-serializable class
824 bad.exception.thrown.display.name=Prohibited exception thrown
825 conditional.expression.with.identical.branches.display.name=Conditional expression with identical branches
826 raw.use.of.parameterized.type.display.name=Raw use of parameterized class
827 standard.variable.names.display.name=Standard variable names
828 instance.variable.naming.convention.display.name=Instance variable naming convention
829 dollar.sign.in.name.display.name=Use of '$' in identifier
830 map.replaceable.by.enum.map.display.name=Map replaceable with EnumMap
831 extends.concrete.collection.display.name=Class explicitly extends a Collection class
832 continue.or.break.from.finally.block.display.name='continue' or 'break' inside 'finally' block
833 abstract.method.with.missing.implementations.display.name=Abstract method with missing implementations
834 object.allocation.in.loop.display.name=Object allocation in loop
835 wait.called.on.condition.display.name='wait()' called on java.util.concurrent.locks.Condition object
836 test.case.with.no.test.methods.display.name=JUnit test case with no tests
837 abstract.class.never.implemented.display.name=Abstract class which has no concrete subclass
838 interface.never.implemented.display.name=Interface which has no concrete subclass
839 constant.declared.in.interface.display.name=Constant declared in interface
843 exception.name.doesnt.end.with.exception.problem.descriptor=Exception class name <code>#ref</code> does not end with 'Exception' #loc
844 non.exception.name.ends.with.exception.problem.descriptor=Non-exception class name <code>#ref</code> ends with 'Exception' #loc
845 class.name.prefixed.with.package.name.problem.descriptor=Class name <code>#ref</code> begins with its package name #loc
846 class.name.same.as.ancestor.name.problem.descriptor=Class name <code>#ref</code> is the same as one of its superclass' names #loc
847 method.name.same.as.class.name.problem.descriptor=Method name <code>#ref</code> is the same as its class name #loc
848 method.name.same.as.parent.name.problem.descriptor=Method name <code>#ref</code> is the same as its parent class name #loc
849 boolean.method.name.must.start.with.question.problem.descriptor=Boolean method name <code>#ref</code> does not start with question word #loc
850 questionable.name.problem.descriptor=Questionable name <code>#ref</code> #loc
851 confusing.main.method.problem.descriptor=Method named <code>#ref</code> without signature 'public static void main(String[])' #loc
852 upper.case.field.name.not.constant.problem.descriptor=Non-constant field <code>#ref</code> with constant-style name #loc
853 dollar.sign.in.name.problem.descriptor=identifer <code>#ref</code> contains '$' #loc
854 integer.division.in.floating.point.context.problem.descriptor=<code>#ref</code>: integer division in floating-point context #loc
855 comparison.of.short.and.char.problem.descriptor=Equality comparison <code>#ref</code> of short and char values #loc
856 big.decimal.equals.problem.descriptor=<code>#ref()</code> between BigDecimal values should probably be 'compareTo()' #loc
857 divide.by.zero.problem.descriptor=Division by zero #loc
858 non.reproducible.math.call.problem.descriptor=<code>Math.#ref()</code> may produce non-reproducible results #loc
859 constant.math.call.problem.descriptor=Constant call to <code>#ref()</code> can be simplified #loc
860 floating.point.equality.problem.descriptor=<code>#ref</code>: floating point values compared for exact equality #loc
861 fallthru.in.switch.statement.problem.descriptor=<code>#ref</code> fallthrough in 'switch' statement #loc
862 switch.statements.without.default.problem.descriptor=<code>#ref</code> statement without 'default' branch #loc
863 default.not.last.case.in.switch.problem.descriptor=<code>#ref</code> branch not last case in 'switch' #loc
864 loop.statements.that.dont.loop.problem.descriptor=<code>#ref</code> statement does not loop #loc
865 conditional.expression.with.identical.branches.problem.descriptor=Conditional expression <code>#ref</code> with identical branches #loc
866 if.statement.with.identical.branches.problem.descriptor=<code>#ref</code> statement with identical branches #loc
867 duplicate.condition.problem.descriptor=Duplicate condition <code>#ref</code> #loc
868 duplicate.condition.ignore.method.calls.option=Ignore method calls in condition
869 duplicate.boolean.branch.problem.descriptor=Duplicate branch <code>#ref</code> #loc
870 iterator.next.does.not.throw.nosuchelementexception.problem.descriptor=<code>Iterator.#ref()</code> which can't throw 'NoSuchElementException' #loc
871 infinite.loop.statement.problem.descriptor=<code>#ref</code> statement cannot complete without throwing an exception #loc
872 confusing.floating.point.literal.problem.descriptor=Confusing floating point literal <code>#ref</code> #loc
873 overly.complex.arithmetic.expression.problem.descriptor=Overly complex arithmetic expression #loc
874 overly.complex.boolean.expression.problem.descriptor=Overly complex boolean expression #loc
875 labeled.statement.problem.descriptor=Labeled statement <code>#ref:</code> #loc
876 break.statement.with.label.problem.descriptor=<code>#ref</code> statement with label #loc
877 continue.statement.with.label.problem.descriptor=<code>#ref</code> statement with label #loc
878 conditional.expression.problem.descriptor=Conditional expression <code>#ref</code> #loc
879 conditional.expression.option=Ignore for simple assignments and returns
880 nested.conditional.expression.problem.descriptor=Nested conditional expression <code>#ref</code> #loc
881 long.literals.ending.with.lowercase.l.problem.descriptor=Long literal <code>#ref</code> ends with lowercase 'l' #loc
882 nested.switch.statement.problem.descriptor=Nested <code>#ref</code> statement #loc
883 chained.method.call.problem.descriptor=Chained method call <code>#ref()</code> #loc
884 nested.method.call.problem.descriptor=Nested method call <code>#ref()</code> #loc
885 octal.literal.problem.descriptor=Octal integer <code>#ref</code> #loc
886 implicit.call.to.super.problem.descriptor=Implicit call to super() <code>#ref</code> #loc
887 negated.if.else.problem.descriptor=<code>#ref</code> statement with negated condition #loc
888 negated.conditional.problem.descriptor=Conditional expression with negated condition #loc
889 confusing.else.problem.descriptor=<code>#ref</code> branch may be unwrapped, as the if branch never completes #loc
890 switch.statement.with.confusing.declaration.problem.descriptor=Local variable <code>#ref</code> declared in one switch branch and used in another #loc
891 raw.use.of.parameterized.type.problem.descriptor=Raw use of parameterized class <code>#ref</code> #loc
892 final.class.problem.descriptor=Class declared <code>#ref</code> #loc
893 empty.class.problem.descriptor=Class <code>#ref</code> is empty #loc
894 empty.class.file.without.class.problem.descriptor=Java file does not declare any class #loc
895 empty.anonymous.class.problem.descriptor=Anonymous class is empty #loc
896 anonymous.inner.class.problem.descriptor=Anonymous inner class <code>#ref</code> #loc
897 limited.scope.inner.class.problem.descriptor=Limited-scope inner class <code>#ref</code> #loc
898 final.method.problem.descriptor=Method declared <code>#ref</code> #loc
899 class.initializer.problem.descriptor=Non-static initializer #loc
900 class.may.be.interface.problem.descriptor=<code>#ref</code> may be interface #loc
901 non.protected.constructor.in.abstract.class.problem.descriptor=Constructor <code>#ref</code> is not declared 'protected' in 'abstract' class #loc
902 class.without.constructor.problem.descriptor=<code>#ref</code> has no constructor #loc
903 abstract.class.without.abstract.methods.problem.descriptor=Class <code>#ref</code> is declared 'abstract', and has no 'abstract' methods #loc
904 final.method.in.final.class.problem.descriptor=Method declared <code>#ref</code> in 'final' class #loc
905 protected.member.in.final.class.problem.descriptor=Class member declared <code>#ref</code> in 'final' class #loc
906 utility.class.with.public.constructor.problem.descriptor=Class <code>#ref</code> has only 'static' members, and a 'public' constructor #loc
907 utility.class.without.private.constructor.problem.descriptor=Class <code>#ref</code> has only 'static' members, and lacks a 'private' constructor #loc
908 abstract.method.overrides.concrete.method.problem.descriptor=Abstract method <code>#ref()</code> overrides concrete method #loc
909 abstract.method.with.missing.implementations.problem.descriptor=Abstract method <code>#ref()</code> is not implemented in every subclass #loc
910 abstract.method.overrides.abstract.method.problem.descriptor=Abstract method <code>#ref()</code> overrides abstract method #loc
911 abstract.class.extends.concrete.class.problem.descriptor=Class <code>#ref</code> is declared 'abstract', and extends a concrete class #loc
912 static.non.final.field.problem.descriptor=Static non-final field <code>#ref</code> #loc
913 constant.declared.in.abstract.class.problem.descriptor=Constant <code>#ref</code> declared in abstract class #loc
914 constant.declared.in.interface.problem.descriptor=Constant <code>#ref</code> declared in interface #loc
915 static.inheritance.problem.descriptor=Interface <code>#ref</code> is implemented only for its static constants #loc
916 class.in.top.level.package.problem.descriptor=Class <code>#ref</code> lacks a package statement #loc
917 utility.class.problem.descriptor=Class <code>#ref</code> has only 'static' members, indicating procedural construction #loc
918 singleton.problem.descriptor=Class <code>#ref</code> is a singleton #loc
919 final.private.method.problem.descriptor='private' method declared <code>#ref</code> #loc
920 noop.method.in.abstract.class.problem.descriptor=No-op Method <code>#ref()</code> should be made abstract #loc
921 final.static.method.problem.descriptor='static' method declared <code>#ref</code> #loc
922 class.without.no.arg.constructor.problem.descriptor=<code>#ref</code> has no no-arg constructor #loc
923 multiple.top.level.classes.in.file.problem.descriptor=Multiple top level classes in file
924 class.name.differs.from.file.name.problem.descriptor=Class name <code>#ref</code> differs from file name #loc
925 marker.interface.problem.descriptor=Marker interface <code>#ref</code> #loc
926 field.has.setter.but.no.getter.problem.descriptor=Field <code>#ref</code> has setter but no getter #loc
927 abstract.class.never.implemented.problem.descriptor=Abstract class <code>#ref</code> has no concrete subclass #loc
928 interface.never.implemented.problem.descriptor=Interface <code>#ref</code> has no concrete subclass #loc
929 missing.deprecated.annotation.problem.descriptor=Missing '@Deprecated' annotation on <code>#ref()</code> #loc
930 missing.override.annotation.problem.descriptor=Missing '@Override' annotation on <code>#ref()</code> #loc
931 non.thread.safe.lazy.initialization.problem.descriptor=Lazy initialization of static field <code>#ref</code> is not thread-safe #loc
932 catch.generic.class.problem.descriptor=catch of generic <code>#ref</code> class should be replaced with more precise exception #loc
933 empty.catch.block.problem.descriptor=Empty <code>#ref</code> block #loc
934 unused.catch.parameter.problem.descriptor=Unused catch parameter <code>#ref</code> #loc
935 used.catch.parameter.named.ignore.problem.descriptor=Catch parameter named <code>#ref</code> is used #loc
936 empty.finally.block.problem.descriptor=Empty <code>#ref</code> block #loc
937 finally.block.cannot.complete.normally.problem.descriptor=<code>#ref</code> block can not complete normally #loc
938 empty.try.block.problem.descriptor=Empty <code>#ref</code> block #loc
939 throw.from.finally.block.problem.descriptor=<code>#ref</code> inside 'finally' block #loc
940 throw.caught.locally.problem.descriptor=<code>#ref</code> caught by containing 'try' statement #loc
941 throw.caught.locally.ignore.option=Ignore rethrown exceptions
942 return.from.finally.block.problem.descriptor=<code>#ref</code> inside 'finally' block #loc
943 continue.or.break.from.finally.block.problem.descriptor=<code>#ref</code> inside 'finally' block #loc
944 bad.exception.declared.problem.descriptor=Prohibited exception <code>#ref</code> declared. #loc
945 bad.exception.caught.problem.descriptor=Prohibited exception <code>#ref</code> caught. #loc
946 checked.exception.class.problem.descriptor=Checked exception class <code>#ref</code> #loc
947 unchecked.exception.class.problem.descriptor=Unchecked exception class <code>#ref</code> #loc
948 thread.death.rethrown.problem.descriptor=<code>#ref</code> not rethrown #loc
949 error.rethrown.problem.descriptor=Error <code>#ref</code> not rethrown #loc
950 nested.try.statement.problem.descriptor=Nested <code>#ref</code> statement #loc
951 exception.from.catch.which.doesnt.wrap.problem.descriptor=<code>#ref</code> inside 'catch' block ignores the caught exception #loc
952 instanceof.catch.parameter.problem.descriptor='instanceof' on 'catch' parameter <code>#ref</code> #loc
953 non.final.field.of.exception.problem.descriptor=Non-final field <code>#ref</code> of exception class #loc
954 unnecessary.label.on.break.statement.problem.descriptor=Unnecessary label on <code>#ref</code> statement #loc
955 unnecessary.label.on.continue.statement.problem.descriptor=Unnecessary label on <code>#ref</code> statement #loc
956 trivial.if.problem.descriptor=<code>#ref</code> statement can be simplified #loc
957 constant.if.statement.problem.descriptor=<code>#ref</code> statement can be simplified #loc
958 unnecessary.parentheses.problem.descriptor=Parentheses around <code>#ref</code> are unnecessary #loc
959 unnecessary.local.variable.problem.descriptor=Local variable <code>#ref</code> is redundant #loc
960 unnecessary.this.problem.descriptor=<code>#ref</code> is unnecessary in this context #loc
961 unnecessary.block.statement.problem.descriptor=Braces around this statement are unnecessary #loc
962 unnecessary.continue.problem.descriptor=<code>#ref</code> is unnecessary as the last statement in a loop #loc
963 unnecessary.semicolon.problem.descriptor=Unnecessary semicolon <code>#ref</code> #loc
964 unnecessary.fully.qualified.name.problem.descriptor1=Fully qualified name <code>#ref</code> is unnecessary, and can be replaced with an import #loc
965 unnecessary.fully.qualified.name.problem.descriptor2=Fully qualified name <code>#ref</code> is unnecessary, and the qualification can be removed #loc
966 unnecessary.qualifier.for.this.problem.descriptor=Qualifier <code>#ref</code> on 'this' is unnecessary in this context #loc
967 unused.label.problem.descriptor=Unused label <code>#ref</code> #loc
968 redundant.field.initialization.problem.descriptor=Field initialization to <code>#ref</code> is redundant #loc
969 redundant.implements.problem.descriptor=Redundant interface declaration <code>#ref</code> #loc
970 extends.object.problem.descriptor=Class <code>#ref</code> explicitly extends java.lang.Object #loc
971 type.parameter.extends.object.problem.descriptor1=Type parameter <code>#ref</code> explicitly extends 'java.lang.Object' #loc
972 type.parameter.extends.object.problem.descriptor2=Wildcard type argument <code>#ref</code> explicitly extends 'java.lang.Object' #loc
973 unnecessary.super.constructor.problem.descriptor=<code>#ref</code> is unnecessary #loc
974 unnecessary.constructor.problem.descriptor=No-arg constructor <code>#ref</code> is unnecessary #loc
975 for.loop.replaceable.by.while.problem.descriptor=<code>#ref</code> loop statement may be replace by 'while' loop #loc
976 unnecessary.default.problem.descriptor=<code>#ref</code> branch is unnecessary #loc
977 unnecessary.boxing.problem.descriptor=Unnecessary boxing <code>#ref</code> #loc
978 unnecessary.unboxing.problem.descriptor=Unnecessary unboxing <code>#ref</code> #loc
979 for.can.be.foreach.problem.descriptor=<code>#ref</code> loop replaceable with 'for each'
980 while.can.be.foreach.problem.descriptor=<code>#ref</code> loop replaceable with 'for each'
981 too.broad.scope.problem.descriptor=Scope of variable <code>#ref</code> is too broad #loc
982 return.this.problem.descriptor=Return of <code>#ref</code> #loc
983 constant.on.lhs.of.comparison.problem.descriptor=<code>#ref</code>: constant on left side of comparison #loc
984 constant.on.rhs.of.comparison.problem.descriptor=<code>#ref</code>: constant on right side of comparison #loc
985 control.flow.statement.without.braces.problem.descriptor=<code>#ref</code> without braces #loc
986 missorted.modifiers.problem.descriptor=Missorted modifers <code>#ref</code> #loc
987 c.style.array.declaration.problem.descriptor=C-style array declaration <code>#ref</code> #loc
988 multiple.declaration.problem.descriptor=Multiple variables in one declaration #loc
989 multiple.typed.declaration.problem.descriptor=Variables of different types in one declaration #loc
990 serializable.inner.class.has.serial.version.uid.field.problem.descriptor=Inner class <code>#ref</code> does not define a 'serialVersionUID' field #loc
991 serializable.inner.class.with.non.serializable.outer.class.problem.descriptor=Inner class <code>#ref</code> is serializable while its outer class is not #loc
992 busy.wait.problem.descriptor=Call to <code>Thread.#ref()</code> in a loop, probably busy-waiting #loc
993 sleep.while.holding.lock.problem.descriptor=Call to <code>Thread.#ref()</code> while synchronized #loc
994 arithmetic.on.volatile.field.problem.descriptor=Arithmetic operation on volatile field <code>#ref</code> #loc
995 call.to.native.method.while.locked.problem.descriptor=Call to native method <code>#ref()</code> in a synchronized context #loc
996 object.notify.problem.descriptor=<code>#ref</code> should probably be replaced with 'notifyAll()' #loc
997 condition.signal.problem.descriptor=<code>#ref</code> should probably be replaced with 'signalAll()' #loc
998 thread.with.default.run.method.problem.descriptor=Instantiating a <code>#ref</code> with default 'run()' method #loc
999 extends.thread.problem.descriptor=Class <code>#ref</code> explicitly extends 'java.lang.Thread' #loc
1000 naked.notify.problem.descriptor=Call to <code>#ref()</code> without corresponding state change #loc
1001 unconditional.wait.problem.descriptor=Unconditional call to <code>#ref()</code> #loc
1002 system.run.finalizers.on.exit.problem.descriptor=Call to <code>System.#ref()</code> #loc
1003 thread.priority.problem.descriptor=Call to <code>Thread.#ref()</code> #loc
1004 thread.yield.problem.descriptor=Call to <code>Thread.#ref()</code> #loc
1005 thread.stop.suspend.resume.problem.descriptor=Call to <code>Thread.#ref()</code> #loc
1006 while.loop.spins.on.field.problem.descriptor=<code>#ref</code> loop spins on field #loc
1007 wait.not.in.loop.problem.descriptor=Call to <code>#ref()</code> is not made in a loop #loc
1008 await.not.in.loop.problem.descriptor=Call to <code>#ref()</code> is not made in a loop #loc
1009 wait.called.on.condition.problem.descriptor=Call to <code>#ref()</code> on Condition object #loc
1010 notify.called.on.condition.problem.descriptor=Call to <code>#ref()</code> on Condition object #loc
1011 wait.not.in.synchronized.context.problem.descriptor=Call to <code>#ref</code> while not synchronized on ''{0}'' #loc
1012 wait.while.holding.two.locks.problem.descriptor=Call to <code>#ref()</code> is made while holding two locks #loc
1013 notify.not.in.synchronized.context.problem.descriptor=Call to <code>#ref()</code> is made outside of a synchronized context #loc
1014 thread.run.problem.descriptor=Calls to <code>#ref()</code> should probably be replaced with 'start()' #loc
1015 thread.start.in.construction.problem.descriptor=Call to <code>#ref</code> during object construction #loc
1016 synchronize.on.lock.problem.descriptor=Synchronization on a ''{0}'' object is unlikely to be intentional #loc
1017 synchronized.on.literal.object.descriptor=Synchronization on {0} <code>#ref</code> which is initialized by a literal #loc
1018 synchronize.on.non.final.field.problem.descriptor=Synchronization on a non-final field <code>#ref</code> is unlikely to have useful semantics #loc
1019 synchronize.on.this.problem.descriptor=Lock operations on 'this' may have unforseen side-effects #loc
1020 nested.synchronized.statement.problem.descriptor=Nested <code>#ref</code> statement #loc
1021 empty.synchronized.statement.problem.descriptor=Empty <code>#ref</code> statement #loc
1022 non.synchronized.method.overrides.synchronized.method.problem.descriptor=Unsynchronized method <code>#ref()</code> overrides synchronized method #loc
1023 public.field.accessed.in.synchronized.context.problem.descriptor=Non-private field <code>#ref</code> accessed in synchronized context #loc
1024 field.accessed.synchronized.and.unsynchronized.problem.descriptor=Field <code>#ref</code> is accessed in both synchronized and unsynchronized contexts #loc
1025 extended.for.statement.problem.descriptor=Extended <code>#ref</code> statement #loc
1026 object.allocation.in.loop.problem.descriptor=Object allocation <code>#ref</code> in loop #loc
1027 instantiating.object.to.get.class.object.problem.descriptor=Instantiating object to get Class object #loc
1028 field.may.be.static.problem.descriptor=Field <code>#ref</code> may be 'static' #loc
1029 method.may.be.static.problem.descriptor=Method <code>#ref()</code> may be 'static' #loc
1030 class.initializer.may.be.static.problem.descriptor=Class initializer may be 'static' #loc
1031 map.replaceable.by.enum.map.problem.descriptor=<code>#ref</code> replaceable with EnumMap #loc
1032 set.replaceable.by.enum.set.problem.descriptor=<code>#ref</code> replaceable with EnumSet #loc
1033 inner.class.may.be.static.problem.descriptor=Inner class <code>#ref</code> may be 'static' #loc
1034 string.buffer.must.have.initial.capacity.problem.descriptor=<code>#ref</code> without initial capacity #loc
1035 string.buffer.replaceable.by.string.builder.problem.descriptor=StringBuffer <code>#ref</code> may be declared as StringBuilder #loc
1036 string.buffer.replaceable.by.string.problem.descriptor=Constant StringBuffer <code>#ref</code> may be declared as String #loc
1037 string.replaceable.by.string.buffer.problem.descriptor=Non-constant String <code>#ref</code> should probably be declared as StringBuilder #loc
1038 collections.must.have.initial.capacity.problem.descriptor=<code>#ref</code> without initial capacity #loc
1039 string.concatenation.in.loops.problem.descriptor=String concatenation <code>#ref</code> in loop #loc
1040 string.concatenation.inside.string.buffer.append.problem.descriptor=String concatenation as argument to <code>{0}.#ref()</code> #loc
1041 boolean.constructor.problem.descriptor=Boolean constructor call <code>#ref</code> #loc
1042 string.to.string.problem.descriptor=<code>#ref</code> is redundant #loc
1043 substring.zero.problem.descriptor=<code>#ref</code> is redundant #loc
1044 string.buffer.to.string.in.concatenation.problem.descriptor=Calls to <code>StringBuffer.#ref()</code> in concatenation #loc
1045 tail.recursion.problem.descriptor=Tail recursive call <code>#ref()</code> #loc
1046 string.equals.empty.string.problem.descriptor=<code>#ref("")</code> can be replaced with 'length()==0' #loc
1047 random.double.for.random.integer.problem.descriptor=Using <code>Random.#ref</code> to create random integer #loc
1048 manual.array.copy.problem.descriptor=Manual array copy #loc
1049 manual.array.to.collection.copy.problem.descriptor=Manual array to collection copy #loc
1050 java.lang.reflect.problem.descriptor=Use of type <code>#ref</code> from java.lang.reflect #loc
1051 call.to.simple.getter.in.class.problem.descriptor=Call to simple getter <code>#ref()</code> from within class #loc
1052 call.to.simple.setter.in.class.problem.descriptor=Call to simple setter <code>#ref()</code> from within class #loc
1053 asserts.without.messages.problem.descriptor=JUnit <code>#ref()</code> without message #loc
1054 test.case.with.constructor.problem.descriptor=Initialization logic in constructor <code>#ref()</code> instead of 'setUp()'
1055 test.case.with.constructor.problem.descriptor.initializer=Initialization logic in initializer instead of 'setUp()'
1056 misspelled.set.up.problem.descriptor=<code>#ref()</code> probably be setUp() #loc
1057 misordered.assert.equals.parameters.problem.descriptor=Parameters to <code>#ref()</code> in wrong order #loc
1058 misspelled.tear.down.problem.descriptor=<code>#ref()</code> method should probably be tearDown() #loc
1059 static.suite.problem.descriptor=JUnit <code>#ref()</code> methods not declared 'static' #loc
1060 setup.calls.super.setup.problem.descriptor=<code>#ref()</code> does not call 'super.setUp()'
1061 teardown.calls.super.teardown.problem.descriptor=<code>#ref()</code> does not call 'super.tearDown()'
1062 setup.is.public.void.no.arg.problem.descriptor=<code>#ref()</code> has incorrect signature
1063 simplifiable.junit.assertion.problem.descriptor=<code>#ref()</code> can be simplified to ''{0}'' #loc
1064 teardown.is.public.void.no.arg.problem.descriptor=<code>#ref()</code> has incorrect signature
1065 test.method.without.assertion.problem.descriptor=JUnit test method <code>#ref()</code> contains no assertions #loc
1066 test.case.with.no.test.methods.problem.descriptor=JUnit test case <code>#ref</code> has no tests
1067 test.case.in.product.code.problem.descriptor=Test case <code>#ref</code> should probably be placed in a test source tree #loc
1068 test.method.in.product.code.problem.descriptor=Test method <code>.#ref()</code> should probably be placed in a test source tree #loc
1069 unconstructable.test.case.problem.descriptor=Test case <code>#ref</code> is unusable by most test runners #loc
1070 deserializable.class.in.secure.context.problem.descriptor=Class <code>#ref</code> may be deserialized, compromising security #loc
1071 serializable.class.in.secure.context.problem.descriptor=Class <code>#ref</code> may be serialized, compromising security #loc
1072 cloneable.class.in.secure.context.problem.descriptor=Class <code>#ref</code> may be cloned, compromising security #loc
1073 non.final.clone.problem.descriptor=Non-final <code>#ref()</code> method, compromising security #loc
1074 non.static.inner.class.in.secure.context.problem.descriptor=Non-static inner class <code>#ref</code>, compromising security #loc
1075 runtime.exec.with.non.constant.string.problem.descriptor=Call to <code>Runtime.#ref()</code> with non-constant argument #loc
1076 load.library.with.non.constant.string.problem.descriptor=Call to <code>System.#ref()</code> with non-constant argument #loc
1077 jdbc.execute.with.non.constant.string.problem.descriptor=Call to <code>Statement.#ref()</code> with non-constant argument #loc
1078 jdbc.prepare.statement.with.non.constant.string.problem.descriptor=Call to <code>Connection.#ref()</code> with non-constant argument #loc
1079 custom.classloader.problem.descriptor=Custom ClassLoader class <code>#ref</code> #loc
1080 custom.security.manager.problem.descriptor=Custom SecurityManager class <code>#ref</code> #loc
1081 system.set.problem.descriptor=Call to <code>System.#ref()</code> may pose security concerns #loc
1082 class.loader.instantiation.problem.descriptor=Instantiation of <code>#ref</code> may pose security concerns #loc
1083 public.static.array.field.problem.descriptor='public static' array field <code>#ref</code>, compromising security #loc
1084 public.static.collection.field.problem.descriptor='public static' collection field <code>#ref</code>, compromising security #loc
1085 abstract.class.with.only.one.direct.inheritor.problem.descriptor=Abstract class <code>#ref</code> has only one direct inheritor #loc
1088 abstract.method.overrides.abstract.method.remove.quickfix=Remove redundant abstract method declaration
1089 class.may.be.interface.convert.quickfix=Convert class to interface
1090 class.without.constructor.create.quickfix=Create empty constructor
1091 class.without.no.arg.constructor.ignore.option=Ignore if class has default constructor
1092 extends.annotation.problem.descriptor=Class ''{0}'' explicitly extends annotation interface <code>#ref</code> #loc
1093 extends.concrete.collection.problem.descriptor=Class <code>#ref</code> explicitly extends ''{0}'' #loc
1094 inner.class.on.interface.ignore.option=Ignore inner interfaces of interfaces
1095 inner.class.on.interface.problem.descriptor=Interface ''{0}'' has inner class <code>#ref</code> #loc
1096 missing.deprecated.annotation.add.quickfix=Add @Deprecated annotation
1097 missing.override.annotation.add.quickfix=Add @Override annotation
1098 non.protected.constructor.in.abstract.class.ignore.option=Ignore for non-public classes
1099 public.constructor.in.non.public.class.problem.descriptor=Constructor is declared <code>#ref</code> in non-public class ''{0}'' #loc
1100 static.inheritance.replace.quickfix=Replace inheritance with qualified references in {0}
1101 utility.class.with.public.constructor.make.quickfix=Make {0, choice, 1#constructor|2#constructors} private
1102 utility.class.without.private.constructor.create.quickfix=Create empty private constructor
1103 utility.class.without.private.constructor.make.quickfix=Make constructor private
1104 annotation.naming.convention.problem.descriptor.short=Annotation name <code>#ref</code> is too short #loc
1105 annotation.naming.convention.problem.descriptor.long=Annotation name <code>#ref</code> is too long #loc
1106 annotation.naming.convention.problem.descriptor.regex.mismatch=Annotation name <code>#ref</code> doesn''t match regex ''{0}'' #loc
1107 class.name.convention.problem.descriptor.short=Class name <code>#ref</code> is too short #loc
1108 class.name.convention.problem.descriptor.long=Class name <code>#ref</code> is too long #loc
1109 class.name.convention.problem.descriptor.regex.mismatch=Class name <code>#ref</code> doesn''t match regex ''{0}'' #loc
1110 constant.naming.convention.problem.descriptor.short=Constant name <code>#ref</code> is too short #loc
1111 constant.naming.convention.problem.descriptor.long=Constant name <code>#ref</code> is too long #loc
1112 constant.naming.convention.problem.descriptor.regex.mismatch=Constant <code>#ref</code> doesn''t match regex ''{0}'' #loc
1113 constant.naming.convention.immutables.option=Only check static final fields with immutable types
1114 convention.pattern.option=Pattern:
1115 convention.min.length.option=Min Length:
1116 convention.max.length.option=Max Length:
1117 enumerated.class.naming.convention.problem.descriptor.short=Enumerated class name <code>#ref</code> is too short #loc
1118 enumerated.class.naming.convention.problem.descriptor.long=Enumerated class name <code>#ref</code> is too long #loc
1119 enumerated.class.naming.convention.problem.descriptor.regex.mismatch=Enumerated class name <code>#ref</code> doesn''t match regex ''{0}'' #loc
1120 enumerated.constant.naming.convention.problem.descriptor.short=Enumerated constant name <code>#ref</code> is too short #loc
1121 enumerated.constant.naming.convention.problem.descriptor.long=Enumerated constant name <code>#ref</code> is too long #loc
1122 enumerated.constant.naming.convention.problem.descriptor.regex.mismatch=Enumerated constant <code>#ref</code> doesn''t match regex ''{0}'' #loc
1123 instance.method.name.convention.problem.descriptor.short=Instance method name <code>#ref</code> is too short #loc
1124 instance.method.name.convention.problem.descriptor.long=Instance method name <code>#ref</code> is too long #loc
1125 instance.method.name.convention.problem.descriptor.regex.mismatch=Instance method name <code>#ref</code> doesn''t match regex ''{0}'' #loc
1126 instance.variable.name.convention.problem.descriptor.short=Instance variable name <code>#ref</code> is too short #loc
1127 instance.variable.name.convention.problem.descriptor.long=Instance variable name <code>#ref</code> is too long #loc
1128 instance.variable.name.convention.problem.descriptor.regex.mismatch=Instance variable <code>#ref</code> doesn''t match regex ''{0}'' #loc
1129 interface.name.convention.problem.descriptor.short=Interface name <code>#ref</code> is too short #loc
1130 interface.name.convention.problem.descriptor.long=Interface name <code>#ref</code> is too long #loc
1131 interface.name.convention.problem.descriptor.regex.mismatch=Interface name <code>#ref</code> doesn''t match regex ''{0}'' #loc
1132 j.unit.abstract.test.class.naming.convention.problem.descriptor.short=Abstract JUnit test class name <code>#ref</code> is too short #loc
1133 j.unit.abstract.test.class.naming.convention.problem.descriptor.long=Abstract JUnit test class name <code>#ref</code> is too long #loc
1134 j.unit.abstract.test.class.naming.convention.problem.descriptor.regex.mismatch=Abstract JUnit test class name <code>#ref</code> doesn''t match regex ''{0}'' #loc
1135 j.unit.test.class.naming.convention.problem.descriptor.short=JUnit test class name <code>#ref</code> is too short #loc
1136 j.unit.test.class.naming.convention.problem.descriptor.long=JUnit test class name <code>#ref</code> is too long #loc
1137 j.unit.test.class.naming.convention.problem.descriptor.regex.mismatch=JUnit test class name <code>#ref</code> doesn''t match regex ''{0}'' #loc
1138 local.variable.naming.convention.problem.descriptor.short=Local variable name <code>#ref</code> is too short #loc
1139 local.variable.naming.convention.problem.descriptor.long=Local variable name <code>#ref</code> is too long #loc
1140 local.variable.naming.convention.problem.descriptor.regex.mismatch=Local variable name <code>#ref</code> doesn''t match regex ''{0}'' #loc
1141 local.variable.naming.convention.ignore.option=Ignore for-loop parameters
1142 local.variable.naming.convention.ignore.catch.option=Ignore catch block parameters
1143 method.names.differ.only.by.case.problem.descriptor=Method names <code>#ref</code> and ''{0}'' differ only by case
1144 parameter.name.differs.from.overridden.parameter.ignore.character.option=Ignore if overridden parameter contains only one character
1145 parameter.name.differs.from.overridden.parameter.ignore.library.option=Ignore if overridden parameter is from a library
1146 parameter.name.differs.from.overridden.parameter.problem.descriptor=Parameter name <code>#ref</code> is different from parameter ''{0}'' overridden #loc
1147 parameter.naming.convention.problem.descriptor.short=Parameter name <code>#ref</code> is too short #loc
1148 parameter.naming.convention.problem.descriptor.long=Parameter name <code>#ref</code> is too long #loc
1149 parameter.naming.convention.problem.descriptor.regex.mismatch=Parameter name <code>#ref</code> doesn''t match regex ''{0}'' #loc
1150 questionable.name.column.title=Name
1151 standard.variable.names.problem.descriptor=Variable named <code>#ref</code> doesn''t have type ''{0}'' #loc
1152 standard.variable.names.problem.descriptor2=Variable named <code>#ref</code> doesn''t have type ''{0}'' or ''{1}'' #loc
1153 static.method.naming.convention.problem.descriptor.short=Static method name <code>#ref</code> is too short #loc
1154 static.method.naming.convention.problem.descriptor.long=Static method name <code>#ref</code> is too long #loc
1155 static.method.naming.convention.problem.descriptor.regex.mismatch=Static method name <code>#ref</code> doesn''t match regex ''{0}'' #loc
1156 static.variable.naming.convention.problem.descriptor.short=Static variable name <code>#ref</code> is too short #loc
1157 static.variable.naming.convention.problem.descriptor.long=Static variable name <code>#ref</code> is too long #loc
1158 static.variable.naming.convention.problem.descriptor.regex.mismatch=Static variable <code>#ref</code> doesn''t match regex ''{0}'' #loc
1159 static.variable.naming.convention.mutable.option=Check static final fields with a mutable type
1160 type.parameter.naming.convention.problem.descriptor.short=Type parameter name <code>#ref</code> is too short #loc
1161 type.parameter.naming.convention.problem.descriptor.long=Type parameter name <code>#ref</code> is too long #loc
1162 boolean.method.name.must.start.with.question.table.column.name=Boolean method name prefix
1163 conditional.expression.with.identical.branches.collapse.quickfix=Collapse conditional expression
1164 confusing.else.unwrap.quickfix=Unwrap else branch
1165 constant.conditional.expression.problem.descriptor=<code>#ref</code> can be simplified to ''{0}'' #loc
1166 constant.conditional.expression.simplify.quickfix=Simplify
1167 enum.switch.statement.which.misses.cases.problem.descriptor=<code>#ref</code> statement on enumerated type ''{0}'' misses cases #loc
1168 for.loop.replaceable.by.while.ignore.option=Ignore 'infinite' for loops without conditions
1169 for.loop.replaceable.by.while.replace.quickfix=Replace with 'while'
1170 for.loop.with.missing.component.problem.descriptor1=<code>#ref</code> statement lacks initializer #loc
1171 for.loop.with.missing.component.problem.descriptor2=<code>#ref</code> statement lacks condition #loc
1172 for.loop.with.missing.component.problem.descriptor3=<code>#ref</code> statement lacks update #loc
1173 for.loop.with.missing.component.problem.descriptor4=<code>#ref</code> statement lacks initializer and condition #loc
1174 for.loop.with.missing.component.problem.descriptor5=<code>#ref</code> statement lacks initializer and update #loc
1175 for.loop.with.missing.component.problem.descriptor6=<code>#ref</code> statement lacks condition and update #loc
1176 for.loop.with.missing.component.problem.descriptor7=<code>#ref</code> statement lacks initializer, condition and update #loc
1177 if.statement.with.identical.branches.collapse.quickfix=Collapse 'if' statement
1178 foreach.replace.quickfix=Replace with 'for each'
1179 unnecessary.boxing.remove.quickfix=Remove boxing
1180 unnecessary.unboxing.remove.quickfix=Remove unboxing
1181 misordered.assert.equals.parameters.flip.quickfix=Flip compared parameters
1182 setup.calls.super.setup.add.quickfix=add call to 'super.setUp()'
1183 simplify.j.unit.assertion.simplify.quickfix=Simplify assertion
1184 teardown.calls.super.teardown.add.quickfix=add call to 'super.tearDown()'
1185 test.method.is.public.void.no.arg.problem.descriptor1=Test method <code>#ref()</code> should probably not have parameters
1186 test.method.is.public.void.no.arg.problem.descriptor2=Test method <code>#ref()</code> is not declared 'public void'
1187 test.method.is.public.void.no.arg.problem.descriptor3=Test method <code>#ref()</code> should not be 'static'
1188 system.properties.problem.descriptor=Call to <code>Integer.#ref()</code> may pose security concerns #loc
1189 system.properties.problem.descriptor1=Call to <code>Boolean.#ref()</code> may pose security concerns #loc
1190 unsecure.random.number.generation.problem.descriptor1=For security purposes, use 'java.security.SecureRandom' instead of <code>java.lang.Math.#ref()</code> #loc
1191 unsecure.random.number.generation.problem.descriptor2=For security purposes, use 'java.security.SecureRandom' instead of <code>java.util.#ref</code> #loc
1192 unsecure.random.number.generation.problem.descriptor3=For security purposes, use 'java.security.SecureRandom' instead of <code>#ref</code> #loc
1193 serializable.has.serialization.methods.problem.descriptor=Serializable class <code>#ref</code> does not define 'readObject()' or 'writeObject()' #loc
1194 serializable.has.serialization.methods.problem.descriptor1=Serializable class <code>#ref</code> does not define 'writeObject()' #loc
1195 serializable.has.serialization.methods.problem.descriptor2=Serializable class <code>#ref</code> does not define 'readObject()' #loc
1196 serializable.has.serialization.methods.ignore.option=Ignore classes serializable due to inheritance
1197 serializable.inner.class.has.serial.version.uid.field.ignore.option=Ignore classes serializable due to inheritance
1198 serializable.inner.class.with.non.serializable.outer.class.ignore.option=Ignore classes serializable due to inheritance
1199 serializable.with.unconstructable.ancestor.problem.descriptor=<code>#ref</code> has an non-serializable ancestor ''{0}'' without a no-arg constructor #loc
1200 transient.field.in.non.serializable.class.problem.descriptor=Field ''{0}'' is marked <code>#ref</code>, in non-Serializable class #loc
1201 transient.field.in.non.serializable.class.remove.quickfix=Remove 'transient'
1202 condition.signal.replace.quickfix=Replace with signalAll()
1203 object.notify.replace.quickfix=Replace with notifyAll()
1204 safe.lock.problem.descriptor=''{0}'' should be locked in front of a try block and unlocked in the corresponding finally block #loc
1205 synchronized.method.problem.descriptor=Method ''{0}()'' declared <code>#ref</code> #loc
1206 synchronized.method.include.option=Include native methods
1207 synchronized.method.move.quickfix=Move synchronization into method
1208 thread.run.replace.quickfix=Replace with 'start()'
1209 volatile.field.problem.descriptor=Volatile field <code>#ref</code> of type ''{0}'' #loc
1210 exception.class.column.name=Exception class
1211 bad.exception.thrown.problem.descriptor=Prohibited exception ''{0}'' thrown #loc
1212 empty.catch.block.comments.option=Comments count as content
1213 empty.catch.block.ignore.option=Ignore empty catch blocks in JUnit test cases
1214 empty.catch.block.ignore.ignore.option=Ignore for catch parameters named 'ignore' or 'ignored'
1215 too.broad.catch.problem.descriptor=Catch of <code>#ref</code> is too broad, masking exception ''{0}'' #loc
1216 too.broad.catch.problem.descriptor1=Catch of <code>#ref</code> is too broad, masking exceptions ''{0}'' and ''{1}'' #loc
1217 unused.catch.parameter.ignore.catch.option=Ignore for catch blocks containing comments
1218 unused.catch.parameter.ignore.empty.option=Ignore unused catch parameters in JUnit test cases
1219 add.serialversionuidfield.quickfix=Add 'serialVersionUID' field
1220 delete.import.quickfix=Delete unnecessary import
1221 encapsulate.variable.quickfix=Encapsulate variable
1222 extract.method.quickfix=Extract method
1223 inline.call.quickfix=Inline call
1224 inline.variable.quickfix=Inline variable
1225 introduce.constant.quickfix=Introduce constant
1226 make.cloneable.quickfix=Make class Cloneable
1227 make.initialization.explicit.quickfix=Make initialization explicit
1228 make.class.serializable.quickfix=Make class Serializable
1229 move.anonymous.to.inner.quickfix=Convert to named inner class
1230 anonymous.inner.may.be.named.static.inner.class.quickfix=Convert to named static inner class
1231 move.class.quickfix=Move class
1232 normalize.declaration.quickfix=Split into multiple declarations
1233 remove.modifier.quickfix=Remove ''{0}'' modifier
1234 replace.inheritance.with.delegation.quickfix=Replace inheritance with delegation
1235 big.decimal.equals.replace.quickfix=replace with 'compareTo()==0'
1236 cast.that.loses.precision.problem.descriptor=Cast to <code>#ref</code> from ''{0}'' may result in loss of precision #loc
1237 comparison.to.nan.problem.descriptor1=Comparison to <code>#ref</code> is always false #loc
1238 comparison.to.nan.problem.descriptor2=Comparison to <code>#ref</code> is always true #loc
1239 comparison.to.nan.replace.quickfix=replace with call to 'isNaN()'
1240 confusing.floating.point.literal.change.quickfix=Change To canonical form
1241 implicit.numeric.conversion.ignore.widening.conversion.option=Ignore widening conversions
1242 implicit.numeric.conversion.ignore.char.conversion.option=Ignore conversions from and to char
1243 implicit.numeric.conversion.ignore.constant.conversion.option=Ignore conversions from constants and literals
1244 implicit.numeric.conversion.problem.descriptor=Implicit numeric conversion of <code>#ref</code> from ''{0}'' to ''{1}'' #loc
1245 implicit.numeric.conversion.convert.quickfix=Convert to ''{0}'' literal
1246 implicit.numeric.conversion.make.explicit.quickfix=Make conversion explicit
1247 long.literals.ending.with.lowercase.l.replace.quickfix=Replace 'l' with 'L'
1248 non.reproducible.math.call.replace.quickfix=Replace with StrictMath call
1249 overly.complex.arithmetic.expression.max.number.option=Maximum number of terms:
1250 expression.can.be.replaced.problem.descriptor=<code>#ref</code> can be replaced with ''{0}'' #loc
1251 method.complexity.limit.option=Method complexity limit:
1252 cyclomatic.complexity.problem.descriptor=<code>#ref</code> is overly complex (cyclomatic complexity = {0}) #loc
1253 method.coupling.limit.option=Method coupling limit:
1254 method.coupling.problem.descriptor=<code>#ref</code> is overly coupled (# referenced classes = {0}) #loc
1255 method.with.multiple.loops.problem.descriptor=<code>#ref</code> contains {0} loops #loc
1256 return.point.limit.option=&Return point limit:
1257 multiple.return.points.per.method.problem.descriptor=<code>#ref</code> has {0} return points #loc
1258 nesting.depth.limit.option=Nesting depth limit:
1259 nesting.depth.problem.descriptor=<code>#ref</code> is overly nested (maximum nesting depth = {0}) #loc
1260 non.comment.source.statements.limit.option=Non-comment source statements limit:
1261 non.comment.source.statements.problem.descriptor=<code>#ref</code> is too long (# Non-comment source statements = {0}) #loc
1262 parameters.per.method.problem.descriptor=<code>#ref()</code> has too many parameters (num parameters = {0}) #loc
1263 parameters.per.constructor.problem.descriptor=<code>#ref()</code> has too many parameters (num parameters = {0}) #loc
1264 parameter.limit.option=Parameter limit:
1265 three.negations.per.method.ignore.option=Ignore negations in equals() methods
1266 three.negations.per.method.problem.descriptor=<code>#ref</code> contains {0} negations #loc
1267 thrown.exceptions.per.method.problem.descriptor=<code>#ref</code> has too many exceptions declared (num exceptions = {0}) #loc
1268 thrown.exceptions.per.method.limit.option=Exceptions thrown limit:
1269 call.to.simple.getter.in.class.display.name.ignore.option=Ignore getter calls on other objects
1270 call.to.simple.getter.in.class.inline.quickfix=Inline call to getter
1271 call.to.simple.setter.in.class.display.name.ignore.option=Ignore setter calls on other objects
1272 call.to.simple.setter.in.class.inline.quickfix=Inline call to setter
1273 make.static.quickfix=Make static
1274 length.one.strings.in.concatenation.problem.descriptor=#ref can be replaced with ''{0}'' #loc
1275 length.one.strings.in.concatenation.replace.quickfix=Replace with character
1276 multiply.or.divide.by.power.of.two.replace.quickfix=Replace with shift
1277 string.can.be.simplified.problem.descriptor=<code>#ref</code> can be simplified to ''{0}'' #loc
1278 string.replace.quickfix=Replace with ''{0}''
1279 instantiating.object.to.get.class.object.replace.quickfix=Replace with direct class object access
1280 manual.array.copy.replace.quickfix=Replace with 'System.arrayCopy()'
1281 manual.array.to.collection.copy.replace.quickfix=Replace with 'Collection.addAll(Arrays.asList())'
1282 method.may.be.static.only.option=Only check private or final methods
1283 method.may.be.static.empty.option=Ignore empty methods
1284 random.double.for.random.integer.replace.quickfix=replace with 'nextInt()'
1285 string.buffer.replaceable.by.string.builder.replace.quickfix=Replace with StringBuilder
1286 string.buffer.to.string.in.concatenation.remove.quickfix=Remove 'toString()'
1287 string.concatenation.in.loops.only.option=only warn if string is repeatedly appended
1288 string.concatenation.inside.string.buffer.append.replace.quickfix=Replace with chained append() calls
1289 string.equals.empty.string.replace.quickfix=Replace with 'length()==0'
1290 tail.recursion.replace.quickfix=Replace tail recursion with iteration
1291 if.statement.with.too.many.branches.max.option=Maximum number of branches:
1292 if.statement.with.too.many.branches.problem.descriptor='<code>#ref</code>' has too many branches ({0}) #loc
1293 negated.conditional.ignore.option=Ignore '!= null' comparisons
1294 negated.conditional.invert.quickfix=Invert condition
1295 negated.if.else.ignore.option=Ignore '!= null' comparisons
1296 negated.if.else.invert.quickfix=Invert If Condition
1297 overly.complex.boolean.expression.overly.option=Maximum number of terms:
1298 pointless.boolean.expression.ignore.option=Ignore named constant in determinining pointless expressions
1299 simplifiable.conditional.expression.problem.descriptor=<code>#ref</code> can be simplified to ''{0}'' #loc
1300 simplifiable.if.statement.problem.descriptor=<code>#ref</code> statement can be replaced with ''{0}'' #loc
1301 switch.statement.density.min.option=Minimum density of branches: %
1302 switch.statement.density.problem.descriptor='<code>#ref</code>' has too low of a branch density ({0}%) #loc
1303 switch.statement.with.too.few.branches.min.option=Minimum number of branches:
1304 switch.statement.with.too.few.branches.problem.descriptor='<code>#ref</code>' has too few branches ({0}), and should probably be replaced with an ''if'' statement #loc
1305 switch.statement.without.default.ignore.option=Ignore if all cases of an enumerated type are covered
1306 unnecessary.label.remove.quickfix=Remove label
1307 unnecessary.return.problem.descriptor=<code>#ref</code> is unnecessary as the last statement in a constructor #loc
1308 unnecessary.return.problem.descriptor1=<code>#ref</code> is unnecessary as the last statement in a method returning 'void' #loc
1309 unused.label.remove.quickfix=Remove unused label
1310 unnecessarily.qualified.static.usage.problem.descriptor=Unnecessarily qualified static method call <code>#ref()</code> #loc
1311 unnecessarily.qualified.static.usage.problem.descriptor1=Unnecessarily qualified static access <code>#ref</code> #loc
1312 unnecessarily.qualified.static.usage.ignore.field.option=Ignore unnecessarily qualified field accesses
1313 unnecessarily.qualified.static.usage.ignore.method.option=Ignore unnecessarily qualified method calls
1314 unnecessary.interface.modifier.problem.descriptor=Modifier <code>#ref</code> is redundant for interfaces #loc
1315 unnecessary.interface.modifier.problem.descriptor1=Modifier <code>#ref</code> is redundant for inner interfaces of interfaces #loc
1316 unnecessary.interface.modifier.problem.descriptor2=Modifier <code>#ref</code> is redundant for interface methods #loc
1317 unnecessary.interface.modifier.problem.descriptor3=Modifier <code>#ref</code> is redundant for inner classes of interfaces #loc
1318 unnecessary.interface.modifier.problem.descriptor4=Modifier <code>#ref</code> is redundant for interface fields #loc
1319 smth.unnecessary.remove.quickfix=Remove unnecessary ''{0}''
1320 unqualified.static.usage.problem.descriptor=Unqualified static method call <code>#ref()</code> #loc
1321 unqualified.static.usage.problem.descriptor1=Unqualified static field access <code>#ref</code> #loc
1322 unqualified.static.usage.ignore.field.option=Ignore unqualified field accesses
1323 unqualified.static.usage.ignore.method.option=Ignore unqualified method calls
1324 unqualified.static.usage.qualify.field.quickfix=Qualify static field access
1325 unqualified.static.usage.qualify.method.quickfix=Qualify static method call
1326 too.broad.scope.allow.option=<html>Allow initializer of variables to construct objects. Potentially unsafe: quick fix may modify semantics if the constructor has non-local side-effects.</html>
1327 too.broad.scope.only.blocks.option=Only report variables that can be moved into inner blocks
1328 too.broad.scope.narrow.quickfix=Narrow scope of ''{0}''
1329 press.escape.to.remove.highlighting.message=Press Escape to remove the highlighting
1330 unnecessary.enum.modifier.problem.descriptor=Modifier <code>#ref</code> is redundant for enum constructors #loc
1331 unnecessary.enum.modifier.problem.descriptor1=Modifier <code>#ref</code> is redundant for inner enums #loc
1332 literal.as.arg.to.string.equals.problem.descriptor=#ref is argument of ''{0}()'', instead of its target.
1333 literal.as.arg.to.string.equals.flip.quickfix=Flip 'equals()'
1334 unnecessary.final.on.local.variable.problem.descriptor=Unnecessary <code>#ref</code> for variable ''{0}'' #loc
1335 unnecessary.final.on.parameter.problem.descriptor=Unnecessary <code>#ref</code> for parameter ''{0}'' #loc
1336 c.style.array.declaration.replace.quickfix=Replace with Java-style array declaration
1337 chained.method.call.ignore.option=Ignore chained method calls in field initializers
1338 introduce.variable.quickfix=Introduce variable
1339 flip.comparision.quickfix=Flip comparison
1340 control.flow.statement.without.braces.add.quickfix=Add braces
1341 extends.object.remove.quickfix=Remove redundant 'extends Object'
1342 implicit.call.to.super.ignore.option=Ignore for direct subclasses of java.lang.Object
1343 implicit.call.to.super.make.explicit.quickfix=Make construction of super() explicit
1344 missorted.modifiers.require.option=Require annotations to be sorted before keywords
1345 missorted.modifiers.sort.quickfix=Sort modifers
1346 nested.method.call.ignore.option=Ignore nested method calls in field initializers
1347 redundant.field.initialization.remove.quickfix=Remove initializer
1348 redundant.implements.remove.quickfix=Remove redundant interface declaration
1349 unnecessary.constructor.remove.quickfix=Remove redundant constructor
1350 unnecessary.fully.qualified.name.ignore.option=Ignore fully qualified names in javadoc
1351 unnecessary.fully.qualified.name.replace.quickfix=Replace with import
1352 unnecessary.fully.qualified.name.remove.quickfix=Remove qualification
1353 unnecessary.fully.qualified.name.status.bar.escape.highlighting.message1=1 fully qualified name replaced with import (press Escape to remove highlighting)
1354 unnecessary.fully.qualified.name.status.bar.escape.highlighting.message2={0} fully qualified names replaced with import (press Escape to remove highlighting)
1355 unnecessary.parentheses.remove.quickfix=Remove unnecessary parentheses
1356 unnecessary.qualifier.for.this.remove.quickfix=Remove unnecessary qualifier
1357 unnecessary.semicolon.remove.quickfix=Remove unnecessary semicolon
1358 unnecessary.super.constructor.remove.quickfix=Remove unnecessary super()
1359 unnecessary.this.remove.quickfix=Remove unnecessary 'this.'
1360 overly.strong.type.cast.problem.descriptor=Cast to <code>#ref</code> can be weakened to ''{0}'' #loc
1361 field.count.inspection.include.constant.fields.in.count.checkbox=Include constant fields in count
1362 field.count.inspection.static.final.fields.count.as.constant.checkbox=Static final fields count as constant
1363 make.method.final.fix.name=Make method ''{0}()'' final
1364 make.class.final.fix.name=Make class ''{0}'' final
1365 non.boolean.method.name.must.not.start.with.question.display.name=Non-boolean method name must not start with question word
1366 non.boolean.method.name.must.not.start.with.question.problem.descriptor=Non-boolean method name <code>#ref</code> starts with a question word #loc
1367 boolean.aonstructor.simplify.quickfix=Simplify
1368 unnecessary.temporary.on.conversion.from.string.problem.descriptor=<code>#ref</code> #loc can be simplified to ''{0}''
1369 # 0 - replacement exception
1370 unnecessary.temporary.on.conversion.from.string.fix.name=Replace with ''{0}''
1371 only.report.qualified.static.usages.option=Only report qualified static usages from a static context
1372 unqualified,static.usage.only.report.static.usages.option=Only report static usages from a non-static context
1373 create.documentation.count.inspections.message={0} Inspections
1374 create.documentation.count.quick.fixes.message={0} Quick Fixes
1375 create.documentation.couldn.t.instantiate.class=Couldn''t instantiate {0}
1376 create.documentation.couldnt.access.class=Couldn''t access {0}
1377 create.documentation.couldnt.cast.class=Couldn''t cast {0}
1378 create.documentation.inspections.enabled.by.default.message=Inspections enabled by default:
1379 create.documentation.couldnt.find.documentation.file.error.message=Couldn''t find documentation file: {0}
1380 create.documentation.unused.documentation.file.error.message=Unused documentation file: {0}
1381 assignment.to.catch.block.parameter.problem.descriptor=Assignment to catch block parameter <code>#ref</code> #loc
1382 assignment.to.method.parameter.problem.descriptor=Assignment to method parameter <code>#ref</code> #loc
1383 value.of.post.increment.problem.descriptor=Value of post-increment expression <code>#ref</code> is used #loc
1384 value.of.post.decrement.problem.descriptor=Value of post-decrement expression <code>#ref</code> is used #loc
1385 value.of.pre.increment.problem.descriptor=Value of pre-increment expression <code>#ref</code> is used #loc
1386 value.of.pre.decrement.problem.descriptor=Value of pre-decrement expression <code>#ref</code> is used #loc
1387 assignment.replaceable.with.operator.assignment.problem.descriptor=<code>#ref</code> could be simplified to ''{0}'' #loc
1388 assignment.replaceable.with.operator.assignment.ignore.conditional.operators.option=Ignore conditional operators
1389 assignment.replaceable.with.operator.assignment.ignore.obscure.operators.option=Ignore the obscure ^ and % operators
1390 assignment.replaceable.with.operator.replace.quickfix=Replace '=' with ''{0}{1}''
1392 button.delete=Delete
1394 object.equality.ignore.between.objects.of.a.type.with.only.private.constructors.option=Ignore == between objects of a type with only private constructors
1395 redundant.method.override.display.name=Method is identical to its super method
1396 redundant.method.override.problem.descriptor=Method <code>#ref()</code> is identical to its super method
1397 redundant.method.override.quickfix=Remove redundant method
1398 refused.bequest.problem.descriptor=Method <code>#ref()</code> ignores defined method in superclass #loc
1399 reqused.bequest.ignore.empty.super.methods.option=Ignore empty super methods (degrades performance of this inspection)
1400 ovetly.complex.boolean.expression.ignore.pure.conjunctions.and.disjunctions.option=Ignore pure conjunctions and disjunctions
1401 pointless.indexof.comparison.display.name=Pointless 'indexOf()' comparison
1402 pointless.indexof.comparison.always.true.problem.descriptor=<code>#ref</code> is always true #loc
1403 pointless.indexof.comparison.always.false.problem.descriptor=<code>#ref</code> is always false
1404 reuse.of.local.variable.problem.descriptor=Reuse of local variable <code>#ref</code> #loc
1405 button.remove=&Remove
1406 bad.exception.declared.ignore.exceptions.declared.in.junit.test.cases.option=&Ignore exceptions declared in JUnit test cases
1407 single.character.startswith.display.name=Single character 'startsWith()' or 'endsWith()'
1408 single.character.startswith.problem.descriptor=Single character <code>#ref()</code> could be replaced with 'charAt()' expression #loc
1409 indexof.replaceable.by.contains.display.name='indexOf()' expression is replaceable with 'contains()'
1410 indexof.replaceable.by.contains.problem.descriptor=<code>#ref</code> can be replaced with ''{0}'' #loc
1411 replace.indexof.with.contains.quickfix=Replace 'indexOf()' with 'contains()'
1412 overloaded.methods.with.same.number.parameters.problem.descriptor=Multiple methods named <code>#ref</code> with the same number of parameters
1413 overloaded.vararg.method.problem.descriptor=Overloaded variable argument method <code>#ref()</code>
1414 overloaded.vararg.constructor.problem.descriptor=Overloaded variable argument constructor <code>#ref</code>
1415 cached.number.constructor.call.display.name=Number constructor call with primitive argument
1416 cached.number.constructor.call.problem.descriptor=Number constructor call with primitive argument <code>#ref</code> #loc
1417 cached.number.constructor.call.quickfix=Replace with ''{0}.valueOf()'' call
1418 chained.equality.comparisons.problem.descriptor=Chained equality comparison <code>#ref</code> #loc
1419 confusing.octal.escape.sequence.problem.descriptor=String <code>#ref</code> contains potentially confusing octal escape sequence #loc
1420 field.accessed.synchronized.and.unsynchronized.option=Simple getters and setters are considered field accesses too
1421 method.overrides.package.local.method.display.name=Method overrides package local method of superclass located in other package
1422 method.overrides.package.local.method.problem.descriptor=Method <code>#ref()</code> overrides a package local method of a superclass located in another package #loc
1423 suspicious.to.array.call.display.name=Suspicious 'Collections.toArray()' call
1424 suspicious.to.array.call.problem.descriptor=Array of type ''{0}[]'' expected
1425 suspicious.system.arraycopy.display.name=Suspicious 'System.arraycopy()' call
1426 suspicious.system.arraycopy.problem.descriptor1=Parameter 'srcPos' may not be negative
1427 suspicious.system.arraycopy.problem.descriptor2=Parameter 'destPos' may not be negative
1428 suspicious.system.arraycopy.problem.descriptor3=Parameter 'length' may not be negative
1429 suspicious.system.arraycopy.problem.descriptor4=<code>#ref</code> is not of an array type
1430 suspicious.system.arraycopy.problem.descriptor5=<code>#ref</code> is not of an array type
1431 suspicious.system.arraycopy.problem.descriptor6=Source parameter type ''{0}'' is not assignable to destination parameter <code>#ref</code> of type ''{1}''
1432 raw.use.of.parameterized.type.ignore.new.objects.option=Ignore construction of new objects
1433 raw.use.of.parameterized.type.ignore.type.casts.option=Ignore type casts
1434 method.only.used.from.inner.class.display.name=Private method only used from inner class
1435 method.only.used.from.inner.class.problem.descriptor.anonymous.extending=Method <code>#ref()</code>#loc is only used from an anonymous class extending ''{0}''
1436 method.only.used.from.inner.class.problem.descriptor.anonymous.implementing=Method <code>#ref()</code>#loc is only used from an anonymous class implementing ''{0}''
1437 method.only.used.from.inner.class.problem.descriptor=Method <code>#ref()</code>#loc is only used from inner class ''{0}''
1438 method.only.used.from.inner.class.ignore.option=Ignore methods accessed from an anonymous class
1439 format.decode.error.requires.both.0.and.1=requires both {0} and {1}
1440 format.decode.any=any
1441 format.decode.date.time=Date/Time
1442 format.decode.char=char
1443 format.decode.integer.type=integer type
1444 format.decode.floating.point=floating point
1445 single.character.startswith.quickfix=Replace with 'charAt()'
1446 interface.never.implemented.option=Ignore interfaces which only declare constants
1447 size.replaceable.by.isempty.display.name='size() == 0' replaceable with 'isEmpty()'
1448 size.replaceable.by.isempty.problem.descriptor=<code>#ref</code> can be replaced with ''{0}''
1449 size.replaceable.by.isempty.quickfix=Replace with 'isEmpty()'
1450 size.replaceable.by.isempty.negation.ignore.option=Ignore expressions which would be replaced with '!isEmpty()'
1451 loop.condition.not.updated.inside.loop.display.name=Loop variable not updated inside loop
1452 loop.condition.not.updated.inside.loop.problem.descriptor='#ref' is not updated inside loop
1453 utility.class.without.private.constructor.option=Ignore classes with only a main method
1454 super.class.logger.option=Ignore classes with an accessible logger declared in a super class
1455 static.method.only.used.in.one.class.display.name=Static method only used from one other class
1456 static.method.only.used.in.one.class.problem.descriptor=Static method <code>#ref()</code> is only used from class ''{0}''
1457 static.method.only.used.in.one.class.problem.descriptor.anonymous.implementing=Static method <code>#ref()</code> is only used from an anonymous class implementing ''{0}''
1458 static.method.only.used.in.one.class.problem.descriptor.anonymous.extending=Static method <code>#ref()</code> is only used from an anonymous class extending ''{0}''
1459 static.method.only.used.in.one.class.quickfix=Move method
1460 unary.plus.display.name=Unary plus
1461 unary.plus.problem.descriptor=Unary <code>#ref</code> operator #loc
1462 await.without.corresponding.signal.display.name='await()' without corresponding 'signal()'
1463 await.without.corresponding.signal.problem.descriptor=Call to <code>#ref</code> without corresponding <code>signal()</code> or <code>signalAll()</code> #loc
1464 signal.without.corresponding.await.display.name='signal()' without corresponding 'await()'
1465 signal.without.corresponding.await.problem.descriptor=Call to <code>#ref</code> without corresponding <code>await()</code> #loc
1466 wait.without.corresponding.notify.display.name='wait()' without corresponding 'notify()'
1467 wait.without.corresponding.notify.problem.descriptor=Call to <code>#ref</code> without corresponding <code>notify()</code> or <code>notifyAll()</code> #loc
1468 notify.without.corresponding.wait.display.name='notify()' without corresponding 'wait()'
1469 notify.without.corresponding.wait.problem.descriptor=Call to <code>#ref</code> without corresponding <code>wait()</code> #loc
1470 integer.multiplication.implicit.cast.to.long.display.name=Integer multiplication or shift implicitly cast to long
1471 integer.multiplication.implicit.cast.to.long.problem.descriptor=#ref: integer multiplication or shift implicitly cast to long #loc
1472 wait.or.await.without.timeout.display.name='wait()' or 'await()' without timeout
1473 wait.or.await.without.timeout.problem.descriptor=<code>#ref</code> without timeout #loc
1474 boolean.field.always.negated.display.name=Boolean field always negated on read
1475 boolean.field.always.negated.problem.descriptor=Boolean field {0} is always negated
1476 test.global.display.name=Test Global Inspection
1477 method.return.always.ignored.display.name=Return value of method is always ignored
1478 method.return.always.ignored.problem.descriptor=Return value of method {0} is always ignored
1479 method.return.always.constant.display.name=Method returns per-class constant
1480 method.return.always.constant.problem.descriptor=Method <code>#ref()</code> returns a per-class constant
1481 class.with.too.many.dependencies.display.name=Class with too many dependencies
1482 class.with.too.many.dependencies.problem.descriptor=Class {0} has too many dependencies ({1} > {2})
1483 class.with.too.many.transitive.dependencies.display.name=Class with too many transitive dependencies
1484 class.with.too.many.transitive.dependencies.problem.descriptor=Class {0} has too many transitive dependencies ({1} > {2})
1485 class.with.too.many.dependents.display.name=Class with too many dependents
1486 class.with.too.many.dependents.problem.descriptor=Class {0} has too many dependents ({1} > {2})
1487 class.with.too.many.transitive.dependents.display.name=Class with too many transitive dependents
1488 class.with.too.many.transitive.dependents.problem.descriptor=Class {0} has too many transitive dependencies ({1} > {2})
1489 class.with.too.many.dependencies.max.option=Maximum number of dependencies
1490 class.with.too.many.dependents.max.option=Maximum number of dependents
1491 class.with.too.many.transitive.dependencies.max.option=Maximum number of transitive dependencies
1492 class.with.too.many.transitive.dependents.max.option=Maximum number of transitive dependents
1493 cyclic.class.dependency.display.name=Cyclic class dependency
1494 cyclic.class.dependency.problem.descriptor=Class {0} is cyclically dependent on {1} other classes
1495 cyclic.package.dependency.display.name=Cyclic package dependency
1496 cyclic.package.dependency.problem.descriptor=Package {0} is cyclically dependent on {1} other packages
1497 class.unconnected.to.package.display.name=Class independent of its package
1498 class.unconnected.to.package.problem.descriptor=Class {0} has no dependencies or dependents in it's package
1499 package.with.too.many.classes.display.name=Package with too many classes
1500 package.with.too.many.classes.problem.descriptor=Package {0} contains too many classes ({1} > {2})
1501 package.with.too.many.classes.max.option=Maximum number of classes
1502 package.with.too.few.classes.display.name=Package with too few classes
1503 package.with.too.few.classes.problem.descriptor=Package {0} contains too few classes ({1} < {2})
1504 package.with.too.few.classes.min.option=Minimum number of classes
1505 module.with.too.many.classes.display.name=Module with too many classes
1506 module.with.too.many.classes.problem.descriptor=Module {0} contains too many classes ({1} > {2})
1507 module.with.too.many.classes.max.option=Maximum number of classes
1508 module.with.too.few.classes.display.name=Module with too few classes
1509 module.with.too.few.classes.problem.descriptor=Module {0} contains too few classes ({1} < {2})
1510 module.with.too.few.classes.min.option=Minimum number of classes
1511 package.in.multiple.modules.display.name=Package with classes in multiple modules
1512 package.in.multiple.modules.problem.descriptor=Package {0} has classes in multiple modules
1513 disjoint.package.display.name=Package with disjoint dependency graph
1514 disjoint.package.problem.descriptor=Package {0} can be decomposed into {1} independent packages
1515 package.naming.convention.problem.descriptor.short=Package name <code>{0}</code> is too short
1516 package.naming.convention.problem.descriptor.long=Package name <code>{0}</code> is too long
1517 package.naming.convention.problem.descriptor.regex.mismatch=Package name <code>{0}</code> doesn''t match regex ''{1}''
1518 cyclic.class.initialization.display.name=Cyclic class initialization dependency
1519 cyclic.class.initialization.problem.descriptor=Initialization of class {0} is cyclically dependent on {1} other classes
1520 before.or.after.is.public.void.no.arg.display.name=Malformed @Before or @After method
1521 before.or.after.is.public.void.no.arg.problem.descriptor=<code>#ref()</code> has incorrect signature for a @Before or @After method
1522 before.class.or.after.class.is.public.static.void.no.arg.display.name=Malformed @BeforeClass or @AfterClass method
1523 before.class.or.after.class.is.public.static.void.no.arg.problem.descriptor=<code>#ref()</code> has incorrect signature for a @BeforeClass or @AfterClass method
1524 string.constructor.display.name=Redundant String constructor call
1525 string.constructor.problem.descriptor=<code>#ref</code> is redundant #loc
1526 string.constructor.replace.arg.quickfix=Replace with arg
1527 string.constructor.replace.empty.quickfix=Replace with empty string
1528 string.constructor.substring.parameter.option=Ignore string constructor calls with '.substring()' call parameter
1529 design.for.extension.display.name=Design for extension
1530 design.for.extension.problem.descriptor=Method <code>#ref()</code> may be overridden and its functionality ignored #loc
1531 bad.oddness.display.name=Suspicious test for oddness
1532 bad.oddness.problem.descriptor=Test for oddness <code>#ref</code> will fail on negative values #loc
1533 comparator.not.serializable.display.name=Comparator class not declared Serializable
1534 comparator.not.serializable.problem.descriptor=Comparator class <code>#ref</code> is not declared as Serializable #loc
1535 non.serializable.field.in.serializable.class.display.name=Non-serializable field in a Serializable class
1536 non.serializable.field.in.serializable.class.problem.descriptor=Non-serializable field '#ref' in a Serializable class #loc
1537 non.serializable.object.passed.to.object.stream.display.name=Non-serializable object passed to ObjectOutputStream
1538 non.serializable.object.passed.to.object.stream.problem.descriptor=Non-serializable object passed to ObjectOutputStream #loc
1539 non.serializable.object.bound.to.http.session.display.name=Non-serializable object bound to HttpSession
1540 non.serializable.object.bound.to.http.session.problem.descriptor=Non-serializable object bound to HttpSession #loc
1541 reflection.for.unavailable.annotation.display.name=Reflective access to a source-only annotation
1542 reflection.for.unavailable.annotation.problem.descriptor=Annotation '#ref' is not retained for reflective access #loc
1543 access.to.static.field.locked.on.instance.display.name=Access to static field locked on instance data
1544 access.to.static.field.locked.on.instance.problem.descriptor=Access to static field <code>#ref</code> locked on instance data #loc
1545 make.method.ctr.quickfix=Make method constructor
1546 annotate.with.nonnls.quickfix=Annotate ''{0}'' with @NonNls
1547 annotate.method.with.nonnls.quickfix=Annotate ''{0}()'' with @NonNls
1548 replace.all.dot.display.name=Call to String.replaceAll(".", ...)
1549 replace.all.dot.problem.descriptor=Call to <code>String.#ref(".", ...)</code>
1550 constant.string.intern.display.name=Call to 'intern()' on String constant
1551 constant.string.intern.problem.descriptor=<code>.#ref()</code> on compile-time constant is unnecessary
1552 constant.string.intern.quickfix=Remove '.intern()'
1553 class.extends.utility.class.display.name=Class extends utility class
1554 class.extends.utility.class.problem.descriptor=class <code>#ref</code> extends utility class ''{0}''
1555 public.constructor.in.non.public.class.quickfix=Make constructor ''{0}''
1556 assignment.to.method.parameter.ignore.transformation.option=Ignore if assignment is a transformation of the original parameter
1557 type.parameter.extends.final.class.display.name=Type parameter extends final class
1558 type.parameter.extends.final.class.problem.descriptor1=Type parameter <code>#ref</code> extends final class ''{0}''
1559 type.parameter.extends.final.class.problem.descriptor2=Wildcard type argument <code>#ref</code> extends final class ''{0}''
1560 type.parameter.extends.final.class.quickfix=Replace type parameter with actual class
1561 non.serializable.field.in.serializable.ignore.option=Ignore classes serializable due to inheritance
1562 double.negation.display.name=Double negation
1563 double.negation.problem.descriptor=Double negation in <code>#ref</code>
1564 double.negation.quickfix=Remove double negation
1565 exception.from.catch.which.doesntwrap.ignore.option=Ignore if result of exception method call is used
1566 comparable.implemented.but.equals.not.overridden.display.name=Comparable implemented but 'equals()' not overridden
1567 comparable.implemented.but.equals.not.overridden.problem.descriptor=Class <code>#ref</code> implements 'java.lang.Comparable' but does not override 'equals()'
1568 unqualified.field.access.display.name=Instance field access not qualified with 'this'
1569 unqualified.field.access.problem.descriptor=instance field access <code>#ref</code> is not qualified with 'this' #loc
1570 add.this.qualifier.quickfix=Add 'this' qualifier
1571 feature.envy.ignore.test.cases.option=Ignore feature envy in JUnit test methods
1572 while.loop.spins.on.field.ignore.non.empty.loops.option=Only warn if the loop is empty
1573 unnecessary.final.on.parameter.only.interface.option=Only warn on final parameters of abstract or interface methods
1574 method.may.be.synchronized.problem.descriptor=Method <code>#ref()</code> with synchronized block could be synchronized method
1575 method.may.be.synchronized.display.name=Method with synchronized block could be synchronized method
1576 method.may.be.synchronized.quickfix=Make method synchronized and remove synchronized block
1577 fallthru.in.switch.statement.quickfix=Add 'break'
1578 law.of.demeter.display.name=Method call violates Law of Demeter
1579 law.of.demeter.problem.descriptor=<code>#ref()</code> call violates Law of Demeter
1580 law.of.demeter.ignore.library.calls.option=Ignore calls on library methods
1581 assertequals.between.inconvertible.types.display.name='assertEquals()' between objects of inconvertible types
1582 assertequals.between.inconvertible.types.problem.descriptor=<code>#ref()</code> between objects of inconvertible types ''{0}'' and ''{1}'' #loc
1583 enumeration.can.be.iteration.display.name=Enumeration can be iteration
1584 enumeration.can.be.iteration.problem.descriptor=<code>#ref()</code> can be replaced with ''{0}'' construct
1585 enumeration.can.be.iteration.quickfix=Replace with Iterator construct
1586 missing.override.annotation.jdk6.option=Use JDK6 @Override rules
1587 equals.hashcode.called.on.url.display.name='equals()' or 'hashCode()' called on java.net.URL object
1588 equals.hashcode.called.on.url.problem.descriptor=Call to <code>#ref()</code> on URL object
1589 collection.contains.url.problem.decriptor={0} <code>#ref</code> may contain URL objects
1590 collection.contains.url.display.name=Map or Set may contain java.net.URL objects
1591 implicit.array.to.string.problem.descriptor=Implicit call to method 'toString()' on array <code>#ref</code>
1592 implicit.array.to.string.method.call.problem.descriptor=Implicit call to method 'toString()' on array returned by <code>#ref</code> call
1593 implicit.array.to.string.display.name=Implicit call to array '.toString()'
1594 implicit.array.to.string.quickfix=Wrap with ''{0}'' expression
1595 suspicious.indent.after.control.statement.problem.descriptor=<code>#ref</code> statement has suspicous indentation
1596 suspicious.indent.after.control.statement.display.name=Suspicious indentation after control statement without braces
1597 unpredictable.big.decimal.constructor.call.display.name=Unpredictable BigDecimal constructor call
1598 unpredictable.big.decimal.constructor.call.problem.descriptor=Unpredictable <code>new #ref()</code> call #loc
1599 unpredictable.big.decimal.constructor.call.ignore.references.option=Ignore constructor calls with variable or method call arguments
1600 unpredictable.big.decimal.constructor.call.ignore.complex.literals.option=Ignore constructor calls with multiple literals (e.g. 0.1 + 0.2)
1601 unpredictable.big.decimal.constructor.call.quickfix=Replace with ''new BigDecimal("{0}")''
1602 unnecessary.unary.minus.display.name=Unnecessary unary minus
1603 unnecessary.unary.minus.problem.descriptor=Unnecessary unary minus
1604 unnecessary.unary.minus.quickfix=Remove unary minus and invert parent operation sign
1605 make.field.final.quickfix=Make ''{0}'' final
1606 increment.decrement.used.as.expression.quickfix=Extract ''{0}'' to separate statement
1607 ignore.classes.in.hierarchy.column.name=Ignore subclasses of
1608 overly.strong.type.cast.ignore.in.matching.instanceof.option=Ignore casts with a matching instanceof expression
1609 return.of.collection.field.quickfix=Replace with ''{0}''
1610 access.to.non.thread.safe.static.field.from.instance.display.name=Access to non thread-safe static field from instance
1611 access.to.non.thread.safe.static.field.from.instance.field.problem.descriptor=Access to static ''{0}'' field <code>#ref</code> from instance field initializer
1612 access.to.non.thread.safe.static.field.from.instance.method.problem.descriptor=Access to static ''{0}'' field <code>#ref</code> from instance method
1613 non.thread.safe.types.column.name=Non Thread-safe Types
1614 transient.field.not.initialized.display.name=Transient field is not initialized on deserialization
1615 transient.field.not.initialized.problem.descriptor=Transient field <code>#ref</code> not initialized on deserialization
1616 call.to.string.concat.can.be.replaced.by.operator.display.name=Call to 'String.concat()' can be replaced with '+'
1617 call.to.string.concat.can.be.replaced.by.operator.problem.descriptor=Call to <code>#ref()</code> can be replaced with '+' expression
1618 call.to.string.concat.can.be.replaced.by.operator.quickfix=Replace 'concat()' call with '+'
1619 new.string.buffer.with.char.argument.display.name=StringBuffer constructor call with 'char' argument
1620 new.string.buffer.with.char.argument.problem.descriptor=<code>new #ref()</code> with argument of type 'char'
1621 new.string.buffer.with.char.argument.quickfix=Replace char argument with String literal
1622 comparator.method.parameter.not.used.display.name='Comparator.compare()' method does not use parameter
1623 comparator.method.parameter.not.used.problem.descriptor='compare()' parameter <code>#ref</code> is not used
1624 to.array.call.with.zero.length.array.argument.display.name=Call to 'Collection.toArray()' with zero-length array argument
1625 to.array.call.with.zero.length.array.argument.problem.descriptor=Call to <code>#ref()</code> with zero-length array argument ''{0}''
1626 to.array.call.with.zero.length.array.argument.quickfix=Replace with ''{0}''
1627 throwable.instance.never.thrown.display.name=Throwable instance not thrown
1628 throwable.instance.never.thrown.runtime.exception.problem.descriptor=Runtime exception instance <code>#ref</code> is not thrown
1629 throwable.instance.never.thrown.checked.exception.problem.descriptor=Checked exception instance <code>#ref</code> is not thrown
1630 throwable.instance.never.thrown.error.problem.descriptor=Error instance <code>#ref</code> is not thrown
1631 throwable.instance.never.thrown.problem.descriptor=Throwable instance <code>#ref</code> is not thrown
1632 type.may.be.weakened.display.name=Type may be weakened
1633 type.may.be.weakened.problem.descriptor=Type of variable <code>#ref</code> may be weakened to {0}
1634 type.may.be.weakened.method.problem.descriptor=Return type of method <code>#ref</code> may be weakened to {0}
1635 type.may.be.weakened.parameter.problem.descriptor=Type of parameter <code>#ref</code> may be weakened to {0}
1636 type.may.be.weakened.field.problem.descriptor=Type of field <code>#ref</code> may be weakened to {0}
1637 type.may.be.weakened.quickfix=Weaken type to ''{0}''
1638 type.may.be.weakened.ignore.option=Use &righthand type as weakest type in assignments
1639 type.may.be.weakened.collection.method.option=Use ¶meterized type of collection for method call arguments
1640 type.may.be.weakened.do.not.weaken.to.object.option=Do not &weaken to java.lang.Object
1641 ignore.guard.clauses=Ignore &guard clauses
1642 ignore.for.equals.methods=Ignore for &equals() methods
1643 caught.exception.immediately.rethrown.display.name=Caught exception is immediately rethrown
1644 caught.exception.immediately.rethrown.problem.descriptor=Caught exception <code>#ref</code> is immediately rethrown
1645 delete.catch.section.quickfix=Delete catch section
1646 remove.try.catch.quickfix=Remove try-catch statement
1647 loop.with.implicit.termination.condition.display.name=Loop with implicit termination condition
1648 loop.with.implicit.termination.condition.dowhile.problem.descriptor=<code>#ref-while</code> loop with implicit termination condition
1649 loop.with.implicit.termination.condition.problem.descriptor=<code>#ref</code> loop with implicit termination condition
1650 loop.with.implicit.termination.condition.quickfix=Make condition explicit
1651 ignore.iterator.loop.variables=Ignore java.util.Iterator loop variables
1652 rename.catch.parameter.to.ignored=Rename catch parameter to 'ignored'
1653 unnecessary.super.qualifier.display.name=Unnecessary 'super' qualifier
1654 unnecessary.super.qualifier.problem.descriptor=Qualifier <code>#ref</code> is unnecessary in this context #loc
1655 unnecessary.super.qualifier.quickfix=Remove unnecessary 'super.'
1656 collections.field.access.replaceable.by.method.call.display.name=Collections.EMPTY_* field access replaceable with Collections.empty*() method call
1657 collections.field.access.replaceable.by.method.call.problem.descriptor=<code>#ref</code> replaceable with Collections.{0} #loc
1658 collections.field.access.replaceable.by.method.call.quickfix=Replace with ''{0}''
1659 synchronization.on.local.variable.or.method.parameter.display.name=Synchronization on local variable or method parameter
1660 synchronization.on.local.variable.problem.descriptor=Synchronization on local variable <code>#ref</code>
1661 synchronization.on.method.parameter.problem.descriptor=Synchronization on method parameter <code>#ref</code> #loc
1662 too.broad.catch.quickfix=Add catch clause for ''{0}''
1663 too.broad.catch.option=&Only warn on too broad catching of RuntimeException, Exception or Throwable
1664 unnecessary.call.to.string.valueof.display.name=Unnecessary call to 'String.valueOf()'
1665 unnecessary.call.to.string.valueof.problem.descriptor=<code>#ref</code> can be simplified to ''{0}''
1666 unnecessary.call.to.string.valueof.quickfix=Replace with ''{0}''
1667 throwable.result.of.method.call.ignored.display.name=Throwable result of method call ignored
1668 throwable.result.of.method.call.ignored.problem.descriptor=Result of <code>#ref()</code> not thrown
1669 char.used.in.arithmetic.context.display.name=Char expression used in arithmetic context
1670 char.used.in.arithmetic.context.problem.descriptor=char <code>#ref</code> used in arithmetic context
1671 char.used.in.arithmetic.context.quickfix=Convert to String literal
1672 char.used.in.arithmetic.context.cast.quickfix=Insert cast to {0}
1673 unnecessary.constant.array.creation.expression.display.name=Constant array creation expression can be replaced with array initializer
1674 unnecessary.constant.array.creation.expression.problem.descriptor=<code>#ref</code> can be replaced with array initializer expression #loc
1675 unnecessary.constant.array.creation.expression.quickfix=Replace with array initializer expression
1676 ambiguous.method.call.display.name=Inherited method called which hides method in outer class
1677 ambiguous.method.call.problem.descriptor=<code>#ref()</code> inherited from ''{0}'' hides method from outer class ''{1}'' #loc
1678 ambiguous.method.call.quickfix=Qualify method call with 'this.'
1679 change.modifier.quickfix=Make ''{0}''
1680 the.whole.project=the whole project
1681 this.class=this class
1682 assertequals.may.be.assertsame.display.name='assertEquals()' may be 'assertSame()'
1683 assertequals.may.be.assertsame.problem.descriptor=<code>#ref()</code> may be 'assertSame()' #loc
1684 logger.initialized.with.foreign.class.quickfix=Replace with ''{0}.class''
1685 logger.initialized.with.foreign.class.problem.descriptor=Logger initializer with foreign class <code>#ref</code> #loc
1686 logger.initialized.with.foreign.class.display.name=Logger initialized with foreign class
1687 logger.factory.method.name=Logger factory &method:
1688 make.static.final.quickfix=Make ''{0}'' static final
1689 logging.condition.disagrees.with.log.statement.display.name=Logging condition does not match log statement
1690 logging.condition.disagrees.with.log.statement.problem.descriptor=Logging condition <code>#ref()</code> does not match ''{0}()'' log statement #loc
1691 log.statement.guarded.by.log.condition.display.name=Log statement not guarded by log condition
1692 log.statement.guarded.by.log.condition.problem.descriptor=<code>#ref()</code> log statement not guarded by log condition #loc
1693 log.statement.guarded.by.log.condition.quickfix=Surround with log condition
1694 key.set.iteration.may.use.entry.set.display.name=Iteration over 'keySet()' may be replaced with 'entrySet()' iteration
1695 key.set.iteration.may.use.entry.set.problem.descriptor=Iteration over <code>#ref</code> may be replaced with 'entrySet()' iteration #loc
1696 key.set.iteration.may.use.entry.set.quickfix=Replace with 'entrySet()' iteration
1697 string.replaceable.by.string.buffer.in.loop.option=Only warn when appending in a loop
1698 declare.collection.as.interface.quickfix=Weaken to ''{0}''
1699 non.exception.name.ends.with.exception.quickfix=Make ''{0}'' extend ''java.lang.Exception''
1700 constant.value.variable.use.display.name=Use of variable whose value is known to be constant
1701 constant.value.variable.use.problem.descriptor=Value of <code>#ref</code> is known to be constant #loc
1702 replace.reference.with.expression.quickfix=Replace with ''{0}''
1703 unnecessary.parentheses.option=Ignore clarifying parentheses
1704 unnecessary.parentheses.conditional.option=Ignore parentheses around the condition of conditional expressions
1705 field.may.be.final.display.name=Field may be final
1706 field.may.be.final.problem.descriptor=Field <code>#ref</code> may be 'final' #loc
1707 cast.that.loses.precision.option=Ignore casts from int to char
1708 variable.not.used.inside.if.display.name=Reference checked for null is not used inside if
1709 variable.not.used.inside.if.problem.descriptor=<code>#ref</code> is not used inside if #loc
1710 if.may.be.conditional.display.name=If statement could be replaced with simple conditional expression
1711 if.may.be.conditional.problem.descriptor=<code>#ref</code> could be replaced with simple conditional expression #loc
1712 if.may.be.conditional.quickfix=Replace with conditional expression
1713 redundant.string.format.call.display.name=Redundant call to 'String.format()'
1714 redundant.string.format.call.problem.descriptor=Redundant call to <code>#ref</code> #loc
1715 redundant.string.format.call.quickfix=Remove redundant call to 'String.format()'
1716 junit4.test.method.in.class.extending.junit3.testcase.display.name=JUnit 4 test method in class extending JUnit 3 TestCase
1717 junit4.test.method.in.class.extending.junit3.testcase.problem.descriptor=@Test annotated method <code>#ref</code> inside class extending JUnit 3 TestCase #loc
1718 equals.called.on.enum.constant.display.name='equals()' called on Enum value
1719 equals.called.on.enum.constant.problem.descriptor=<code>#ref</code> called on Enum value #loc
1720 equals.called.on.enum.constant.quickfix=Replace 'equals()' with '=='
1721 unnecessary.annotation.parentheses.display.name=Unnecessary annotation parentheses
1722 unnecessary.annotation.parentheses.problem.descriptor=<code>#ref</code> has unnecessary parentheses #loc
1723 unnecessary.annotation.parameter.quickfix=Remove parentheses
1724 int.literal.may.be.long.literal.display.name=int literal cast to long could be long literal
1725 int.literal.may.be.long.literal.problem.descriptor=<code>#ref</code> could be replaced with ''{0}''
1726 int.literal.may.be.long.literal.quickfix=Replace with ''{0}''
1727 constant.assert.condition.display.name='assert' statement condition is constant
1728 constant.assert.condition.problem.descriptor=assert condition <code>#ref</code> is constant
1729 assert.with.side.effects.display.name='assert' statement with side effects
1730 assert.with.side.effects.problem.descriptor=<code>#ref</code> has side effects #loc
1731 method.count.ignore.getters.setters.option=&Ignore simple getter and setter methods
1732 orred.not.equal.expression.display.name=Identical reference in '!=' expression on both sides of '||' expression
1733 orred.not.equal.expression.problem.descriptor=<code>#ref</code> is always true #loc
1734 orred.not.equal.expression.quickfix=Change '||' to '&&'
1735 class.new.instance.display.name=Unsafe call to 'Class.newInstance()'
1736 class.new.instance.problem.descriptor=Call to <code>#ref()</code> may throw undeclared checked exceptions #loc
1737 class.new.instance.quickfix=Replace with 'Class.getConstructor().newInstance()' call
1738 dynamic.regex.replaceable.by.compiled.pattern.display.name=Dynamic regular expression could be replaced by compiled Pattern
1739 dynamic.regex.replaceable.by.compiled.pattern.problem.descriptor=<code>#ref()</code> could be replaced with compiled java.util.regex.Pattern construct #loc
1740 dynamic.regex.replaceable.by.compiled.pattern.quickfix=Replace with call to method of compiled Pattern constant
1741 ignore.serializable.option=ignore java.io.Serializable
1742 ignore.cloneable.option=ignore java.lang.Cloneable
1743 listener.may.use.adapter.display.name=Class may extend adapter instead of implementing listener
1744 listener.may.use.adapter.problem.descriptor=Class ''{0}'' may extend ''{1}'' instead of implementing <code>#ref</code> #loc
1745 listener.may.use.adapter.quickfix=Replace with ''extends {0}''
1746 listener.may.use.adapter.emtpy.methods.option=&Only warn when empty implementing methods are found
1747 unnecessary.inherit.doc.display.name=Unnecessary {@inheritDoc} JavaDoc Comment
1748 unnecessary.inherit.doc.problem.descriptor=JavaDoc comment containing only <code>#ref</code> is unnecessary
1749 unnecessary.inherit.doc.quickfix=Remove unnecessary @inheritDoc
1750 multiple.exceptions.declared.on.test.method.display.name=Multiple exceptions declared on test method
1751 multiple.exceptions.declared.on.test.method.problem.descriptor=<code>#ref</code> could be replaced with 'throws Exception'
1752 multiple.exceptions.declared.on.test.method.quickfix=Replace with 'throws Exception'
1753 unnecessary.javadoc.link.display.name=Unnecessary JavaDoc link
1754 unnecessary.javadoc.link.problem.descriptor=<code>#ref</code> is unnecessary
1755 unnecessary.javadoc.link.quickfix=Remove unnecessary {0}
1756 thread.local.not.static.final.display.name=ThreadLocal field not declared static final
1757 thread.local.not.static.final.problem.descriptor=ThreadLocal <code>#ref</code> is not declared 'static final'