Permalink
Fetching contributors…
Cannot retrieve contributors at this time
executable file 6066 lines (5559 sloc) 268 KB
<?xml version="1.0" encoding="UTF-8"?>
<MessageCollection xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="messagecollection.xsd">
<Plugin>
<ShortDescription>fb-contrib plugin</ShortDescription>
<Details>
<![CDATA[
<p>This plugin contains FindBugs detectors from the fb-contrib project</p>
]]>
</Details>
<BugsUrl>http://fb-contrib.sourceforge.net/bugdescriptions.html</BugsUrl>
<AllBugsUrl>http://fb-contrib.sourceforge.net/bugdescriptions.html</AllBugsUrl>
</Plugin>
<!-- Detectors -->
<Detector class="com.mebigfatguy.fbcontrib.collect.CollectStatistics">
<Details>
<![CDATA[
<p>Collects statistics for other detectors</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.collect.CollectMethodsReturningImmutableCollections">
<Details>
<![CDATA[
<p>Collects method calls that may return immutable collections</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.InefficientStringBuffering">
<Details>
<![CDATA[
<p>Looks for appending strings inside of calls to StringBuffer or StringBuilder append.</p>
<pre>
StringBuilder sb = new StringBuilder();
sb.append(a + b);
return sb.toString();
</pre>
You should use the .append method to append values
<pre>
sb.append(a).append(b);
</pre>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.SyncCollectionIterators">
<Details>
<![CDATA[
<p>Looks for use of iterators on synchronized collections built from the java.util.Collections class.</p>
<p>As the collection in question was built through Collections.synchronizedXXX, an assumption
is made that this collection must be multithreaded safe. However, iterator access is used,
which is explicitly unsafe. When iterators are to be used, synchronization should be done manually.</p>
<p>It is a slow detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.CyclomaticComplexity">
<Details>
<![CDATA[
<p>Calculates the McCabe Cyclomatic Complexity measure and reports methods that have an
excessive value. This report value can be set with system property 'fb-contrib.cc.limit'.</p>
<p>It is a slow detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.OverlyConcreteParameter">
<Details>
<![CDATA[
<p>Looks for parameters that are defined by classes, but where the method only use methods defined by an
implemented interface or superclass of that class. Relying on concrete classes in public signatures causes cohesion,
and makes low impact changes more difficult.</p>
<p>It is a slow detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.ListIndexedIterating">
<Details>
<![CDATA[
<p>Looks for for loops that iterate over a java.util.List using an integer index, and get,
rather than using an Iterator. An iterator may perform better depending on List implementation,
but more importantly will allow the code to be converted to other collection types.</p>
<p>It is a moderately fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.UnrelatedCollectionContents">
<Details>
<![CDATA[
<p>Looks for collections or arrays that hold objects that are unrelated through class or
interface inheritance other than java.lang.Object. Doing so makes for brittle code,
relying either on positional correspondence for type, or a reliance on instanceof to
determine type. A better design usually can be had by creating a separate class,
which defines the different types required, and add an instance of that class to the
collection, or array.</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.RuntimeExceptionDeclared">
<Details>
<![CDATA[
<p>Looks for methods that declare RuntimeExceptions in their throws clause. While doing
so is not illegal, it may represent a misunderstanding as to the exception in question.
If a RuntimeException is declared, it implies that this exception type is expected to happen,
which if true should be handled in code, and not propagated. </p>
<p>It is a fast detector.</p>
<p>As an example, every method could be declared like this:
<code>
public void foo() throws NullPointerException {
}
</code>
But what does that tell you? Is this method very very likely to throw NullPointerExceptions?
If it is, why isn't this method handling them so that exceptions aren't thrown. So don't do this.
If an NPE is very likely, then check for it, and handle the situation.
</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.ClassEnvy">
<Details>
<![CDATA[
<p><em>THIS DETECTOR IS HIGHLY EXPERIMENTAL AND IS LIKELY TO CREATE A LOT OF FUD</em></p>
<p>Looks for methods that use a high percentage of methods from another class over its own
methods. When this is the case, it is often better to implement this method in that other class,
by refactoring the class to accept parameters it needs from the source class.
The reporting percentage can be set with system property 'fb-contrib.ce.percent'.</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.LiteralStringComparison">
<Details>
<![CDATA[
<p>Looks for methods that compare strings against literal strings, where the literal string
is passed as the parameter. If the .equals or .compareTo is called on the literal itself, passing
the variable as the parameter, you avoid the possibility of a NullPointerException.</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.PartiallyConstructedObjectAccess">
<Details>
<![CDATA[
<p>Looks for constructors of non-final classes that make method calls to non-final methods.
As these methods could be overridden, the overridden method will be accessing an object that
is only partially constructed, perhaps causing problems. Making these called methods final is
an easy fix, where possible.</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.DubiousListCollection">
<Details>
<![CDATA[
<p>Looks for fields that are implementations of java.util.List, but that are used in a set-like fashion.
Since lookup type operations are performed using a linear search for Lists, the performance for large
Lists will be poor. Consideration should be made as to whether these fields should be sets. In the
case that order is important, consider using LinkedHashSet.</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.ParallelLists">
<Details>
<![CDATA[
<p>Looks for classes that maintain two or more lists or arrays associated one-for-one through the same index
to hold two or more pieces of related information. It would be better to create a new class that holds
all of these pieces of information, and place instances of this class in one list. Or if the two list are
related in key/value fashion, then use a map instead.</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.FinalParameters">
<Details>
<![CDATA[
<p>Looks for methods that correctly do not write to a parameter. To help document this you should consider
defining these parameters as final.</p>
<p>It is a slow detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.AbstractClassEmptyMethods">
<Details>
<![CDATA[
<p>Looks for abstract classes that define empty methods or methods that simply throw an
exception. Since this is an abstract class, it may be cleaner to simple define this method
as abstract, so that correct subclass behavior is enforced.</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.ManualArrayCopy">
<Details>
<![CDATA[
<p>Looks for methods that copy data from one array to another using a loop. It is
better performing to use System.arraycopy to do such copying as this is a native method.</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.FloatingPointLoops">
<Details>
<![CDATA[
<p>Looks for methods that use floating point indexes for loops. Since floating point
math is imprecise, rounding errors will occur each time through the loop causing
hard to find problems. It is usually better to use integer indexing, and calculating
the correct floating point value from the index.</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.NonCollectionMethodUse">
<Details>
<![CDATA[
<p>Looks for method calls to collection classes where the method is not defined by the Collections
interface, and an equivalent method exists in the interface. Examples include:<br/>
<table border="1">
<tr><th>Old Method</th><th>New Method</th></tr>
<tr><td>Hashtable.contains</td><td>Map.containsValue</td></tr>
<tr><td>Hashtable.elements</td><td>Map.elements</td></tr>
<tr><td>Hashtable.keys</td><td>Map.keySet</td></tr>
<tr><td>Vector.addElement</td><td>List.add</td></tr>
<tr><td>Vector.elementAt</td><td>List.get</td></tr>
<tr><td>Vector.insertElementAt</td><td>List.add</td></tr>
<tr><td>Vector.removeAllElements</td><td>List.clear</td></tr>
<tr><td>Vector.removeElement</td><td>List.remove</td></tr>
<tr><td>Vector.removeElementAt</td><td>List.remove</td></tr>
<tr><td>Vector.setElementAt</td><td>List.set</td></tr>
</table>
</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.ConfusingAutoboxedOverloading">
<Details>
<![CDATA[
<p>Looks for methods that have the same signature, except where one uses a
Character parameter, and the other uses an int, long, float, double parameter.
Since autoboxing is available in 1.5 one might assume that
<pre><code>
test('a')
</code></pre>
would map to
<pre><code>
public void test(Character c)
</code></pre>
but instead maps to one that takes an int, long, float or double, such as
<pre><code>
public void test(int i)
</code></pre>
</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.AbnormalFinallyBlockReturn">
<Details>
<![CDATA[
<p>Looks for methods that have finally blocks that return values
or throw exceptions. This code will swallow normal program flow and
hide real program logic.</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.StaticMethodInstanceInvocation">
<Details>
<![CDATA[
<p>Looks for methods that make static method calls using an instance reference.
For documentation purposes, it is better to call the method using the class name.
This may represent a change in definition that should be noticed.</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.SpuriousThreadStates">
<Details>
<![CDATA[
<p>Looks for methods that call wait, notify or notifyAll on an instance of a
java.lang.Thread. Since the internal workings of the threads is to synchronize on the
thread itself, introducing client calls will confuse the thread state of the object
in question, and will cause spurious thread state changes, either waking threads up
when not intended, or removing the thread from the runnable state.</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.NeedlessAutoboxing">
<Details>
<![CDATA[
<p>Looks for methods that pass a primitive wrapper class object to the
same class' Constructor. Patterns found are:
<ul>
<li>new Boolean(Boolean)</li>
<li>new Byte(Byte)</li>
<li>new Character(Character)</li>
<li>new Short(Short)</li>
<li>new Integer(Integer)</li>
<li>new Long(Long)</li>
<li>new Float(Float)</li>
<li>new Double(Double)</li>
</ul>
Since primitive wrapper classes are immutable this is needless garbage being created. Just
use the original reference.
</p>
<p>It also looks for calls to BoxedClass.valueOf(x) where X is already a BoxedClass</p>
<p>It also looks for calls to BoxedClass.valueOf(myString).boxedValue(), when instead it is
simpler to use BoxedClass.parseBoxed(myString)</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.UnnecessaryStoreBeforeReturn">
<Details>
<![CDATA[
<p>Looks for methods that store the return result in a local variable and
then immediately return that local variable. It is simpler to just return
the method (or assignment) result directly.</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.CopiedOverriddenMethod">
<Details>
<![CDATA[
<p>Looks for methods that are direct copies of the implementation in the superclass.</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.ArrayBasedCollections">
<Details>
<![CDATA[
<p>Looks for methods that use arrays for items in the keySet of a map, or as
an element of a set, or in a list when using the contains method. Since arrays
do not, and cannot define an equals method, reference equality is used for these
collections, which is probably not desired. If it is, consider using the IdentityHashMap
class when using Maps in this case, to better document your intentions.</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.OrphanedDOMNode">
<Details>
<![CDATA[
<p>Looks for methods that create DOM nodes but do not add them to any DOM Document.
Either the node was needed to be added to the tree, or the node likely was created in error.</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.AbstractOverriddenMethod">
<Details>
<![CDATA[
<p>Looks for methods that are declared as abstract that override concrete methods in a
superclass. Doing this casts away the implementation of the superclass, and breaks
the contract as set forth by the parent class.</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.CustomBuiltXML">
<Details>
<![CDATA[
<p>Looks for methods that build XML based strings by concatenation strings
and custom values together. Doing so makes brittle code, that is difficult to
modify, validate and understand. It is cleaner to create external XML files that are
transformed at runtime, using parameters set through Transformer.setParameter.</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.BloatedSynchronizedBlock">
<Details>
<![CDATA[
<p>Looks for methods that are implemented using synchronized blocks, but are overly
synchronized because the beginning of the block only accesses local variables,
and not member variables, or this.</p>
<p>It is a slow detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.ConstantListIndex">
<Details>
<![CDATA[
<p>Looks for methods that access arrays or classes that implement java.util.List
using a constant integer for the index. This is often a typo intended to be a loop
variable, but if specific indices mean certain things, perhaps a first class object
would be a better choice for a container, on even a map with informative key names
would be better.</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.SloppyClassReflection">
<Details>
<![CDATA[
<p>Looks for methods that use Class.forName("XXX") to load a class object
for a class that is already referenced by this class. It is simpler to just use
XXX.class, and doing so protects the integrity of this code from such transformations
as obfuscation. Use of Class.forName should only be used when the class in question
isn't already statically bound to this context.</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.ArrayWrappedCallByReference">
<Details>
<![CDATA[
<p>Looks for methods that use an array of length one to pass a variable to achieve call
by pointer ala C++. It is better to define a proper return class type that holds all
the relevant information retrieved from the called method.</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.SluggishGui">
<Details>
<![CDATA[
<p>Looks for methods that implement AWT or Swing listeners and perform time
consuming operations. Doing these operations in the GUI thread will cause the
interface to appear sluggish and non-responsive to the user. It is better to
use a separate thread to do the time consuming work so that the user
has a better experience.</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.NeedlessInstanceRetrieval">
<Details>
<![CDATA[
<p>Looks for methods that call a method to retrieve a reference to an object,
to use to load a constant. It is simpler and more performant to access the
static variable directly from the class itself.</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.DateComparison">
<Details>
<![CDATA[
<p>Looks for inefficient comparison of Date objects using two comparisons when one would do.</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.SuspiciousWaitOnConcurrentObject">
<Details>
<![CDATA[
<p>Looks for calls to the wait method on mutexes defined in the java.util.concurrent
package where it is likely that await was intended.</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.JDBCVendorReliance">
<Details>
<![CDATA[
<p>Looks for uses of JDBC vendor specific classes and methods making the database
access code non-portable.</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.PossibleMemoryBloat">
<Details>
<![CDATA[
<p>Looks for classes that maintain collections or StringBuffer/StringBuilders in
static member variables, and that do not appear to provide a way to clear or remove
items from these members. Such class fields are likely causes of memory bloat.</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.LocalSynchronizedCollection">
<Details>
<![CDATA[
<p>Looks for allocations of synchronized collections that are stored in local
variables, and never stored in fields or returned from methods. As local variables
are by definition thread safe, using synchronized collections in this context
makes no sense.</p>
<p>It is a moderately fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.FieldCouldBeLocal">
<Details>
<![CDATA[
<p>Looks for classes that define fields that are used in a locals only fashion,
specifically private fields that are accessed first in each method with a
store vs. a load.</p>
<p>It is a slow detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.NonOwnedSynchronization">
<Details>
<![CDATA[
<p>Looks for methods that synchronize on variables that are not owned by the
current class. Doing this causes confusion when two classes use the same variable
for their own synchronization purposes. For cleanest separation of interests, only
synchronize on private fields of the class. Note that 'this' is not owned by
the current class and synchronization on 'this' should be avoided as well.</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.NonRecycleableTaglibs">
<Details>
<![CDATA[
<p>Looks for tag libraries that are not recycleable because backing members
of taglib attributes are set in areas besides the setter method for the attribute.</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.Section508Compliance">
<Details>
<![CDATA[
<p>Looks for violation of Section 508, Accessibility for People with disabilities Act.</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.UseEnumCollections">
<Details>
<![CDATA[
<p>Looks for use of sets and maps using enums. It is more efficient to use EnumSet or EnumMap.</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.SQLInLoop">
<Details>
<![CDATA[
<p>Looks for the execution of SQL queries inside a loop. This pattern tends to be inefficient,
and often can be improved upon, by collecting all the keys needed for the query and issuing just
one query using an in clause with all the keys for all the queries previously needed in the loop.</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.NeedlessMemberCollectionSynchronization">
<Details>
<![CDATA[
<p>Looks for classes that define private synchronized collections as static or instance
members, that are only altered in a static initializer or constructor. Since the multithreaded
use of this collection is read-only, the use of synchronization is unnecessary.</p>
<p>It is a moderately fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.InheritanceTypeChecking">
<Details>
<![CDATA[
<p>Looks for if/else blocks where a series of them use instanceof on the same
variable to determine what to do. If these classes are related by inheritance,
this often is better handled through calling a single overridden method.</p>
<p>It is a moderately fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.StaticArrayCreatedInMethod">
<Details>
<![CDATA[
<p>Looks for creation of arrays in methods using constant values. These arrays
will need to be recreated each time the method is called. These arrays should probably
be defined as static fields, instead.</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.PossiblyRedundantMethodCalls">
<Details>
<![CDATA[
<p>Looks for calls of the same method on the same object when that object hasn't changed.
This often is redundant, and the second call can be removed, or combined.</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.UseToArray">
<Details>
<![CDATA[
<p>Looks for code that builds an array of values from a collection, by manually looping
over the elements of the collection, and adding them to the array. It is simpler and
cleaner to use mycollection.toArray(new type[mycollection.size()]).</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.LostExceptionStackTrace">
<Details>
<![CDATA[
<p>Looks for methods that catch exceptions, and then throw a different exception
without embedding the original exception in the thrown one. Doing so, hides the real
source of the exception, making debugging and fixing these problems difficult.</p>
<p>It is a moderately fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.UseCharacterParameterizedMethod">
<Details>
<![CDATA[
<p>Looks for methods that pass single character string constants as parameters to
methods that alternatively have an overridden method that accepts a character instead.
It is easier for the method to handle a single character than a String.</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.TailRecursion">
<Details>
<![CDATA[
<p>Looks for methods that make a recursive call to itself as the last statement in the
method. This tail recursion could be converted into a simple loop which would improve
the performance and stack requirements.</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.UnrelatedReturnValues">
<Details>
<![CDATA[
<p>Looks for methods that are defined to return Object, and return different types of
objects based on different code paths. If this method is not based on an interface or
superclass, it is suggested to change the return type to a type that would accommodate
all kinds of return types.</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.PossibleIncompleteSerialization">
<Details>
<![CDATA[
<p>Looks for classes that don't handle serialization of parent class member fields
when the class in question is serializable but is derived from a non serializable
classes.</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.SuspiciousComparatorReturnValues">
<Details>
<![CDATA[
<p>Looks for classes that implement Comparator or Comparable, and whose compare or compareTo
methods return constant values only, but that don't represent the three possible choice
(a negative number, 0, and a positive number).</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.SillynessPotPourri">
<Details>
<![CDATA[
<p>Looks for a potpourri of small problems that do not fit into a common pattern.</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.BloatedAssignmentScope">
<Details>
<![CDATA[
<p><em>THIS DETECTOR IS HIGHLY EXPERIMENTAL AND IS LIKELY TO CREATE A LOT OF FUD</em></p>
<p>Looks for assignments to variables in a scope larger than its use. As long as the evaluation of the assignment
does not have side effects, the assignment can be moved into the inner scope where it is used.</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.SpoiledChildInterfaceImplementor">
<Details>
<![CDATA[
<p>Looks for classes that implement interfaces by relying on methods being
implemented in superclasses, even though the superclass knows nothing about
the interface being implemented by the child.</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.DeletingWhileIterating">
<Details>
<![CDATA[
<p>Looks for deletion of items from a collection using the remove method
of the collection at the same time that the collection is being iterated on. If
this occurs the iterator will become invalid and throw a ConcurrentModificationException.
Instead, the remove should be called on the iterator itself.</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.UseSplit">
<Details>
<![CDATA[
<p>Looks for code that builds an array by using a StringTokenizer to break up
a string and place individual elements into an array. It is simpler to use
String.split instead.</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.SuspiciousJDKVersionUse">
<Details>
<![CDATA[
<p>Looks for calls to classes and methods that do not exist in the JDK for which this class is
compiled. This can happen if you specify the <code>-source</code> and <code>-target</code> options of the javac compiler, and
specify a target that is less than the JDK version of the javac compiler.</p>
<p>It relies on the system property <code>-Dfb-contrib.sjvu.jdkhome=/path/to/older/jdk/to/check"</code> to specify
what JDK to compare against. On linux, you may need to give file permissions to findbugs to read these directories.
If this property is not set, this detector does nothing.</p>
<p>It is a slow detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.UseAddAll">
<Details>
<![CDATA[
<p>Looks for loops that transfer the contents of one collection to another. These collection sources might
be local variables or member fields, including sets, maps key/values, lists, or arrays. It is simpler to
just use the addAll method of the collection class. In the case where the source is an array, you can use
Arrays.asList(array), and use that as the source to addAll.</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.MethodReturnsConstant">
<Details>
<![CDATA[
<p>Looks for private or static methods that only return one constant value. Since there is no
chance for derived classes overriding this behavior, the return of a constant value
seems dubious.</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.NeedlessCustomSerialization">
<Details>
<![CDATA[
<p>Looks for classes that implement the Serializable interface and implement the
standard readObject and writeObject methods by simply deferring to the Stream
parameter's defaultReadObject or defaultWriteObject and nothing else. As this is the
built in behavior, these methods are not needed.</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.MisleadingOverloadModel">
<Details>
<![CDATA[
<p>Looks for classes that define both static and instance methods with the same name.
As each type represents a different use model, it doesn't make sense that this name
would be overloaded, and will confuse users of the class.</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.ExceptionSoftening">
<Details>
<![CDATA[
<p>Looks for methods that catch checked exceptions, and throw unchecked
exceptions in their place. There are several levels of concern. Least
concerning are methods constrained by interface or superclass contracts
not to throw checked exceptions but appear owned by the same author. Next
are methods constrained by interface or superclass contracts and throw other
types of checked exceptions. Most egregious are methods not constrained by any interface
or superclass contract.</p>
<p>It is a moderately fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.ConfusingFunctionSemantics">
<Details>
<![CDATA[
<p>Looks for methods that return a parameter after modifying that parameter.
Doing this will confuse the user of this method, as it will be assumed that the
passed in argument is different than the output, or at least won't be changed.
If the purpose of this method is just to modify the parameter, this method should
probably be changed to have a void return type. If you must return a variable, perhaps
a clone of the parameter should be returned.</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.UnitTestAssertionOddities">
<Details>
<![CDATA[
<p>Looks for JUnit or TestNG test case methods that use assertions with odd parameters.
Including in this is:
<ul>
<li>Passing a constant as the second (actual) parameter in a JUnit test</li>
<li>Not using the three parameter version of asserts for doubles</li>
<li>Passing true or false as the first parameter instead of using assertTrue, or assertFalse</li>
<li>Using the assert keyword</li>
</ul>
</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.SuspiciousCloneAlgorithm">
<Details>
<![CDATA[
<p>Looks for implementations of clone where an assignment is made to a field of the
source object. It is likely that that store should have occurred on the cloned object, as
the clone operation is almost always considered read only.</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.WeakExceptionMessaging">
<Details>
<![CDATA[
<p>Looks for exceptions that are thrown with static strings as messages. Using static strings
doesn't differentiate one use of this method versus another, and so it may be difficult
to determine how this exception occurred without showing context.</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.SuspiciousClusteredSessionSupport">
<Details>
<![CDATA[
<p>Looks for code that fetches a complex object from an HttpSession attribute, modifies the
object, but does not call setAttribute again on this object. This will not inform the application server
that this object has changed, and thus will not correctly replicate these changes across the cluster.</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.LoggerOddities">
<Details>
<![CDATA[
<p>Looks for odd patterns of use of Logger classes from either log4j, SLF4J or Commons Logging.</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.IncorrectInternalClassUse">
<Details>
<![CDATA[
<p>Looks for classes that rely on internal classes in the various APIs or libraries. As these
classes are not officially released from the API vendor, they are subject to change or removal, and thus,
should not be counted on.</p>
Packages that shouldn't be used are:
<ul>
<li>sun.xxx</li>
<li>org.apache.xerces.xxx</li>
<li>org.apache.xalan.xxx</li>
</ul>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.DubiousSetOfCollections">
<Details>
<![CDATA[
<p>Looks for sets or keySets of maps that contain other collections. As typically collections calculate
their hashCode, equals and compareTo methods by iterating the collection and evaluating the same function
on each item in the collection, this can be costly from a performance point of view.</p>
<p>In addition, using a set, or keySet of a map, infers that you will be looking for items based on
the value of a collection, which seems dubious at best.</p>
<p>Finally, as collections are often modified, this may cause problems if the collection is modified,
thus changing hashCodes, etc, while the collection is in the set.</p>
<p>If you wish to keep a collection of collections, the outer collection should probably be a list
to avoid these problems.</p>
<p>It is a moderately fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.BogusExceptionDeclaration">
<Details>
<![CDATA[
<p>Looks for constructors, static methods and private methods that declare that they throw
checked exceptions that the actual code never throws. Since these methods can't be overridden,
there is no reason to add these exceptions to the method declaration.</p>
<p>It is a moderately fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.UnnecessaryNewNullCheck">
<Details>
<![CDATA[
<p>Looks for allocations of objects, and then immediately checking to see if the
object is null, or non null. As the new operator is guaranteed to either succeed, or throw
an exception, this null check is useless, and denotes a misunderstanding as to how
the JVM works. You can remove this guard.</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.DeprecatedTypesafeEnumPattern">
<Details>
<![CDATA[
<p>Looks for classes that appear to implement the old style type safe enum pattern
that was used before Java added Enum support to the language. Since this class is
compiled with Java 1.5 or later, it would be simpler to just use Java enums.</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.TristateBooleanPattern">
<Details>
<![CDATA[
<p>Looks for methods that are declared to return a Boolean, but return a null
value. As this now allows the method to return three values, the use of Boolean is
dubious. It would be better to just define a new enumeration with three values,
and return that.</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.SuspiciousUninitializedArray">
<Details>
<![CDATA[
<p>Looks for methods that return arrays that are allocated but not initialized
in this method. While it's possible that the calling method will do the work of
initializing the array, it is not a usual pattern, and it is suspected that this array
was just forgotten to be initialized.</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.InappropriateToStringUse">
<Details>
<![CDATA[
<p>Looks for methods that perform algorithmic operations on Strings that are returned
from a toString() method. As toString should only be used for debug/trace purposes, it
shouldn't be used for algorithm use.</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.InconsistentKeyNameCasing">
<Details>
<![CDATA[
<p>Looks for methods that use the same name with different casing to access objects in HttpRequest parameters
and attributes. As these parameter names are case-sensitive this will lead to confusion.</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.OverzealousCasting">
<Details>
<![CDATA[
<p>Looks for manual casts of objects that are more specific than needed as the value is assigned
to a class or interface higher up in the inheritance chain. You only need to cast to that class
or interface.</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.PoorlyDefinedParameter">
<Details>
<![CDATA[
<p>Looks for non derivable methods that declare parameters and then cast those
parameters to more specific types in the method. This is misleading and dangerous
as you are not documenting through parameter types what is necessary for these
parameters to function correctly.</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.NonSymmetricEquals">
<Details>
<![CDATA[
<p>Looks for classes that break the fundamental rule of equivalence, which is
symmetry. If a equals b, then b equals a. While it is usually wrong to allow
equals to compare different types, at the very least you should make sure that
each class knows about each other and is able to compare themselves with each other.</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.ContraVariantArrayAssignment">
<Details>
<![CDATA[
<p>Finds contravariant array assignments. Since arrays are mutable data structures, their use
must be restricted to covariant or invariant usage.</p>
<pre><code>
class A {}
class B extends A {}
B[] b = new B[2];
A[] a = b;
a[0] = new A(); // results in ArrayStoreException (Runtime)
</code></pre>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.NonFunctionalField">
<Details>
<![CDATA[
<p>Looks for fields in serializable classes that are defined as both final and
transient. As a transient field is not initialized when streamed, and is not
initialized in a constructor, it will remain null because it is defined final.</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.SuspiciousNullGuard">
<Details>
<![CDATA[
<p>Looks for code that checks to see if a field or local variable is not null,
before entering a code block either an if, or while statement, and then reassigns that
field or local variable. It is likely that guard should have been to see if that
field or local variable is null, not, not null.</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.MoreDumbMethods">
<Details>
<![CDATA[
<p>This detector looks for calls to more pointless or deprecated methods.</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.ReflectionOnObjectMethods">
<Details>
<![CDATA[
<p>This detector looks for reflective calls on methods that are found in the class java.lang.Object.
As these methods are always available, there is no reason to use reflection to call them.</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.ImproperPropertiesUse">
<Details>
<![CDATA[
<p>This detector looks for java.util.Properties use where values other than String
are placed in the properties object. As the Properties object was intended to be a
String to String only collection, putting other types in the Properties object is
incorrect, and takes advantage of a poor design decision by the original Properties class
designers to derive from Hashtable, rather than using aggregation.</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.PossibleConstantAllocationInLoop">
<Details>
<![CDATA[
<p>This detector looks for allocations of objects using the default constructor in a loop, where
the object allocated is never assigned to any object that is used outside the loop.
It is possible that this allocation can be done outside the loop to avoid excessive garbage.</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.WriteOnlyCollection">
<Details>
<![CDATA[
<p>This detector looks for allocations and initializations of Java collections, but that are never
read from or accessed to gain information. This represents a collection of no use, and most probably
can be removed. It is similar to a dead local store.</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.UseVarArgs">
<Details>
<![CDATA[
<p>This detector looks for definitions of methods that have an array as the last parameter.
Since this class is compiled with Java 1.5 or better, it would be more flexible for clients of this
method to define this parameter as a vararg parameter.</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.PossibleUnsuspectedSerialization">
<Details>
<![CDATA[
<p>This detector looks for code that serializes objects that are non-static inner
classes of other classes. Since there is a reference to the containing class, this class will be serialized as well.
It is often the case that this is not what is wanted, and will cause much more data to be serialized
than is necessary.</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.SideEffectConstructor">
<Details>
<![CDATA[
<p>This detector looks for object creation where the object isn't assigned to any variable or
field. This implies that the class operates through side effects in the constructor, which makes
for difficult to maintain code.</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.SuspiciousGetterSetterUse">
<Details>
<![CDATA[
<p>This detector looks for Java bean getter-setter use where the value of a property is set
with the value retrieved from the same bean's correllary getter, like this:</p>
<pre><code>
person.setAge(person.getAge());
</code></pre>
<p>Typically this is a copy paste typo.</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.LingeringGraphicsObjects">
<Details>
<![CDATA[
<p>This detector looks for creation of java.awt.Graphics object that do not have the
<code>.dispose()</code> method called on them when finished. These objects will be cleaned up by
the Garbage collector, bug given the likelihood that large numbers of these objects can
be created in a short period of time, it is better to dispose them as soon as possible.</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.StackedTryBlocks">
<Details>
<![CDATA[
<p>This detector looks for two or more try catch blocks that are consecutive
and catch the same kind of exception, and each catch block mandatorily throws
the same exception. These two catch blocks can and should be made into one
catch block to simply the code.</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.CommonsEqualsBuilderToEquals">
<Details>
<![CDATA[
<p>This detector looks for uses for commons-lang EqualsBuilder where the
result of equals() is returned instead of calling the method isEquals().</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.CommonsHashcodeBuilderToHashcode">
<Details>
<![CDATA[
<p>This detector looks for uses for commons-lang <code>HashCodeBuilder</code> where the
result of <code>hashCode()</code> is returned instead of calling the method <code>toHashCode()</code>.</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.CommonsStringBuilderToString">
<Details>
<![CDATA[
<p>This detector looks for uses for commons-lang <code>ToStringBuilder</code> where the
result of <code>toString()</code> is returned without an intermediate invocation of toString().</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.CompareClassNameEquals">
<Details>
<![CDATA[
<p>In a JVM, two classes are the same class (and consequently the same type) if
they are loaded by the same class loader, and they have the same fully
qualified name [JVMSpec 1999].
Comparing class name ignores the class loader.</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.BackportReusePublicIdentifiers">
<Details>
<![CDATA[
<p>Detects use of Backport Utils concurrent classes from Emory, or Time classes from ThreeTen. Updated/efficient versions of
classes from emory are available in versions of the JDK 5.0 and higher, and in JDK 8.0 and higher for ThreeTen, and these
classes should only be used if you are targeting a JDK lower than this.</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.CloneUsability">
<Details>
<![CDATA[
<p>Looks for classes that implement clone() that do not specialize the return value, and do
not swallow CloneNotSupportedException. Not doing so makes the clone method not as simple to use,
and should be harmless to do so.</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.ConfusingArrayAsList">
<Details>
<![CDATA[
<p>Looks for calls to Arrays.asList where the parameter is a primitive array.
This does not produce a list that holds the primitive boxed values, but a list of
one item, the array itself.</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.PresizeCollections">
<Details>
<![CDATA[
<p>Looks for methods that create collections using the default constructor,
even though the number of elements that will be placed in the collection is known
a priori, and thus could be pre-allocated. Not doing so just causes more intermediate
reallocations which is unnecessary.</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.UnboundMethodTemplateParameter">
<Details>
<![CDATA[
<p>Looks for methods that declare method level template parameter(s) that are not bound to any of the
method's parameters, and thus is not adding any validation/type safety to the method, and is
just confusing.</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.NonProductiveMethodCall">
<Details>
<![CDATA[
<p>Looks for common methods that are non mutating where the return value is ignored. As these methods
do not change the object they are called on, calling these methods is pointless. They can be removed.</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.ArrayIndexOutOfBounds">
<Details>
<![CDATA[
<p>Looks for questionable load/stores to array elements.
<ul>
<li>
Looks for accesses to array elements using literal values that are known to be outside the bounds of the array.
This mistake will cause an ArrayIndexOutOfBoundsException to occur at runtime.</li>
<li>
Looks for stores to array elements where the array itself appears to have not been allocated.
</li>
</ul>
</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.InvalidConstantArgument">
<Details>
<![CDATA[
<p>Looks for method calls that take a parameter value that does not match one of the expected
values for that parameter. It is likely this parameter value should really be an enum, but predates
the addition of enums to Java. Passing an invalid value will likely cause problems in the execution of
the method.
</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.CollectionNamingConfusion">
<Details>
<![CDATA[
<p>Looks for fields or local variables that are collections but the names have a different type
of collection in the name. This is confusing, and is probably a left over from a type change, such as
</p>
<p>List&lt;String&gt; mySet;</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.PoorMansEnum">
<Details>
<![CDATA[
<p>Looks for fields defined with simple types, (int, String, etc) that are used like an enum. Specifically fields that are
only assigned a set of constant values. This variable probably should be redefined as an enum.
</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.UnusedParameter">
<Details>
<![CDATA[
<p>Looks for private or static methods that have parameters that aren't used. These parameters
can be removed, assuming the method isn't used through reflection.</p>
<p>It is fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.FindClassCircularDependencies">
<Details>
<![CDATA[
<p>This detector looks circular dependencies among classes. </p>
<p>It is a moderately fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.ModifyingUnmodifiableCollection">
<Details>
<![CDATA[
<p>This detector looks for code that attempts to modify a collection that is or may be
defined as immutable. Doing so will cause exceptions at runtime.</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.HangingExecutors">
<Details>
<![CDATA[
<p>Three detectors for hanging ExecutorServices, that is, ExecutorServices that never get a call to shutdown, which
can potentially cause the JVM to not exit.</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.HttpClientProblems">
<Details>
<![CDATA[
<p>The HttpRequests from the Apache HttpComponents have some little-known quirks about them.
This is a set of detectors that helps guard against resource starvation.</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.Unjitable">
<Details>
<![CDATA[
<p>This detector looks for methods that are longer than 8000 bytes. Methods this
long are automatically disqualified by the JIT for compilation and will always be
emulated. Consider breaking this method up to avoid this, if performance is important.</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.ConflictingTimeUnits">
<Details>
<![CDATA[
<p>Looks for methods that perform arithmetic operations on values representing time
where the time unit is incompatible, i.e. adding a millisecond value to a nanosecond value.
</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.CharsetIssues">
<Details>
<![CDATA[
<p>Looks for manual specification of String encoding using String constants where either
a StandardCharset could be used (JDK7) or where the encoding is not recognized with the
current JDK.</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.ContainsBasedConditional">
<Details>
<![CDATA[
<p>Looks for complex if expressions made up of multiple conditions joined by OR, where the same
local variable is compared to a static value. When the number of conditions grow it is much cleaner
to build a static set of the possible values, and use the contains method on that set. This will
shorten the code, and make it more self documenting.</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.OverlyPermissiveMethod">
<Details>
<![CDATA[
<p>Looks for methods that are declared more permissively than the code is using. For instance, declaring
a method public, when it could just be declared private. Having methods have more permissive access than they
need to have limits your ability to make observations about these methods, like parameter usage,
refactorability, and derivability. This detector will not report on methods that are never called in
the case this method is an API like method intended to be called by client code. If this method is
also called through reflection, this detector may erroneous report it.</p>
<p>It is a moderately fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.StringifiedTypes">
<Details>
<![CDATA[
<p>Looks for classes that store fields that are Strings that impersonate instances of classes, or collections that are
fields that hold Strings that impersonate a class. Examples of String impersonating are storing:
<ul>
<li>The result of a toString call</li>
<li>Strings build from parsing or building strings from other objects, such as "1,2,3,4" or "Project:3"</li>
</ul>
By using Strings you are throwing away type-safety, and making it difficult to reason about what the values of variables
in use are. If a String has multiple parts to it, it probably belongs as a first class Class.
</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.SuspiciousLoopSearch">
<Details>
<![CDATA[
<p>Looks for methods that assign a value to a variable in an if equals conditional in a loop, but does not break after doing so.
Since equality would seem to be a one time event, continuing with the loop seems pointless, and a break statement in the if statement
seems like it should be added.</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.ConflatingResourcesAndFiles">
<Details>
<![CDATA[
<p>Looks for methods that use the File API on resources retrieved from URLs where the URL in question isn't from a file protocol.
In the case of classpath resources, this will work if the code is executed from directories, but fail using JARs.
If using resources, then use URL.openStream() method instead of File APIs.</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.ImmatureClass">
<Details>
<![CDATA[
<p>Looks for classes that are not fully complete from a usability point of view. Making them more difficult to use
than it should be. Things such as
<ul>
<li>Using the default package</li>
<li>Missing hashCode/equals</li>
<li>Missing toString() method</li>
<li>Using autogenerated parameter names</li>
</ul>
</p>
<p>It is a moderately fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.JAXRSIssues">
<Details>
<![CDATA[
<p>Looks for problems with the use of the JAX-RS specification.</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.JPAIssues">
<Details>
<![CDATA[
<p>Looks for problems with the use of the JPA specification, including spring's
support of JPA</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.SuboptimalExpressionOrder">
<Details>
<![CDATA[
<p>Looks for conditional expressions that are a combination of simple local variable (in)equalities
and tests on the results of method calls where the method calls are done first. By placing the simple
conditions first you may eliminate costly calls in certain cases. This assumes that the method calls
do not have side effects that should happen always.</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.IOIssues">
<Details>
<![CDATA[
<p>Looks for various issues around doing I/O with streams and reader/writers.</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.DubiousMapCollection">
<Details>
<![CDATA[
<p>Looks for use of maps that are private fields in a List only way, that is, maps that are created in constructors
or static initializers, and are only iterated over. Often this is done because the Map allows for two values, as opposed
to a List. The Fix is to just create a List of some object that holds all the values.</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.BuryingLogic">
<Details>
<![CDATA[
<p>Looks for methods that needlessly push a large chunk of code to the right through indenting with braces.
The code is basically an if/else-then-return structure. The if true test does the bulk of the logic, and the else
just returns. It is more readable if the bulk of the logic is move as far to the left in the method as is possible.
</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.WiringIssues">
<Details>
<![CDATA[
<p>Looks for various issues around @Autowired/@Inject fields in DI classes</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.ConcurrentCollectionIssues">
<Details>
<![CDATA[
<p>Looks for problems with using concurrent collections
<ul>
<li>Adding a collection as a value of Concurrent map, without the use of putIfAbsent</li>
</ul>
</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.UseTryWithResources">
<Details>
<![CDATA[
<p>Looks for use of auto-closeable resources in JDK 7 or later that are not using
the try-with-resources paradigm. To avoid problems, and ease the reader, use of try-with-resources
is recommended</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.SuspiciousShadedClassUse">
<Details>
<![CDATA[
<p>Looks for use of shaded methods from 3rdparty jars, created by tools such as the maven shade plugin.
These methods are from classes that have been included in a jar, for internal use, and are copies of real 3rdparty jars.
It is likely you meant to use the real class from the real jar, but your IDE picked the wrong import to use.
</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.UnsynchronizedSingletonFieldWrites">
<Details>
<![CDATA[
<p>Looks for writes to fields of classes that are believed to be classes used only as Singletons. These
classes include Enums, as well as spring beans that are Singleton scoped.</p>
<p>It is a fast detector.</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.OptionalIssues">
<Details>
<![CDATA[
<p>Looks for various issues with the use of the java.util.Optional class.</p>
<p>It is a fast detector</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.UnnecessaryApiConversion">
<Details>
<![CDATA[
<p>Looks for code that appears to be using two forms of similar apis, an older one, and a new one.
It finds code that creates newer api objects by first instantiating older api objects, and converting
them into the new form. It is simpler just to create the new object directly.</p>
<p>It is a fast detector</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.detect.ReflectionIssues">
<Details>
<![CDATA[
<p>Looks for issues around the use of java reflection.</p>
<p>It is a fast detector</p>
]]>
</Details>
</Detector>
<Detector class="com.mebigfatguy.fbcontrib.debug.OCSDebugger">
<Details></Details>
</Detector>
<!-- BugPattern -->
<BugPattern type="ISB_INEFFICIENT_STRING_BUFFERING">
<ShortDescription>Method passes simple concatenating string in StringBuffer or StringBuilder append</ShortDescription>
<LongDescription>Method {1} passes simple concatenating string in StringBuffer or StringBuilder append</LongDescription>
<Details>
<![CDATA[
<p>This method uses <code>StringBuffer</code> or <code>StringBuilder</code>'s append method to concatenate strings. However, it passes the result
of doing a simple String concatenation to one of these append calls, thus removing any performance gains
of using the <code>StringBuffer</code> or <code>StringBuilder</code> class.</p>
<p>
Java will implicitly use StringBuilders, which can make this hard to detect or fix. For example, <br/>
<pre><code>
StringBuilder sb = new StringBuilder();
for (Map.Entry<Integer, String> e : map.entrySet()) {
sb.append(e.getKey() + e.getValue()); //bug detected here
}
</code></pre><br/>
gets automatically turned into something like: <br/>
<pre><code>
StringBuilder sb = new StringBuilder();
for (Map.Entry<Integer, String> e : map.entrySet()) {
StringBuilder tempBuilder = new StringBuilder();
tempBuilder.append(e.getKey());
tempBuilder.append(e.getValue());
<b>sb.append(tempBuilder.toString());</b> //this isn't too efficient
}
</code></pre><br/>
which involves a temporary <code>StringBuilder</code>, which is completely unnecessary. To prevent this from happening, simply do:<br/>
<pre><code>
StringBuilder sb = new StringBuilder();
for (Map.Entry<Integer, String> e : map.entrySet()) {
sb.append(e.getKey());
sb.append(e.getValue());
}
</code></pre>
</p>
]]>
</Details>
</BugPattern>
<BugPattern type="ISB_EMPTY_STRING_APPENDING">
<ShortDescription>Method concatenates an empty string to effect type conversion</ShortDescription>
<LongDescription>Method {1} concatenates an empty string to effect type conversion</LongDescription>
<Details>
<![CDATA[
<p>This method concatenates an empty string with a literal value, in order to convert
the literal value into a string. It is more efficient to use String.valueOf() to do the same
thing as you do not incur the cost of creating a StringBuffer/Builder and calling methods on it
to accomplish this.</p>
]]>
</Details>
</BugPattern>
<BugPattern type="ISB_TOSTRING_APPENDING">
<ShortDescription>Method concatenates the result of a toString() call</ShortDescription>
<LongDescription>Method {1} concatenates the result of a toString() call</LongDescription>
<Details>
<![CDATA[
<p>This method concatenates the output of a <code>toString()</code> call into a <code>StringBuffer</code> or <code>StringBuilder</code>.
It is simpler just to pass the object you want to append to the append call, as that form
does not suffer the potential for <code>NullPointerException</code>s, and is easier to read.</p>
<p>
Keep in mind that Java compiles simple <code>String</code> concatenation to use <code>StringBuilder</code>s,
so you may see this bug even when you don't use <code>StringBuilder</code>s explicitly.
</p>
<p>
Instead of: <br/>
<pre><code>
StringBuilder builder = ...;
builder.append(someObj.toString());
...
System.out.println("Problem with the object :" + someObj.toString());
</code></pre>
just do: <br/>
<pre><code>
StringBuilder builder = ...
builder.append(someObj);
...
System.out.println("Problem with the object :" + someObj);
</code></pre>
to avoid the possibility of <code>NullPointerException</code>s when someObj is <code>null</code>.
</p>
]]>
</Details>
</BugPattern>
<BugPattern type="SCI_SYNCHRONIZED_COLLECTION_ITERATORS">
<ShortDescription>Method creates iterators on synchronized collections</ShortDescription>
<LongDescription>Method {1} creates iterators on synchronized collections</LongDescription>
<Details>
<![CDATA[
<p>This method uses a synchronized collection, built from Collections.synchronizedXXXX, but accesses it
through an iterator. Since an iterator is, by definition, multithreaded unsafe, this is a conflict in
concept. When using iterators, you should do the synchronization manually.</p>
]]>
</Details>
</BugPattern>
<BugPattern type="CC_CYCLOMATIC_COMPLEXITY">
<ShortDescription>Method is excessively complex</ShortDescription>
<LongDescription>Method {1} is excessively complex, with a cyclomatic complexity of {3}</LongDescription>
<Details>
<![CDATA[
<p>This method has a high cyclomatic complexity figure, which calculates the number of branch
points. It is likely difficult to test, and is brittle to change. Consider refactoring this
method into several to reduce the risk.</p>
]]>
</Details>
</BugPattern>
<BugPattern type="OCP_OVERLY_CONCRETE_PARAMETER">
<ShortDescription>Method needlessly defines parameter with concrete classes</ShortDescription>
<LongDescription>{3}</LongDescription>
<Details>
<![CDATA[
<p>This method uses concrete classes for parameters when only methods defined in an implemented
interface or superclass are used. Consider increasing the abstraction of the interface to
make low impact changes easier to accomplish in the future.</p>
<p>Take the following example:<br/>
<pre><code>
private void appendToList(ArrayList&lt;String&gt; list) {
if (list.size() &lt; 100) {
list.add("Foo");
}
}
</code></pre>
The parameter list is currently defined as an <code>ArrayList</code>, which is a concrete implementation of the <code>List</code> interface.
Specifying <code>ArrayList</code> is unnecessary here, because we aren't using any <code>ArrayList</code>-specific methods (like <code>ensureCapacity()</code> or <code>trimToSize()</code>).
Instead of using the concrete definition, it is better to do something like:<br/>
<pre><code>
private void appendToList(List&lt;String&gt; list) {
...
</code></pre>
If the design ever changes, e.g. a <code>LinkedList</code> is used instead, this code won't have to change.
</p>
<p>IDEs tend to have tools to help generalize parameters. For example, in Eclipse, the refactoring tool <a href="http://help.eclipse.org/luna/index.jsp?topic=%2Forg.eclipse.jdt.doc.user%2Freference%2Fref-menu-refactor.htm">Generalize Declared Type</a> helps find an appropriate level of concreteness.</p>
]]>
</Details>
</BugPattern>
<BugPattern type="LII_LIST_INDEXED_ITERATING">
<ShortDescription>Method uses integer based for loops to iterate over a List</ShortDescription>
<LongDescription>Method {1} uses integer based for loops to iterate over a List</LongDescription>
<Details>
<![CDATA[
<p>This method uses an integer based for loop to iterate over a java.util.List, by calling
List.get(i) each time through the loop. The integer is not used for other reasons. It is better
to use an Iterator instead, as depending on List implementation, iterators can perform better,
and they also allow for exchanging of other collection types without issue.</p>
]]>
</Details>
</BugPattern>
<BugPattern type="UCC_UNRELATED_COLLECTION_CONTENTS">
<ShortDescription>Method adds unrelated types to collection or array</ShortDescription>
<LongDescription>Method {1} adds unrelated types to collection or array</LongDescription>
<Details>
<![CDATA[
<p>This method adds unrelated objects to a collection or array, requiring careful and brittle
data access to that collection. Create a separate class with properties needed, and add
an instance of this class to the collection or array, if possible.</p>
]]>
</Details>
</BugPattern>
<BugPattern type="DRE_DECLARED_RUNTIME_EXCEPTION">
<ShortDescription>Method declares RuntimeException in throws clause</ShortDescription>
<LongDescription>Method {1} declares RuntimeException in throws clause</LongDescription>
<Details>
<![CDATA[
<p>This method declares a RuntimeException derived class in its throws clause.
This may indicate a misunderstanding as to how unchecked exceptions are handled.
If it is felt that a RuntimeException is so prevalent that it should be declared, it
is probably a better idea to prevent the occurrence in code.</p>
]]>
</Details>
</BugPattern>
<BugPattern type="CE_CLASS_ENVY">
<ShortDescription>Method excessively uses methods of another class</ShortDescription>
<LongDescription>Method {1} excessively uses methods of another class</LongDescription>
<Details>
<![CDATA[
<p><em>THIS DETECTOR IS HIGHLY EXPERIMENTAL AND IS LIKELY TO CREATE A LOT OF FUD</em></p>
<p>This method makes extensive use of methods from another class over methods of its own
class. Typically this means that the functionality that is accomplished by this method
most likely belongs with the class that is being used so liberally. Consider refactoring this
method to be contained in that class, and to accept all the parameters needed in the method signature.</p>
]]>
</Details>
</BugPattern>
<BugPattern type="LSC_LITERAL_STRING_COMPARISON">
<ShortDescription>Method makes literal string comparisons passing the literal as an argument</ShortDescription>
<LongDescription>Method {1} makes literal string comparisons passing the literal as an argument</LongDescription>
<Details>
<![CDATA[
<p>This line is in the form of <br/>
<pre><code>String str = ...
str.equals("someOtherString");
//or
str.compareTo("someOtherString");</code></pre>
</p>
<p>A <code>NullPointerException</code> may occur if the String variable <code>str</code> is <code>null</code>. If instead the code was restructured to<br/>
<pre><code>String str = ...
"someOtherString".equals(str);
//or
"someOtherString".compareTo(str);</code></pre><br/>
that is, call <code>equals()</code> or <code>compareTo()</code> on the string literal, passing the
variable as an argument, this exception could never happen as both <code>equals()</code> and
<code>compareTo()</code> check for <code>null</code>.</p>
]]>
</Details>
</BugPattern>
<BugPattern type="PCOA_PARTIALLY_CONSTRUCTED_OBJECT_ACCESS">
<ShortDescription>Constructor makes call to non-final method</ShortDescription>
<LongDescription>Constructor {1} makes call to non-final method</LongDescription>
<Details>
<![CDATA[
<p>This constructor makes a call to a non-final method. Since this method can be overridden, a subclasses
implementation will be executing against an object that has not been initialized at the subclass level.
You should mark all methods called from the constructor as final to avoid this problem.</p>
]]>
</Details>
</BugPattern>
<BugPattern type="DLC_DUBIOUS_LIST_COLLECTION">
<ShortDescription>Class defines List based fields but uses them like Sets</ShortDescription>
<LongDescription>Class {0} defines List based fields but uses them like Sets</LongDescription>
<Details>
<![CDATA[
<p>This class defines a field based on java.util.List, but uses it to some extent like a Set. Since
lookup type operations are performed using a linear search for Lists, the performance for large
Lists will be poor. If the list is known to only contain a small number of items, (3, 4, etc) then it
doesn't matter. Otherwise, consider changing this field's implementation to a set-based one. If order of
iteration is important to maintain insert order, perhaps consider a LinkedHashSet.</p>
]]>
</Details>
</BugPattern>
<BugPattern type="PL_PARALLEL_LISTS">
<ShortDescription>Class defines two or more one for one associated lists or arrays</ShortDescription>
<LongDescription>Class {0} defines two or more one for one associated lists or arrays</LongDescription>
<Details>
<![CDATA[
<p>This class appears to maintain two or more lists or arrays whose contents are related in a parallel way. That is,
you have something like:<br/>
<pre><code>
List&lt;String&gt; words = new ArrayList&lt;String&gt;();
List&lt;Integer&gt; wordCounts = new ArrayList&lt;String&gt;();
</code></pre>
where the elements of the list at index 0 are related, the elements at index 1 are related and so on. </p>
<p>
Consider creating a separate class to hold all the related
pieces of information, and adding instances of this class to just one list or array, or if just two values, use
a Map to associate one value with the other like:<br/>
<pre><code>
private class WordAndCount{public String word; public int count}
List&lt;WordAndCount&gt; wordsAndCounts = new ArrayList&lt;WordAndCount&gt;();
//or, for just two elements
Map<String,Integer> wordCounts = new HashMap<String,Integer>();
</code></pre>
</p>
]]>
</Details>
</BugPattern>
<BugPattern type="FP_FINAL_PARAMETERS">
<ShortDescription>Method does not define a parameter as final, but could</ShortDescription>
<LongDescription>Method {1} does not define one or more parameters as final, but could</LongDescription>
<Details>
<![CDATA[
<p>This method does not write to a parameter. To help document this, and to perhaps
help the JVM optimize the invocation of this method, you should consider defining these parameters
as final.</p>
<p>Performance gains are debatable as "the final keyword does not appear in the class file for
local variables and parameters, thus it cannot impact the runtime performance. Its only use
is to clarify the coders intent that the variable not be changed (which many consider dubious
reason for its usage), and dealing with anonymous inner classes." - http://stackoverflow.com/a/266981/1447621 </p>
]]>
</Details>
</BugPattern>
<BugPattern type="ACEM_ABSTRACT_CLASS_EMPTY_METHODS">
<ShortDescription>Empty method could be declared abstract</ShortDescription>
<LongDescription>Empty method {1} could be declared abstract</LongDescription>
<Details>
<![CDATA[
<p>This method is empty or merely throws an exception. Since the class it is defined in is
abstract, it may be more correct to define this method as abstract instead, so that proper
subclass behavior is enforced.</p>
]]>
</Details>
</BugPattern>
<BugPattern type="MAC_MANUAL_ARRAY_COPY">
<ShortDescription>Method copies arrays manually</ShortDescription>
<LongDescription>Method {1} copies arrays manually</LongDescription>
<Details>
<![CDATA[
<p>This method copies data from one array to another manually using a loop.
It is much better performing to use System.arraycopy as this method is native.</p>
]]>
</Details>
</BugPattern>
<BugPattern type="FPL_FLOATING_POINT_LOOPS">
<ShortDescription>Method uses floating point indexed loops</ShortDescription>
<LongDescription>Method {1} uses floating point indexed loops</LongDescription>
<Details>
<![CDATA[
<p>This method uses floating point variables to index a loop. Since floating point
math is imprecise, rounding errors will accumulate over time each time the loop is
executed. It is usually better to use integer indexing, and calculate the new value
of the floating point number at the top of the loop body.</p>
<p>Example:
<pre><code>
for (float f = 1.0f; f &lt;= 10.0f; f += 0.1f) {
System.out.println(f);
}
</code></pre>
The last value printed may not be 10.0, but instead might be 9.900001 or such.
</p>
]]>
</Details>
</BugPattern>
<BugPattern type="NCMU_NON_COLLECTION_METHOD_USE">
<ShortDescription>Method uses old non collections interface methods</ShortDescription>
<LongDescription>Method {1} uses old non collections interface methods</LongDescription>
<Details>
<![CDATA[
<p>This method makes calls to collection classes where the method is not defined by the Collections
interface, and an equivalent method exists in the interface. By using the new methods,
you can define this object by the Collections interface and allow better decoupling.</p>
]]>
</Details>
</BugPattern>
<BugPattern type="CAO_CONFUSING_AUTOBOXED_OVERLOADING">
<ShortDescription>Class defines methods which confuse Character with int parameters</ShortDescription>
<LongDescription>Class {0} defines methods which confuse Character with int parameters</LongDescription>
<Details>
<![CDATA[
<p>This class defines two methods that differ only by a parameter being defined
as Character vs. int, long, float or double. As autoboxing is present, it may be
assumed that a parameter of 'a' would map to the Character version, but it does not.</p>
]]>
</Details>
</BugPattern>
<BugPattern type="AFBR_ABNORMAL_FINALLY_BLOCK_RETURN">
<ShortDescription>Method has abnormal exit from finally block</ShortDescription>
<LongDescription>Method {1} has abnormal exit from finally block</LongDescription>
<Details>
<![CDATA[
<p>This method returns or throws exceptions from a finally block. This will
mask real program logic in the try block, and short-circuit normal method termination.</p>
]]>
</Details>
</BugPattern>
<BugPattern type="SMII_STATIC_METHOD_INSTANCE_INVOCATION">
<ShortDescription>Method calls static method on instance reference</ShortDescription>
<LongDescription>Method {1} calls static method on instance reference</LongDescription>
<Details>
<![CDATA[
<p>This method makes a static method call on an instance reference. For
reading comprehension of the code is better to call the method on the class,
rather than an instance. Perhaps this method's static nature has changed since
this code was written, and should be revisited.</p>
]]>
</Details>
</BugPattern>
<BugPattern type="STS_SPURIOUS_THREAD_STATES">
<ShortDescription>Method calls wait, notify or notifyAll on a Thread instance</ShortDescription>
<LongDescription>Method {1} calls wait, notify or notifyAll on a Thread instance</LongDescription>
<Details>
<![CDATA[
<p>This method invokes the methods wait, notify or notifyAll on a Thread instance.
Doing so will confuse the internal thread state behavior causing spurious thread
wakeups/sleeps because the internal mechanism also uses the thread instance for its
notifications.</p>
]]>
</Details>
</BugPattern>
<BugPattern type="NAB_NEEDLESS_AUTOBOXING_CTOR">
<ShortDescription>Method passes primitive wrapper to same primitive wrapper constructor</ShortDescription>
<LongDescription>Method {1} passes primitive wrapper to same primitive wrapper constructor</LongDescription>
<Details>
<![CDATA[
<p>This method passes a wrapped primitive object to the same class's constructor.
Since wrapper classes are immutable, you can just use the original object, rather
than constructing a new one. This code works because of an abuse of autoboxing.</p>
]]>
</Details>
</BugPattern>
<BugPattern type="NAB_NEEDLESS_BOXING_STRING_CTOR">
<ShortDescription>Method passes parsed string to primitive wrapper constructor</ShortDescription>
<LongDescription>Method {1} passes parsed string to primitive wrapper constructor</LongDescription>
<Details>
<![CDATA[
<p>This method passes a primitive value retrieved from a <code>BoxedPrimitive.parseBoxedPrimitive("1")</code> call to
the same class's constructor. It is simpler to just pass the string to the BoxedPrimitives constructor or, better yet, use the static valueOf.</p>
<p>Instead of something like:<br/>
<pre><code>
Boolean bo = new Boolean(Boolean.parseBoolean("true"));
Float f = new Float(Float.parseFloat("1.234"));
</code></pre>
Simply do: <br/>
<pre><code>
Boolean bo = new Boolean("true");
Float f = new Float("1.234");
</code></pre>
or, to be more memory efficient: <br/>
<pre><code>
Boolean bo = Boolean.valueOf("true");
Float f = Float.valueOf("1.234");
</code></pre>
</p>
]]>
</Details>
</BugPattern>
<BugPattern type="NAB_NEEDLESS_AUTOBOXING_VALUEOF">
<ShortDescription>Method passes primitive wrapper to Wrapper class valueOf method</ShortDescription>
<LongDescription>Method {1} passes primitive wrapper to Wrapper class valueOf method</LongDescription>
<Details>
<![CDATA[
<p>This method passes a wrapped primitive object to the same class's .valueOf method.
Since wrapper classes are immutable, you can just use the original object, rather
than calling valueOf to create a new one. This code works because of an abuse of autoboxing.</p>
]]>
</Details>
</BugPattern>
<BugPattern type="NAB_NEEDLESS_BOXING_PARSE">
<ShortDescription>Method converts String to primitive using excessive boxing</ShortDescription>
<LongDescription>Method {1} converts String to primitive using excessive boxing</LongDescription>
<Details>
<![CDATA[
<p>This method passes a String to a wrapped primitive object's valueOf method, which in turn calls
the boxedValue() method to convert to a primitive. When it is desired to convert from a String
to a primitive value, it is simpler to use the BoxedPrimitive.parseBoxedPrimitive(String)
method. </p>
<p>Instead of something like:<br/>
<pre><code>
public int someMethod(String data) {
long l = Long.valueOf(data).longValue();
float f = Float.valueOf(data).floatValue();
return Integer.valueOf(data); // There is an implicit .intValue() call
}
</code></pre>
Simply do: <br/>
<pre><code>
public int someMethod(String data) {
long l = Long.parseLong(data);
float f = Float.parseFloat(data);
return Integer.parseInt(data);
}
</code></pre>
</p>
]]>
</Details>
</BugPattern>
<BugPattern type="NAB_NEEDLESS_BOXING_VALUEOF">
<ShortDescription>Method converts String to boxed primitive using excessive boxing</ShortDescription>
<LongDescription>Method {1} converts String to boxed primitive using excessive boxing</LongDescription>
<Details>
<![CDATA[
<p>This method passes a String to a wrapped primitive object's parse method, which in turn calls
the valueOf() method to convert to a boxed primitive. When it is desired to convert from a String
to a boxed primitive object, it is simpler to use the BoxedPrimitive.valueOf(String) method.</p>
<p>Instead of something like:<br/>
<pre><code>
Boolean bo = Boolean.valueOf(Boolean.parseBoolean("true"));
Float f = Float.valueOf(Float.parseFloat("1.234"));
</code></pre>
Simply do: <br/>
<pre><code>
Boolean bo = Boolean.valueOf("true");
Float f = Float.valueOf("1.234");
</code></pre>
</p>
]]>
</Details>
</BugPattern>
<BugPattern type="NAB_NEEDLESS_BOX_TO_UNBOX">
<ShortDescription>Method creates Boxed primitive from primitive only to get primitive value</ShortDescription>
<LongDescription>Method {1} creates Boxed primitive from primitive only to get primitive value</LongDescription>
<Details>
<![CDATA[
<p>This method constructs a Boxed Primitive from a primitive only to call the primitiveValue() method to
convert it back to a primitive. Just use the primitive value instead.</p>
<p>Instead of something like:<br/>
<pre><code>
boolean bo = new Boolean(true).booleanValue();
float f = new Float(1.234f).floatValue();
</code></pre>
Simply do: <br/>
<pre><code>
boolean bo = true;
float f = 1.234f;
</code></pre>
</p>
]]>
</Details>
</BugPattern>
<BugPattern type="NAB_NEEDLESS_BOX_TO_CAST">
<ShortDescription>Method creates Boxed primitive from primitive only to cast to another primitive type</ShortDescription>
<LongDescription>Method {1} creates Boxed primitive from primitive only to cast to another primitive type</LongDescription>
<Details>
<![CDATA[
<p>This method constructs a Boxed Primitive from a primitive only to call the primitiveValue() method to
cast the value to another primitive type. It is simpler to just use casting.</p>
<p>Instead of something like:<br/>
<pre><code>
double someDouble = ...
float f = new Double(someDouble).floatValue();
int someInt = ...
byte b = new Integer(someInt).byteValue();
</code></pre>
Simply do: <br/>
<pre><code>
double someDouble = ...
float f = (float) someDouble;
int someInt = ...
byte b = (byte)someInt;
</code></pre>
</p>
]]>
</Details>
</BugPattern>
<BugPattern type="NAB_NEEDLESS_BOOLEAN_CONSTANT_CONVERSION">
<ShortDescription>Method needlessly boxes a boolean constant</ShortDescription>
<LongDescription>Method {1} needlessly boxes a boolean constant</LongDescription>
<Details>
<![CDATA[
<p>This method assigns a Boxed boolean constant to a primitive boolean variable, or assigns a primitive boolean
constant to a Boxed boolean variable. Use the correct constant for the variable desired. Use <br/>
<pre><code>
boolean b = true;
boolean b = false;
</code></pre>
or <br/>
<pre><code>
Boolean b = Boolean.TRUE;
Boolean b = Boolean.FALSE;
</code></pre>
</p>
<p>Be aware that this boxing happens automatically when you might not expect it. For example, <br/>
<pre><code>
Map<String, Boolean> statusMap = ...
public Boolean someMethod() {
statusMap.put("foo", true); //the "true" here is boxed
return false; //the "false" here is boxed
}
</code></pre>
has two cases of this needless autoboxing. This can be made more efficient by simply substituting
in the constant values: <br/>
<pre><code>
Map<String, Boolean> statusMap = ...
public Boolean someMethod() {
statusMap.put("foo", Boolean.TRUE);
return Boolean.FALSE;
}
</code></pre>
</p>
]]>
</Details>
</BugPattern>
<BugPattern type="USBR_UNNECESSARY_STORE_BEFORE_RETURN">
<ShortDescription>Method stores return result in local before immediately returning it</ShortDescription>
<LongDescription>Method {1} stores return result in local before immediately returning it</LongDescription>
<Details>
<![CDATA[
<p>This method stores the return result in a local variable, and then immediately
returns the local variable. It would be simpler just to return the value that is
assigned to the local variable, directly.</p>
<p>
Instead of the following: <br/>
<pre><code>
public float average(int[] arr) {
float sum = 0;
for (int i = 0; i &lt; arr.length; i++) {
sum += arr[i];
}
float ave = sum / arr.length;
return ave;
}
</code></pre>
Simply change the method to return the result of the division: <br/>
<pre><code>
public float average(int[] arr) {
float sum = 0;
for (int i = 0; i &lt; arr.length; i++) {
sum += arr[i];
}
<b>return sum / arr.length;</b> //Change
}
</code></pre>
</p>
]]>
</Details>
</BugPattern>
<BugPattern type="COM_COPIED_OVERRIDDEN_METHOD">
<ShortDescription>Method is implemented with an exact copy of its superclass's method</ShortDescription>
<LongDescription>Method {1} is implemented with an exact copy of its superclass's method</LongDescription>
<Details>
<![CDATA[
<p>This method is implemented using an exact copy of its superclass method's
implementation, which usually means that this method can just be removed.</p>
]]>
</Details>
</BugPattern>
<BugPattern type="COM_PARENT_DELEGATED_CALL">
<ShortDescription>Method merely delegates to its superclass's version</ShortDescription>
<LongDescription>Method {1} merely delegates to its superclass's version</LongDescription>
<Details>
<![CDATA[
<p>This method is implemented to just delegate its implementation by calling
the superclass method with the same signature. This method can just be removed.</p>
]]>
</Details>
</BugPattern>
<BugPattern type="ABC_ARRAY_BASED_COLLECTIONS">
<ShortDescription>Method uses array as basis of collection</ShortDescription>
<LongDescription>Method {1} uses array as basis of collection</LongDescription>
<Details>
<![CDATA[
<p>This method passes an array as the key to a Map, element in a Set, or item in a List when
the contains method is used on the List. Since arrays do not and cannot override the equals
method, collection inclusion is based on the reference's address, which is probably not desired.
In the case that this is a TreeMap or TreeSet, consider passing a Comparator to the map's
constructor.</p>
]]>
</Details>
</BugPattern>
<BugPattern type="ODN_ORPHANED_DOM_NODE">
<ShortDescription>Method creates DOM node but doesn't attach it to a document</ShortDescription>
<LongDescription>Method {1} creates DOM node but doesn't attach it to a document</LongDescription>
<Details>
<![CDATA[
<p>This method creates a DOM node but does not attach it to a DOM document.</p>
]]>
</Details>
</BugPattern>
<BugPattern type="AOM_ABSTRACT_OVERRIDDEN_METHOD">
<ShortDescription>Abstract method overrides a concrete implementation</ShortDescription>
<LongDescription>Abstract method {1} overrides a concrete implementation</LongDescription>
<Details>
<![CDATA[
<p>This abstract method is derived from a concrete method implementation. It is highly
suspect that the superclass method's implementation would be cast away.</p>
]]>
</Details>
</BugPattern>
<BugPattern type="CBX_CUSTOM_BUILT_XML">
<ShortDescription>Method builds XML strings through ad hoc concatenation</ShortDescription>
<LongDescription>Method {1} builds XML strings through ad hoc concatenation</LongDescription>
<Details>
<![CDATA[
<p>This method generates an XML based string by concatenating together various
XML fragments, and variable values. Doing so makes the code difficult to read, modify
and validate. It is much more clean to build XML structures in external files that are
read in and transformed into the final product, through modification by Transformer.setParameter.</p>
]]>
</Details>
</BugPattern>
<BugPattern type="BSB_BLOATED_SYNCHRONIZED_BLOCK">
<ShortDescription>Method overly synchronizes a block of code</ShortDescription>
<LongDescription>Method {1} overly synchronizes a block of code</LongDescription>
<Details>
<![CDATA[
<p>This method implements a synchronized block, but the code found at the beginning
of this block only accesses local variables, and not member variables, or this.
For better performance, move the code that accesses local variables only, above the
synchronized block, and leave the synchronized block only for field accesses, or access
to this object.</p>
]]>
</Details>
</BugPattern>
<BugPattern type="CLI_CONSTANT_LIST_INDEX">
<ShortDescription>Method accesses list or array with constant index</ShortDescription>
<LongDescription>Method {1} accesses list or array with constant index</LongDescription>
<Details>
<![CDATA[
<p>This method accesses an array or list using a constant integer index. Often,
this is a typo where a loop variable is intended to be used. If however, specific
list indices mean different specific things, then perhaps replacing the list with
a first-class object with meaningful accessors would make the code less brittle.</p>
]]>
</Details>
</BugPattern>
<BugPattern type="SCR_SLOPPY_CLASS_REFLECTION">
<ShortDescription>Method accesses statically bound class with Class.forName</ShortDescription>
<LongDescription>Method {1} accesses statically bound class with Class.forName</LongDescription>
<Details>
<![CDATA[
<p>This method accesses the class object of a class that is already statically bound
in this context, with Class.forName. Using Class.forName makes reflection more fragile
in regards to code transformations such as obfuscation, and is unneeded here, since
the class in question is already 'linked' to this class.</p>
]]>
</Details>
</BugPattern>
<BugPattern type="AWCBR_ARRAY_WRAPPED_CALL_BY_REFERENCE">
<ShortDescription>Method uses 1 element array to simulate call by reference</ShortDescription>
<LongDescription>Method {1} uses 1 element array to simulate call by reference</LongDescription>
<Details>
<![CDATA[
<p>This method uses a one-element array to wrap an object that is to be passed to a method as an argument
to simulate call by pointer ala C++. It is better to define a proper return class type that holds all
the relevant information retrieved from the called method.</p>
]]>
</Details>
</BugPattern>
<BugPattern type="SG_SLUGGISH_GUI">
<ShortDescription>Method performs time consuming operation in GUI thread</ShortDescription>
<LongDescription>Method {1} performs time consuming operation in GUI thread</LongDescription>
<Details>
<![CDATA[
<p>This method implements an AWT or Swing listener and performs time
consuming operations. Doing these operations in the GUI thread will cause the
interface to appear sluggish and non-responsive to the user. Consider
using a separate thread to do the time consuming work so that the user
has a better experience.</p>
]]>
</Details>
</BugPattern>
<BugPattern type="NIR_NEEDLESS_INSTANCE_RETRIEVAL">
<ShortDescription>Method retrieves instance to load static member</ShortDescription>
<LongDescription>Method {1} retrieves instance to load static member</LongDescription>
<Details>
<![CDATA[
<p>This method calls a method to load a reference to an object, and then only
uses it to load a static member of that instance's class. It is simpler and
more performant to just load the static field from the class itself.</p>
]]>
</Details>
</BugPattern>
<BugPattern type="DDC_DOUBLE_DATE_COMPARISON">
<ShortDescription>Method uses two date comparisons when one would do</ShortDescription>
<LongDescription>Method {1} uses two date comparisons when one would do</LongDescription>
<Details>
<![CDATA[
<p>This method compares dates with two comparisons, rather than using the reverse comparison.
So this pattern</p>
<pre><code>
if ((date1.equals( date2 )) || (date1.after( date2 )))
</code></pre>
could become:<br/>
<pre><code>
if (date1.compareTo( date2 ) >= 0)
</code></pre><br/>
and<br/>
<pre><code>
if ((date1.equals( date2 )) || (date1.before( date2 )))
</code></pre>
could become <br/>
<pre><code>
if (date1.compareTo( date2 ) <= 0)
</code></pre><br/>
and<br/>
<pre><code>
if ((date1.before( date2 )) || (date1.after( date2 )))
</code></pre>
could become<br/>
<pre><code>
if (!date1.equals( date2 ))
</code></pre>
]]>
</Details>
</BugPattern>
<BugPattern type="SWCO_SUSPICIOUS_WAIT_ON_CONCURRENT_OBJECT">
<ShortDescription>Method calls wait when await was probably intended</ShortDescription>
<LongDescription>Method {1} calls wait when await was probably intended</LongDescription>
<Details>
<![CDATA[
<p>This method calls wait() on a on mutex defined in the java.util.concurrent package.
These classes, define await, instead of wait, and it is most likely that await
was intended.</p>
]]>
</Details>
</BugPattern>
<BugPattern type="JVR_JDBC_VENDOR_RELIANCE">
<ShortDescription>Method uses JDBC vendor specific classes and methods</ShortDescription>
<LongDescription>Method {1} uses JDBC vendor specific classes and methods</LongDescription>
<Details>
<![CDATA[
<p>This method uses JDBC vendor specific classes and method to perform database work.
This makes the code specific to this vendor, and unable to run on other databases.</p>
]]>
</Details>
</BugPattern>
<BugPattern type="PMB_POSSIBLE_MEMORY_BLOAT">
<ShortDescription>Potential memory bloat in static field</ShortDescription>
<LongDescription>Class {0} defines static field "{1}" which appears to allow memory bloat</LongDescription>
<Details>
<![CDATA[
<p>This class defines static fields that are <code>Collection</code>s, <code>StringBuffer</code>s, or <code>StringBuilder</code>s
that do not appear to have any way to clear or reduce their size. That is, a collection is defined
and has method calls like <br/>
{<code>add()</code>, <code>append()</code>, <code>offer()</code>, <code>put()</code>, ...} <br/>
with no method calls to removal methods like<br/>
{<code>clear()</code>, <code>delete()</code>, <code>pop()</code>, <code>remove()</code>, ...}<br/>
This means that the collection in question can only ever increase in size, which is
a potential cause of memory bloat.</p>
<p>
If this collection is a list, set or otherwise of static things (e.g. a List&gt;String&gt; for month names), consider
adding all of the elements in a static initializer, which can only be called once:<br/>
<pre><code>
private static List&lt;String&gt; monthNames = new ArrayList&lt;String&gt;();
static {
monthNames.add("January");
monthNames.add("February");
monthNames.add("March");
...
}
</code></pre>
</p>
]]>
</Details>
</BugPattern>
<BugPattern type="PMB_INSTANCE_BASED_THREAD_LOCAL">
<ShortDescription>Field is an instance based ThreadLocal variable</ShortDescription>
<LongDescription>Field {1} is an instance based ThreadLocal variable</LongDescription>
<Details>
<![CDATA[
<p>This ThreadLocal field is defined as being instance based (not static). As all
ThreadLocal variables describe permanent reachability roots so far as the garbage
collector is concerned, these variables will never be reclaimed (so long as the Thread lives).
Since this ThreadLocal is instanced, you potentially will be creating many non reclaimable
variables, even after the owning instance has been reclaimed. It is almost a certainty that
you want to use static based ThreadLocal variables.</p>
]]>
</Details>
</BugPattern>
<BugPattern type="LSYC_LOCAL_SYNCHRONIZED_COLLECTION">
<ShortDescription>Method creates local variable-based synchronized collection</ShortDescription>
<LongDescription>Method {1} creates local variable-based synchronized collection</LongDescription>
<Details>
<![CDATA[
<p>This method creates a synchronized collection and stores the reference to it
in a local variable. As local variables are by definition thread-safe, it seems
questionable that this collection needs to be synchronized.</p>
<p>
<table>
<tr><th>If you are using</th><th>consider using</th></tr>
<tr><td>java.util.Vector</td><td>java.util.ArrayList</td></tr>
<tr><td>java.util.Hashtable</td><td>java.util.HashMap</td></tr>
<tr><td>java.lang.StringBuffer</td><td>java.lang.StringBuilder</td></tr>
</table>
</p>
]]>
</Details>
</BugPattern>
<BugPattern type="FCBL_FIELD_COULD_BE_LOCAL">
<ShortDescription>Class defines fields that are used only as locals</ShortDescription>
<LongDescription>Class {0} defines fields that are used only as locals</LongDescription>
<Details>
<![CDATA[
<p>This class defines fields that are used in a locals only fashion,
specifically private fields or protected fields in final classes that are accessed
first in each method with a store vs. a load. This field could be replaced by one
or more local variables.</p>
]]>
</Details>
</BugPattern>
<BugPattern type="NOS_NON_OWNED_SYNCHRONIZATION">
<ShortDescription>Class uses non owned variables to synchronize on</ShortDescription>
<LongDescription>Class {0} uses non owned variables to synchronize on</LongDescription>
<Details>
<![CDATA[
<p>This method uses a synchronize block where the object that is being synchronized on,
is not owned by this current instance. This means that other instances may use this same
object for synchronization for their own purposes, causing synchronization confusion. It is
always cleaner and safer to only synchronize on private fields of this class. Note that 'this'
is not owned by the current instance, but is owned by whomever assigns it to a field of its
class. Synchronizing on 'this' is also not a good idea.</p>
]]>
</Details>
</BugPattern>
<BugPattern type="NRTL_NON_RECYCLEABLE_TAG_LIB">
<ShortDescription>Tag library is not recycleable</ShortDescription>
<LongDescription>Tag library {0} is not recycleable</LongDescription>
<Details>
<![CDATA[
<p>This tag library class implements an attribute whose associated backing store field
is modified at another point in the tag library. In order for a tag library to be
recycleable, only the container is allowed to change this attribute, through the use
of the setXXX method of the taglib. By modifying the value programmatically, the
container will not initialize the attribute correctly on reuse.</p>
]]>
</Details>
</BugPattern>
<BugPattern type="S508C_NULL_LAYOUT">
<ShortDescription>GUI uses absolute layout</ShortDescription>
<LongDescription>GUI {0} uses absolute layout</LongDescription>
<Details>
<![CDATA[
<p>This class passes null to setLayout, which specifies that components are
to be laid out using absolute coordinates. This makes making changes for
font sizes, etc, difficult as items will not reposition.</p>
]]>
</Details>
</BugPattern>
<BugPattern type="S508C_NO_SETLABELFOR">
<ShortDescription>JLabel doesn't specify what it's labeling</ShortDescription>
<LongDescription>JLabel in method {1} doesn't specify what it's labeling</LongDescription>
<Details>
<![CDATA[
<p>This class uses JLabels that do not specify what fields are being labeled.
This hampers screen readers from given appropriate feed back to users. Use
the JLabel.setLabelFor method to accomplish this.</p>
]]>
</Details>
</BugPattern>
<BugPattern type="S508C_NO_SETSIZE">
<ShortDescription>Window sets size manually, and doesn't use pack</ShortDescription>
<LongDescription>Window {0} sets size manually, and doesn't use pack</LongDescription>
<Details>
<![CDATA[
<p>This class creates a window, and sizes the window using setSize. It is better,
for handling font size changes, to use the pack method.</p>
]]>
</Details>
</BugPattern>
<BugPattern type="S508C_NON_ACCESSIBLE_JCOMPONENT">
<ShortDescription>Class extends JComponent but does not implement Accessible interface</ShortDescription>
<LongDescription>Class {0} extends JComponent but does not implement Accessible interface</LongDescription>
<Details>
<![CDATA[
<p>This class extends the JComponent GUI control but does not implement the Accessibility interface.
This makes this control unable to be processed by screen readers, etc, for people with reading/vision
difficulties.</p>
]]>
</Details>
</BugPattern>
<BugPattern type="S508C_SET_COMP_COLOR">
<ShortDescription>Method explicitly sets the color of a Component</ShortDescription>
<LongDescription>Method {1} Method explicitly sets the color of a Component</LongDescription>
<Details>
<![CDATA[
<p>This method sets a Components explicitly foreground or background color which may
cause difficulty with people with vision problems from using this application.
Colors should be allowed to be set from the operating system.</p>
]]>
</Details>
</BugPattern>
<BugPattern type="S508C_NON_TRANSLATABLE_STRING">
<ShortDescription>Method passes constant string to title/label of component</ShortDescription>
<LongDescription>Method {1} passes constant string to title/label of component</LongDescription>
<Details>
<![CDATA[
<p>This method creates a component and passes a string literal to the title or label
of the component. As this string will be shown to users, it should be internationalizable
through the use of a resource bundle.</p>
]]>
</Details>
</BugPattern>
<BugPattern type="S508C_APPENDED_STRING">
<ShortDescription>Method passes appended string to title/label of component</ShortDescription>
<LongDescription>Method {1} passes appended string to title/label of component</LongDescription>
<Details>
<![CDATA[
<p>This method creates a component and passes a string that was built up from a number of
strings through appending multiple strings together. As foreign languages may order phrases
differently, this will make translations difficult.</p>
]]>
</Details>
</BugPattern>
<BugPattern type="UEC_USE_ENUM_COLLECTIONS">
<ShortDescription>Class uses an ordinary set or map with an enum class as the key</ShortDescription>
<LongDescription>Class {0} uses an ordinary set or map with an enum class as the key</LongDescription>
<Details>
<![CDATA[
<p>This class uses an ordinary set or map collection and uses an enum class as the key type.
It is more performant to use the JDK 1.5 EnumSet or EnumMap classes.</p>
]]>
</Details>
</BugPattern>
<BugPattern type="SIL_SQL_IN_LOOP">
<ShortDescription>Method executes SQL queries inside of loops</ShortDescription>
<LongDescription>Method {1} executes SQL queries inside of loops</LongDescription>
<Details>
<![CDATA[
<p>This method executes SQL queries inside of a loop. This pattern is often inefficient
as the number of queries may mushroom in fencepost cases. It is probably more performant
to loop over the input and collect the key data needed for the query for all items, and
issue one query using an in clause, or similar construct, and then loop over this result
set, and fetch all the data at once.</p>
]]>
</Details>
</BugPattern>
<BugPattern type="NMCS_NEEDLESS_MEMBER_COLLECTION_SYNCHRONIZATION">
<ShortDescription>Class defines unneeded synchronization on member collection</ShortDescription>
<LongDescription>Class {0} defines unneeded synchronization on member collection</LongDescription>
<Details>
<![CDATA[
<p>This class defines a private collection member as synchronized. It appears however
that this collection is only modified in a static initializer, or constructor. As these
two areas are guaranteed to be thread safe, defining this collection as synchronized is
unnecessary and a potential performance bottleneck.</p>
]]>
</Details>
</BugPattern>
<BugPattern type="ITC_INHERITANCE_TYPE_CHECKING">
<ShortDescription>Method uses instanceof on multiple types to arbitrate logic</ShortDescription>
<LongDescription>Method {1} uses instanceof on multiple types to arbitrate logic</LongDescription>
<Details>
<![CDATA[
<p>This method uses the instanceof operator in a series of if/else statements to
differentiate blocks of code based on type. If these types are related by inheritance,
it is cleaner to just define a method in the base class, and use overridden methods
in these classes.</p>
]]>
</Details>
</BugPattern>
<BugPattern type="SACM_STATIC_ARRAY_CREATED_IN_METHOD">
<ShortDescription>Method creates array using constants</ShortDescription>
<LongDescription>Method {1} creates array using constants</LongDescription>
<Details>
<![CDATA[
<p>This method creates an array initialized by constants. Each time this method is called
this array will be recreated. It would be more performant to define the array as a
static field of the class instead.</p>
]]>
</Details>
</BugPattern>
<BugPattern type="PRMC_POSSIBLY_REDUNDANT_METHOD_CALLS">
<ShortDescription>Method appears to call the same method on the same object redundantly</ShortDescription>
<LongDescription>Method {1} appears to call the same method on the same object redundantly</LongDescription>
<Details>
<![CDATA[
<p>This method makes two consecutive calls to the same method using the same constant
parameters, on the same instance without any intervening changes to the objects. If this
method does not make changes to the object, which it appears it doesn't, then making
two calls is just a waste. These method calls could be combined by assigning the
result into a temporary variable, and using the variable the second time.</p>
]]>
</Details>
</BugPattern>
<BugPattern type="UTA_USE_TO_ARRAY">
<ShortDescription>Method manually creates array from collection</ShortDescription>
<LongDescription>Method {1} manually creates array from collection</LongDescription>
<Details>
<![CDATA[
<p>This method manually loops over a collection, pulling each element out and storing
it in an array to build an array from the collection. It is easier, and clearer to use
the built in collections method toArray. Given a collection 'mycollection' of type T, use
<code>mycollection.toArray(new T[mycollection.size()]);</code></p>
]]>
</Details>
</BugPattern>
<BugPattern type="LEST_LOST_EXCEPTION_STACK_TRACE">
<ShortDescription>Method throws alternative exception from catch block without history</ShortDescription>
<LongDescription>Method {1} throws alternative exception from catch block without history</LongDescription>
<Details>
<![CDATA[
<p>This method catches an exception, and throws a different exception, without incorporating the
original exception. Doing so hides the original source of the exception making debugging and fixing
these problems difficult. It is better to use the constructor of this new exception that takes an
original exception so that this detail can be passed along to the user. If this exception has no constructor
that takes an initial cause parameter, use the initCause method to initialize it instead.</p>
<p>
<pre><code>
catch (IOException e) {
throw new MySpecialException("Failed to open configuration", e);
}
</code></pre>
</p>
]]>
</Details>
</BugPattern>
<BugPattern type="UCPM_USE_CHARACTER_PARAMETERIZED_METHOD">
<ShortDescription>Method passes constant String of length 1 to character overridden method</ShortDescription>
<LongDescription>Method {1} passes constant String of length 1 to character overridden method</LongDescription>
<Details>
<![CDATA[
<p>This method passes a constant literal <code>String</code> of length 1 as a parameter to a method, that
exposes a similar method that takes a <code>char</code>. It is simpler and more expedient to handle one
character, rather than a <code>String</code>.</p>
<p>
Instead of making calls like: <br/>
<pre><code>
String myString = ...
if (myString.indexOf("e") != -1) {
int i = myString.lastIndexOf("e");
System.out.println(myString + ":" + i); //the Java compiler will use a StringBuilder internally here [builder.append(":")]
...
return myString.replace("m","z");
}
</code></pre>
Replace the single letter <code>String</code>s with their <code>char</code> equivalents like so:<br/>
<pre><code>
String myString = ...
if (myString.indexOf('e') != -1) {
int i = myString.lastIndexOf('e');
System.out.println(myString + ':' + i); //the Java compiler will use a StringBuilder internally here [builder.append(':')]
...
return myString.replace('m','z');
}
</code></pre>
</p>
]]>
</Details>
</BugPattern>
<BugPattern type="TR_TAIL_RECURSION">
<ShortDescription>Method employs tail recursion</ShortDescription>
<LongDescription>Method {1} employs tail recursion</LongDescription>
<Details>
<![CDATA[
<p>This method recursively calls itself as the last statement of the method
(Tail Recursion). This method can be easily refactored into a simple loop, which
will make it more performant, and reduce the stack size requirements.</p>
]]>
</Details>
</BugPattern>
<BugPattern type="URV_UNRELATED_RETURN_VALUES">
<ShortDescription>Method returns different types of unrelated Objects</ShortDescription>
<LongDescription>Method {1} returns different types of unrelated Objects</LongDescription>
<Details>
<![CDATA[
<p>This method returns two or more unrelated types of objects (Related only through java.lang.Object).
This will be very confusing to the code that must call it.</p>
]]>
</Details>
</BugPattern>
<BugPattern type="URV_CHANGE_RETURN_TYPE">
<ShortDescription>Method returns more specific type of object than declared</ShortDescription>
<LongDescription>Method {1} returns more specific type of object than declared</LongDescription>
<Details>
<![CDATA[
<p>This method is defined to return a java.lang.Object. However, the return types
returned from this method can be defined by a more specific class or interface. Since this
method is not derived from a superclass or interface, it would be more clear to
change the return type of this method.</p>
]]>
</Details>
</BugPattern>
<BugPattern type="URV_INHERITED_METHOD_WITH_RELATED_TYPES">
<ShortDescription>Inherited method returns more specific type of object than declared</ShortDescription>
<LongDescription>Inherited method {1} returns more specific type of object than declared</LongDescription>
<Details>
<![CDATA[
<p>This inherited method is defined to return a java.lang.Object. However, the return types returned
from this method can be defined by a more specific class or interface. If possible consider changing the
return type in the inheritance hierarchy of this method, otherwise the caller of this method will be brittle
in handling of the return type.</p>
]]>
</Details>
</BugPattern>
<BugPattern type="PIS_POSSIBLE_INCOMPLETE_SERIALIZATION">
<ShortDescription>Class doesn't serialize superclass fields</ShortDescription>
<LongDescription>Class {0} doesn't serialize superclass fields</LongDescription>
<Details>
<![CDATA[
<p>This method implements Serializable but is derived from a
class that does not. The superclass has fields that are not serialized
because this class does not take the responsibility of writing these fields out
either using Serializable's writeObject method, or Externalizable's writeExternal
method. Therefore when this class is read from a stream, the superclass fields
will only be initialized to the values specified in its default constructor.
If possible, change the superclass to implement Serializable, or implement
Serializable or Externalizable methods in the child class.</p>
]]>
</Details>
</BugPattern>
<BugPattern type="SCRV_SUSPICIOUS_COMPARATOR_RETURN_VALUES">
<ShortDescription>Comparator method doesn't seem to return all ordering values</ShortDescription>
<LongDescription>Comparator method {1} doesn't seem to return all ordering values</LongDescription>
<Details>
<![CDATA[
<p>This compareTo or compare method returns constant values to represent less than,
equals, and greater than. However, it does not return each type, or it unconditionally returns a non zero value.
Given that comparators are transitive, this seems incorrect.</p>
]]>
</Details>
</BugPattern>
<BugPattern type="SPP_NEGATIVE_BITSET_ITEM">
<ShortDescription>Method passes a negative number as a bit to a BitSet which isn't supported</ShortDescription>
<LongDescription>Method {1} passes a negative number as a bit to a BitSet which isn't supported</LongDescription>
<Details>
<![CDATA[
<p>This method passes a constant negative value as a bit position to a java.util.BitSet. The BitSet class
doesn't support negative values, and thus this method call will not work as expected.</p>
]]>
</Details>
</BugPattern>
<BugPattern type="SPP_INTERN_ON_CONSTANT">
<ShortDescription>Method calls intern on a string constant</ShortDescription>
<LongDescription>Method {1} calls intern on a string constant</LongDescription>
<Details>
<![CDATA[
<p>This method calls intern on a constant string. As constant strings are already interned, this call
is superfluous.</p>
]]>
</Details>
</BugPattern>
<BugPattern type="SPP_NO_CHAR_SB_CTOR">
<ShortDescription>Method appears to pass character to StringBuffer or StringBuilder integer constructor</ShortDescription>
<LongDescription>Method {1} appears to pass character to StringBuffer or StringBuilder integer constructor</LongDescription>
<Details>
<![CDATA[
<p>This method constructs a StringBuffer or a StringBuilder using the constructor that takes an integer, but
appears to pass a character instead. It is probable that the author assumed that character would be appended to the
StringBuffer/Builder, but instead the integer value of the character is used as an initial size for the buffer.</p>
]]>
</Details>
</BugPattern>
<BugPattern type="SPP_USE_MATH_CONSTANT">
<ShortDescription>Method uses non standard math constant</ShortDescription>
<LongDescription>Method {1} uses non standard math constant</LongDescription>
<Details>
<![CDATA[
<p>This method defines its own version of <em>PI</em> or <em>e</em> and the value is not as precise as the
one defined in the constants Math.PI or Math.E. Use these constants instead.</p>
]]>
</Details>
</BugPattern>
<BugPattern type="SPP_STUTTERED_ASSIGNMENT">
<ShortDescription>Method assigns a value to a local twice in a row</ShortDescription>
<LongDescription>Method {1} assigns a value to a local twice in a row</LongDescription>
<Details>
<![CDATA[
<p>This method assigns a value twice in a row in a stuttered way such as
<code>a = a = 5;</code> This is most probably a cut and paste error where the duplicate
assignment can be removed.</p>
]]>
</Details>
</BugPattern>
<BugPattern type="SPP_USE_ISNAN">
<ShortDescription>Method incorrectly compares a floating point number to NaN</ShortDescription>
<LongDescription>Method {1} compares a {3} to {4}.NaN</LongDescription>
<Details>
<![CDATA[
<p>This method compares a double or float to the constant <code>Double.NaN</code> or <code>Float.NaN</code>.
You should use
<code>Double.isNaN(d)</code> or <code>Float.isNaN(f)</code>
if the variable is a primitive. If using a boxed primitive <code>d.isNaN()</code> or <code>f.isNaN()</code> should be used.</p>
]]>
</Details>
</BugPattern>
<BugPattern type="SPP_USE_BIGDECIMAL_STRING_CTOR">
<ShortDescription>Method passes double value to BigDecimal Constructor</ShortDescription>
<LongDescription>Method {1} passes double value to BigDecimal Constructor</LongDescription>
<Details>
<![CDATA[
<p>This method calls the BigDecimal constructor that takes a double, and passes a literal double constant value. Since
the use of BigDecimal is to get better precision than double, by passing a double, you only get the precision of double number
space. To take advantage of the BigDecimal space, pass the number as a string. </p>
]]>
</Details>
</BugPattern>
<BugPattern type="SPP_STRINGBUFFER_WITH_EMPTY_STRING">
<ShortDescription>Method passes an empty string to StringBuffer of StringBuilder constructor</ShortDescription>
<LongDescription>Method {1} passes an empty string to StringBuffer of StringBuilder constructor</LongDescription>
<Details>
<![CDATA[
<p>This method calls the StringBuffer or StringBuilder constructor passing in a constant empty string ("").
This is the same as calling the default constructor, but makes the code work harder. Consider passing in a
default size instead.</p>
]]>
</Details>
</BugPattern>
<BugPattern type="SPP_EQUALS_ON_ENUM">
<ShortDescription>Method calls equals on an enum instance</ShortDescription>
<LongDescription>Method {1} calls equals on an enum instance</LongDescription>
<Details>
<![CDATA[
<p>This method calls the equals(Object) method on an enum instance. Since enums values are singletons,
you can use == to safely compare two enum values. In fact, the implementation for Enum.equals does just
that.</p>
]]>
</Details>
</BugPattern>
<BugPattern type="SPP_INVALID_BOOLEAN_NULL_CHECK">
<ShortDescription>Method uses invalid C++ style null check on Boolean</ShortDescription>
<LongDescription>Method {1} uses invalid C++ style null check on Boolean</LongDescription>
<Details>
<![CDATA[
<p>This method attempts to check for null by just referring to the variable name
as would be done in C++. This ordinarily would be considered a compile error, except the
variable in question is a Boolean, which does an auto unbox to boolean.
<pre><code>
if (b && b.booleanValue())
</code></pre>
should be<br/>
<pre><code>
if ((b != null) && b.booleanValue())
</code></pre>
</p>
]]>
</Details>
</BugPattern>
<BugPattern type="SPP_USE_CHARAT">
<ShortDescription>Method fetches character array just to do the equivalent of the charAt method</ShortDescription>
<LongDescription>Method {1} fetches character array just to do the equivalent of the charAt method</LongDescription>
<Details>
<![CDATA[
<p>This method calls the toCharArray method on a String to fetch an array of characters, only
to retrieve one of those characters by index. It is more performant to just use the charAt method.</p>
]]>
</Details>
</BugPattern>
<BugPattern type="SPP_USELESS_TERNARY">
<ShortDescription>Method uses a ternary operator to cast a boolean to true or false</ShortDescription>
<LongDescription>Method {1} uses a ternary operator to cast a boolean to true or false</LongDescription>
<Details>
<![CDATA[
<p>This method tests the value of a boolean and using a ternary operator to return either true or false.
The ternary operator is completely unnecessary, just use the original boolean value.</p>
]]>
</Details>
</BugPattern>
<BugPattern type="SPP_SUSPECT_STRING_TEST">
<ShortDescription>Method possibly mixes up normal strings and empty strings in branching logic</ShortDescription>
<LongDescription>Method {1} treats null and normal strings the same, when it should probably
treat null and empty strings the same</LongDescription>
<Details>
<![CDATA[
<p>This method tests a string, and groups null values with real strings, leaving empty strings as another
case. That is, FindBugs has detected a structure like: <br/>
<pre><code>
String a = null, b = "", c = "someString";
String testStr = ...; //one of a, b or c
if ({{FLAWED_TEST_LOGIC}}) {
// Strings a and c fall into this branch... which is not typical.
} else {
// String b falls into this branch.
}
</code></pre>
This might be perfectly valid, but normally, null strings and empty strings are logically handled the same way,
and so this test may be flawed.</p>
<p>Pattern found is one of the following:
<ul>
<li><code>if ((s == null) || (s.length() &gt; 0))</code> --- did you mean
<code>((s == null) || (s.length() == 0))</code>?</li>
<li><code>if ((s == null) || (s.length() != 0))</code> -- did you mean
<code>((s == null) || (s.length() == 0))</code>? </li>
<li><code>if ((s != null) && (s.length() == 0))</code> -- did you mean
<code>((s != null) && (s.length() &gt; 0))</code> or perhaps
<code>((s == null) || (s.length() == 0))</code>? </li>
</ul>
</p>
]]>
</Details>
</BugPattern>
<BugPattern type="SPP_USE_STRINGBUILDER_LENGTH">
<ShortDescription>Method converts StringBuffer or Builder to String just to get its length</ShortDescription>
<LongDescription>Method {1} converts StringBuffer or Builder to String just to get its length</LongDescription>
<Details>
<![CDATA[
<p>This method calls the toString method on a StringBuffer or StringBuilder only to call length() on the resulting
string. It is faster, and less memory intensive to just call the length method directly on the StringBuffer or StringBuilder
itself.</p>
]]>
</Details>
</BugPattern>
<BugPattern type="SPP_INVALID_CALENDAR_COMPARE">
<ShortDescription>Method passes a non calendar object to Calendar.before or Calendar.after</ShortDescription>
<LongDescription>Method {1} passes a non calendar object to Calendar.before or Calendar.after</LongDescription>
<Details>
<![CDATA[
<p>This method passes a non calendar object to the java.util.Calendar.after or java.util.Calendar.before methods.
Even though these methods take an Object as a parameter type, only Calendar type objects are supported, otherwise
false is returned.</p>
]]>
</Details>
</BugPattern>
<BugPattern type="SPP_USE_CONTAINSKEY">
<ShortDescription>Method calls keySet() just to call contains, use containsKey instead</ShortDescription>
<LongDescription>Method {1} calls keySet() just to call contains, use containsKey instead</LongDescription>
<Details>
<![CDATA[
<p>This method calls mySet.keySet().contains("foo") when mySet.containsKey("foo") is simpler.</p>
]]>
</Details>
</BugPattern>
<BugPattern type="SPP_USE_ISEMPTY">
<ShortDescription>Method checks the size of a collection against zero rather than using isEmpty()</ShortDescription>
<LongDescription>Method {1} checks the size of a collection against zero rather than using isEmpty()</LongDescription>
<Details>
<![CDATA[
<p>This method calls the size() method on a collection and compares the result to zero to see if the collection
is empty. For better code clarity, it is better to just use col.isEmpty() or !col.isEmpty().</p>
]]>
</Details>
</BugPattern>
<BugPattern type="SPP_USE_GETPROPERTY">
<ShortDescription>Method calls getProperties just to get one property, use getProperty instead</ShortDescription>
<LongDescription>Method {1} calls getProperties just to get one property, use getProperty instead</LongDescription>
<Details>
<![CDATA[
<table>
<tr><td>This method uses</td></tr>
<tr><td>String prop = System.getProperties().getProperty("foo");</td></tr>
<tr><td>instead of simply using</td></tr>
<tr><td>String prop = System.getProperty("foo");</td></tr>
</table>
]]>
</Details>
</BugPattern>
<BugPattern type="SPP_SERIALVER_SHOULD_BE_PRIVATE">
<ShortDescription>Class defines a serialVersionUID as non private</ShortDescription>
<LongDescription>Class {0} defines a serialVersionUID as non private</LongDescription>
<Details>
<![CDATA[
<p>This class defines a static field 'serialVersionUID' to define the serialization
version for this class. This field is marked as non private. As the serialVersionUID only
controls the current class, and doesn't affect any derived classes, defining it as non
private is confusing. It is suggested you change this variable to be private.</p>
]]>
</Details>
</BugPattern>
<BugPattern type="SPP_USELESS_CASING">
<ShortDescription>Method compares string without case after enforcing a case</ShortDescription>
<LongDescription>Method {1} compares string without case after enforcing a case</LongDescription>
<Details>
<![CDATA[
<p>This method compares two strings with compareToIgnoreCase or equalsIgnoreCase, after having
called toUpperCase or toLowerCase on the string in question. As you are comparing without
concern to case, the toUpperCase or toLowerCase calls are pointless and can be removed.</p>
]]>
</Details>
</BugPattern>
<BugPattern type="SPP_NON_ARRAY_PARM">
<ShortDescription>Method passes a non array object to a parameter that expects an array</ShortDescription>
<LongDescription>Method {1} passes a non array object to a parameter that expects an array</LongDescription>
<Details>
<![CDATA[
<p>This method expects an array to be passed as one of its parameters, but unfortunately defines
the parameter as Object. This invocation of this method does not pass an array and will throw
an exception when run.</p>
]]>
</Details>
</BugPattern>
<BugPattern type="SPP_EMPTY_CASING">
<ShortDescription>Method passes an empty string to equalsIgnoreCase or compareToIgnoreCase</ShortDescription>
<LongDescription>Method {1} passes an empty string to equalsIgnoreCase or compareToIgnoreCase</LongDescription>
<Details>
<![CDATA[
<p>This method passes the empty string "" to equalsIgnoreCase or compareToIgnoreCase. As the empty string
is not case-sensitive, using equals is simpler. It would be even simpler to do a length() == 0 test.</p>
]]>
</Details>
</BugPattern>
<BugPattern type="SPP_TEMPORARY_TRIM">
<ShortDescription>Method trims a String temporarily</ShortDescription>
<LongDescription>Method {1} trims a String temporarily</LongDescription>
<Details>
<![CDATA[
<p>This method calls trim() on a String without assigning the new string to another variable.
It then calls length() or equals() on this trimmed string. If trimming the string was important
for determining its length or its equality, it should be trimmed when you actually go to use it.
It would make more sense to first trim the String, store the trimmed value in a variable, and then
continue to test and use that trimmed string.</p>
]]>
</Details>
</BugPattern>
<BugPattern type="SPP_STRINGBUILDER_IS_MUTABLE">
<ShortDescription>Method needlessly assigns a StringBuilder to itself, as it's mutable</ShortDescription>
<LongDescription>Method {1} needlessly assigns a StringBuilder to itself, as it's mutable</LongDescription>
<Details>
<![CDATA[
<p>This method calls StringBuilder.append and assigns the results to the same StringBuilder like:</p>
<code>sb = sb.append("foo")</code>
<p>StringBuilder is mutable, so this is not necessary.
This is also true of StringBuffer.</p>
]]>
</Details>
</BugPattern>
<BugPattern type="SPP_USE_GET0">
<ShortDescription>Method uses iterator().next() on a List to get the first item</ShortDescription>
<LongDescription>Method {1} uses iterator().next() on a List to get the first item</LongDescription>
<Details>
<![CDATA[
<p>This method calls myList.iterator().next() on a List to get the first item. It is more performant
to just use myList.get(0).</p>
]]>
</Details>
</BugPattern>
<BugPattern type="SPP_DOUBLE_APPENDED_LITERALS">
<ShortDescription>Method appends two literal strings back to back to a StringBuilder</ShortDescription>
<LongDescription>Method {1} appends two literal strings back to back to a StringBuilder</LongDescription>
<Details>
<![CDATA[
<p>This method appends two literal strings to a <code>StringBuilder</code> back to back.
Modern compilers will optimize something like:<br/>
<pre><code>
public static final string CONST_VAL = "there";
...
String str = "Hello" + " "+ CONST_VAL + " " +"world!";
</code></pre>
to: <br/>
<pre><code>
public static final string CONST_VAL = "there";
...
String str = "Hello there world!";
</code></pre>
This means the concatenation is done during compile time, not at runtime, so there's <b>no need</b> to do: <br/>
<pre><code>
public static final string CONST_VAL = "there";
...
StringBuilder sb = new StringBuilder("Hello").append(" ").append(CONST_VAL).append(" ").append("world!");
String str = sb.toString();
</code></pre>
which is harder to read and will result in more complex bytecode.
</p>
<p>
Simply append your constants with the "+" symbol, don't append them with <code>StringBuilder.append()</code>.
</p>
]]>
</Details>
</BugPattern>
<BugPattern type="SPP_NULL_BEFORE_INSTANCEOF">
<ShortDescription>Method checks a reference for null before calling instanceof</ShortDescription>
<LongDescription>Method {1} checks a reference for null before calling instanceof</LongDescription>
<Details>
<![CDATA[
<p>This method checks a reference for null just before seeing if the reference is an instanceof some class.
Since instanceof will return false for null references, the null check is not needed.</p>
]]>
</Details>
</BugPattern>
<BugPattern type="SPP_NON_USEFUL_TOSTRING">
<ShortDescription>Method calls toString() on an instance of a class that hasn't overridden toString()</ShortDescription>
<LongDescription>Method {1} calls toString() on an instance of a class that hasn't overridden toString()</LongDescription>
<Details>
<![CDATA[
<p>This method calls toString() on an object that hasn't overridden the toString() method, and thus relies on
the version found in java.lang.Object. This string is just a raw display of the object's class and location, and
provides no information about the information of use. You should implement toString in this class.</p>
]]>
</Details>
</BugPattern>
<BugPattern type="SPP_TOSTRING_ON_STRING">
<ShortDescription>Method calls toString() on a String</ShortDescription>
<LongDescription>Method {1} calls toString() on a String</LongDescription>
<Details>
<![CDATA[
<p>This method calls toString on a String. Just use the object itself if you want a String.</p>
]]>
</Details>
</BugPattern>
<BugPattern type="SPP_CONVERSION_OF_STRING_LITERAL">
<ShortDescription>Method converts a String literal</ShortDescription>
<LongDescription>Method {1} calls {3} on a String Literal</LongDescription>
<Details>
<![CDATA[
<p>This method calls a converting method like <code>toLowerCase()</code> or <code>trim</code>
on a <code>String</code> literal. You should make the transformation yourself and use the transformed literal.</p>
<p>
For example, instead of :<br/>
<pre><code>
return "ThisIsAConstantString".toLowerCase().trim();
</code></pre>
just do <br/>
<pre><code>
return "thisisaconstantstring";
</code></pre>
for shorter and easier to read code. An exception might be made when locale-specific transformations need
to be done (in the case of <code>toUpperCase()</code> and <code>toLowerCase()</code>.
</p>
]]>
</Details>
</BugPattern>
<BugPattern type="SPP_EQUALS_ON_STRING_BUILDER">
<ShortDescription>Method calls equals(Object o) on a StringBuilder or StringBuffer</ShortDescription>
<LongDescription>Method {1} calls equals(Object o) on a StringBuilder or StringBuffer</LongDescription>
<Details>
<![CDATA[
<p>This method calls equals on a StringBuilder or StringBuffer. Surprisingly, these classes do not override
the equals method from Object, and so equals is just defined to be == (or same references). This is most
likely not what you would like. If you wish to check that the strings have the same characters, you need to
call toString() on these object and compare them as Strings.</p>
]]>
</Details>
</BugPattern>
<BugPattern type="SPP_STATIC_FORMAT_STRING">
<ShortDescription>Method calls String.format on a static (non parameterized) format string</ShortDescription>
<LongDescription>Method {1} calls String.format on a static (non parameterized) format string</LongDescription>
<Details>
<![CDATA[
<p>This method calls String.format passing a static string as the format string that has no replacement markers
(starting with %). Thus no replacement will happen, and the format method is superfluous. If parameters were intended,
add the appropriate format markers as needed; otherwise, just remove the call to String.format and use the static
string as is.</p>
]]>
</Details>
</BugPattern>
<BugPattern type="SPP_NULL_CHECK_ON_OPTIONAL">
<ShortDescription>Method checks an Optional reference for null or non nullness</ShortDescription>
<LongDescription>Method {1} checks an Optional reference for null or non nullness</LongDescription>
<Details>
<![CDATA[
This method uses an Optional variable, and checks the reference value for whether it is null or not null.
Since the point of the Optional class is to avoid 'the null reference problem', having code that needs to
check the reference itself is self defeating, and therefore makes the use of the Optional variable useless.
You should never use a variable of type Optional that has a value of null, and so there should be no need to
check for it.
]]>
</Details>
</BugPattern>
<BugPattern type="SPP_WRONG_COMMONS_TO_STRING_OBJECT">
<ShortDescription>Method does not pass an object to commons-lang's ToStringBuilder</ShortDescription>
<LongDescription>Method {1} does not pass an object to commons-lang's ToStringBuilder</LongDescription>
<Details>
<![CDATA[
This method uses commons-lang, or commons-lang3's ToStringBuilder to attempt to output a representation of an object.
However, no object was passed, just the style specifier, and so the output will be of the ToStringStyle object itself.
Don't forget to include the object you wish to output as the first parameter, such as
<pre>
ToStringBuilder.reflectionToString(this, ToStringStyle.SHORT_PREFIX_STYLE);
</pre>
]]>
</Details>
</BugPattern>
<BugPattern type="SPP_NULL_CHECK_ON_MAP_SUBSET_ACCESSOR">
<ShortDescription>Method checks whether the keySet(), entrySet() or values() collection of a Map is null</ShortDescription>
<LongDescription>Method {1} checks whether the keySet(), entrySet() or values() collection of a Map is null</LongDescription>
<Details>
<![CDATA[
This method checks to see if the return value from a keySet(), entrySet() or values() method call on a Map is null.
For any valid functioning Map these collections will always be non-null, and so the call is superfluous. Maybe you intended
to check whether those sets where empty() instead.
]]>
</Details>
</BugPattern>
<BugPattern type="BAS_BLOATED_ASSIGNMENT_SCOPE">
<ShortDescription>Method assigns a variable in a larger scope than is needed</ShortDescription>
<LongDescription>Method {1} assigns a variable in a larger scope than is needed</LongDescription>
<Details>
<![CDATA[
<p><em>THIS DETECTOR IS HIGHLY EXPERIMENTAL AND IS LIKELY TO CREATE A LOT OF FUD</em></p>
<p>This method assigns a value to a variable in an outer scope compared to where the variable is actually used.
Assuming this evaluation does not have side effects, the assignment can be moved into the inner scope (if block)
so that its execution time isn't taken up if the if guard is false. Care should be
taken, however, that the right hand side of the assignment does not contain side
effects that are required to happen, and that changes are not made further down that
will affect the execution of the assignment when done later on.</p>
]]>
</Details>
</BugPattern>
<BugPattern type="SCII_SPOILED_CHILD_INTERFACE_IMPLEMENTOR">
<ShortDescription>Class implements interface by relying on unknowing superclass methods</ShortDescription>
<LongDescription>Class {0} implements interface by relying on unknowing superclass methods</LongDescription>
<Details>
<![CDATA[
<p>This class declares that it implements an interface, but does so by relying on methods supplied
by superclasses, even though those superclasses know nothing about the interface in question. If you wish
to have the child not implement all the methods of the interface, it would probably be better to declare
the superclass as implementing the interface, and if that class does not provide all the methods, then declare
that superclass abstract.</p>
]]>
</Details>
</BugPattern>
<BugPattern type="DWI_DELETING_WHILE_ITERATING">
<ShortDescription>Method deletes collection element while iterating</ShortDescription>
<LongDescription>Method {1} deletes collection element while iterating</LongDescription>
<Details>
<![CDATA[
<p>This method removes items from a collection using the remove method of the collection, while
at the same time iterating across the collection. Doing this will invalidate the iterator, and further
use of it will cause ConcurrentModificationExceptions to be thrown. To avoid this, the remove
method of the iterator should be used.</p>
]]>
</Details>
</BugPattern>
<BugPattern type="DWI_MODIFYING_WHILE_ITERATING">
<ShortDescription>Method modifies collection element while iterating</ShortDescription>
<LongDescription>Method {1} modifies collection element while iterating</LongDescription>
<Details>
<![CDATA[
<p>This method modifies the contents of a collection using the collection API methods, while
at the same time iterating across the collection. Doing this will invalidate the iterator, and further
use of it will cause ConcurrentModificationExceptions to be thrown.</p>
]]>
</Details>
</BugPattern>
<BugPattern type="USS_USE_STRING_SPLIT">
<ShortDescription>Method builds String array using String Tokenizing</ShortDescription>
<LongDescription>Method {1} builds String array using String Tokenizing</LongDescription>
<Details>
<![CDATA[
<p>This method uses a StringTokenizer to split up a String and then walks through the
separated elements and builds an array from these enumerated values. It is simpler
and easier to use the String.split method.</p>
<p>PLEASE NOTE: String.split will return an array of 1 element when passed the
empty string, as opposed to using StringTokenizer which returns false on the first
hasMoreElements/hasMoreTokens call. So you may need to use:</p>
<pre><code>
if (s.length() &gt; 0) <br/>
return s.split(";");<br/>
return new String[0];<br/>
</code></pre>
]]>
</Details>
</BugPattern>
<BugPattern type="SJVU_SUSPICIOUS_JDK_VERSION_USE">
<ShortDescription>Method uses rt.jar class or method that does not exist</ShortDescription>
<LongDescription>Method {1} uses rt.jar class or method that does not exist for the version the class is compiled for</LongDescription>
<Details>
<![CDATA[
<p>This method calls a method that does not exist, on a class that does not exist in the JDK that
this class has been compiled for. This can happen if you compile the class specifying the -source and
-target options, and use a version that is before the version of the compiler's JDK.</p>
]]>
</Details>
</BugPattern>
<BugPattern type="UAA_USE_ADD_ALL">
<ShortDescription>Method uses simple loop to copy contents of one collection to another</ShortDescription>
<LongDescription>Method {1} uses simple loop to copy contents of one collection to another</LongDescription>
<Details>
<![CDATA[
<p>This method uses a simple for loop to copy the contents of a set, list, map key/value, array or other collection
to another collection. It is simpler and more straight forward to just call the addAll method of the destination collection
passing in the source collection. In the case that the source is an array, you can use Array.asList method to massage the array
into a collection.</p>
]]>
</Details>
</BugPattern>
<BugPattern type="MRC_METHOD_RETURNS_CONSTANT">
<ShortDescription>Private or static method only returns one constant value</ShortDescription>
<LongDescription>Private or static method {1} only returns one constant value</LongDescription>
<Details>
<![CDATA[
<p>This private or static method only returns one constant value. As this method is private or static,
its behavior can't be overridden, and thus the return of a constant value seems dubious.
Either the method should be changed to return no value, or perhaps another return value
was expected to be returned in another code path in this method.</p>
]]>
</Details>
</BugPattern>
<BugPattern type="NCS_NEEDLESS_CUSTOM_SERIALIZATION">
<ShortDescription>Method needlessly implements what is default streaming behavior</ShortDescription>
<LongDescription>Method {1} needlessly implements what is default streaming behavior</LongDescription>
<Details>
<![CDATA[
<p>This method implements the Serializable interface by performing the same operations that
would be done if this method did not exist. Since this is the case, this method is not needed.</p>
]]>
</Details>
</BugPattern>
<BugPattern type="MOM_MISLEADING_OVERLOAD_MODEL">
<ShortDescription>Class 'overloads' a method with both instance and static versions</ShortDescription>
<LongDescription>Class {0} 'overloads' a method with both instance and static versions</LongDescription>
<Details>
<![CDATA[
<p>This class 'overloads' the same method with both an instance and static version. As the use
of these two models is different, it will be confusing to the users of these methods.</p>
]]>
</Details>
</BugPattern>
<BugPattern type="EXS_EXCEPTION_SOFTENING_NO_CONSTRAINTS">
<ShortDescription>Unconstrained method converts checked exception to unchecked</ShortDescription>
<LongDescription>Unconstrained method {1} converts checked exception to unchecked</LongDescription>
<Details>
<![CDATA[
<p>This method is not constrained by an interface or superclass, but converts a caught checked exception
to unchecked exception and thrown. It would be more appropriate just to throw the checked exception, adding
the exception to the throws clause of the method.</p>
]]>
</Details>
</BugPattern>
<BugPattern type="EXS_EXCEPTION_SOFTENING_HAS_CHECKED">
<ShortDescription>Constrained method converts checked exception to unchecked instead of another allowable checked exception</ShortDescription>
<LongDescription>Constrained method {1} converts checked exception to unchecked instead of another allowable checked exception</LongDescription>
<Details>
<![CDATA[
<p>This method's exception signature is constrained by an interface of superclass not to throw a
checked exception that was caught. Therefore this exception was converted to an unchecked exception and
thrown. It would probably be better to throw the closest checked exception allowed, and to annotate
the new exception with the original exception using the initial cause field.</p>
]]>
</Details>
</BugPattern>
<BugPattern type="EXS_EXCEPTION_SOFTENING_NO_CHECKED">
<ShortDescription>Constrained method converts checked exception to unchecked</ShortDescription>
<LongDescription>Constrained method {1} converts checked exception to unchecked</LongDescription>
<Details>
<![CDATA[
<p>This method's exception signature is constrained by an interface or superclass not to throw
any checked exceptions. Therefore a caught checked exception was converted to an unchecked exception
and thrown. However, it appears that the class in question is owned by the same author as the constraining
interface or superclass. Consider changing the signature of this method to include the checked exception.</p>
]]>
</Details>
</BugPattern>
<BugPattern type="EXS_EXCEPTION_SOFTENING_RETURN_FALSE">
<ShortDescription>method converts an exception into a boolean 'error code' value</ShortDescription>
<LongDescription>method {1} converts an exception into a boolean 'error code' value</LongDescription>
<Details>
<![CDATA[
<p>This method catches an exception and returns a boolean that represents whether an exception occurred or not.
This throws away the value of exception handling and lets code ignore the resultant 'error code' return value.
You should just throw the exception to the caller instead.</p>
]]>
</Details>
</BugPattern>
<BugPattern type="CFS_CONFUSING_FUNCTION_SEMANTICS">
<ShortDescription>Method returns modified parameter</<