Project:
FindBugs version: 2.0.1-rc3
Code analyzed:
78222 lines of code analyzed, in 792 classes, in 15 packages.
| Metric | Total | Density* |
|---|---|---|
| High Priority Warnings | 1 | 0.01 |
| Medium Priority Warnings | 37 | 0.47 |
| Total Warnings | 38 | 0.49 |
(* Defects per Thousand lines of non-commenting source statements)
| Warning Type | Number |
|---|---|
| Bad practice Warnings | 11 |
| Correctness Warnings | 1 |
| Malicious code vulnerability Warnings | 10 |
| Performance Warnings | 1 |
| Dodgy code Warnings | 15 |
| Total | 38 |
Click on a warning row to see full context information.
| Code | Warning |
|---|---|
| Nm | The class name edu.jas.application.FactorFactory shadows the simple name of the superclass edu.jas.ufd.FactorFactory |
| RV | edu.jas.poly.PolynomialComparator.compare(GenPolynomial, GenPolynomial) negates the return value of edu.jas.poly.GenPolynomial.compareTo(GenPolynomial) |
| RV | edu.jas.poly.TermOrder$69.compare(ExpVector, ExpVector) negates the return value of edu.jas.poly.TermOrder$EVComparator.compare(ExpVector, ExpVector) |
| RV | edu.jas.poly.TermOrder$9.compare(ExpVector, ExpVector) negates the return value of edu.jas.poly.TermOrder$EVComparator.compare(ExpVector, ExpVector) |
| SnVI | edu.jas.gb.GBProxy is Serializable; consider declaring a serialVersionUID |
| SnVI | edu.jas.gb.GroebnerBaseDistributed is Serializable; consider declaring a serialVersionUID |
| SnVI | edu.jas.gb.GroebnerBaseDistributedHybrid is Serializable; consider declaring a serialVersionUID |
| SnVI | edu.jas.gb.GroebnerBaseParallel is Serializable; consider declaring a serialVersionUID |
| SnVI | edu.jas.gb.GroebnerBaseSeqPairDistributed is Serializable; consider declaring a serialVersionUID |
| SnVI | edu.jas.gb.GroebnerBaseSeqPairParallel is Serializable; consider declaring a serialVersionUID |
| SnVI | edu.jas.ufd.GCDProxy is Serializable; consider declaring a serialVersionUID |
| Code | Warning |
|---|---|
| SA | Self comparison of $L0 with itself edu.jas.ps.Examples.example11() |
| Code | Warning |
|---|---|
| EI | edu.jas.poly.GenPolynomialRing.getVars() may expose internal representation by returning GenPolynomialRing.vars |
| EI | edu.jas.poly.TermOrder.getWeight() may expose internal representation by returning TermOrder.weight |
| EI | edu.jas.ps.MultiVarPowerSeriesRing.getVars() may expose internal representation by returning MultiVarPowerSeriesRing.vars |
| EI2 | new edu.jas.application.Dimension(int, Set, Set, String[]) may expose internal representation by storing an externally mutable object into Dimension.v |
| EI2 | new edu.jas.poly.ExpVectorLong(long[]) may expose internal representation by storing an externally mutable object into ExpVectorLong.val |
| EI2 | new edu.jas.poly.GenPolynomialRing(RingFactory, int, TermOrder, String[]) may expose internal representation by storing an externally mutable object into GenPolynomialRing.vars |
| EI2 | edu.jas.poly.GenPolynomialRing.setVars(String[]) may expose internal representation by storing an externally mutable object into GenPolynomialRing.vars |
| EI2 | new edu.jas.poly.TermOrder(long[][]) may expose internal representation by storing an externally mutable object into TermOrder.weight |
| EI2 | new edu.jas.ps.MultiVarPowerSeriesRing(RingFactory, int, int, String[]) may expose internal representation by storing an externally mutable object into MultiVarPowerSeriesRing.vars |
| MS | edu.jas.kern.ComputerThreads.NO_THREADS isn't final and can't be protected from malicious code |
| Code | Warning |
|---|---|
| WMI | edu.jas.gb.OrderedSyzPairlist.put(GenPolynomial) makes inefficient use of keySet iterator instead of entrySet iterator |
| Code | Warning |
|---|---|
| DB | edu.jas.application.RingFactoryTokenizer.nextCoefficientRing() uses the same code for two branches |
| DB | edu.jas.poly.GenPolynomialTokenizer.nextCoefficientRing() uses the same code for two branches |
| DLS | Dead store to $L5 in edu.jas.poly.ExpVector.subst(int, long) |
| DLS | Dead store to $L4 in edu.jas.poly.ExpVectorByte.subst(int, byte) |
| DLS | Dead store to $L5 in edu.jas.poly.ExpVectorByte.subst(int, long) |
| DLS | Dead store to $L4 in edu.jas.poly.ExpVectorInteger.subst(int, int) |
| DLS | Dead store to $L5 in edu.jas.poly.ExpVectorInteger.subst(int, long) |
| DLS | Dead store to $L5 in edu.jas.poly.ExpVectorLong.subst(int, long) |
| DLS | Dead store to $L5 in edu.jas.poly.ExpVectorShort.subst(int, long) |
| DLS | Dead store to $L4 in edu.jas.poly.ExpVectorShort.subst(int, short) |
| DLS | Dead store to $L1 in edu.jas.ps.MultiVarPowerSeries.orderExpVector() |
| DLS | Dead store to $L14 in edu.jas.ufd.FactorAbsolute.factorsAbsoluteIrreducible(GenPolynomial) |
| DLS | Dead store to $L4 in new edu.jas.util.CartesianTwoProductInfiniteIterator(Iterable, Iterable) |
| DLS | Dead store to $L4 in new edu.jas.util.CartesianTwoProductInfiniteIteratorList(Iterable, Iterable) |
| SF | Switch statement found in edu.jas.poly.GenPolynomialTokenizer.nextPolynomial() where one case falls through to the next case |
This method uses the same code to implement two branches of a conditional branch. Check to ensure that this isn't a coding mistake.
This instruction assigns a value to a local variable, but the value is not read or used in any subsequent instruction. Often, this indicates an error, because the value computed is never used.
Note that Sun's javac compiler often generates dead stores for final local variables. Because FindBugs is a bytecode-based tool, there is no easy way to eliminate these false positives.
Returning a reference to a mutable object value stored in one of the object's fields exposes the internal representation of the object. If instances are accessed by untrusted code, and unchecked changes to the mutable object would compromise security or other important properties, you will need to do something different. Returning a new copy of the object is better approach in many situations.
This code stores a reference to an externally mutable object into the internal representation of the object. If instances are accessed by untrusted code, and unchecked changes to the mutable object would compromise security or other important properties, you will need to do something different. Storing a copy of the object is better approach in many situations.
A mutable static field could be changed by malicious code or by accident from another package. Unfortunately, the way the field is used doesn't allow any easy fix to this problem.
This class has a simple name that is identical to that of its superclass, except
that its superclass is in a different package (e.g., alpha.Foo extends beta.Foo).
This can be exceptionally confusing, create lots of situations in which you have to look at import statements
to resolve references and creates many
opportunities to accidently define methods that do not override methods in their superclasses.
This code negatives the return value of a compareTo or compare method. This is a questionable or bad programming practice, since if the return value is Integer.MIN_VALUE, negating the return value won't negate the sign of the result. You can achieve the same intended result by reversing the order of the operands rather than by negating the results.
This method compares a local variable with itself, and may indicate a typo or a logic error. Make sure that you are comparing the right things.
This method contains a switch statement where one case branch will fall through to the next case. Usually you need to end this case with a break or return.
This class implements the Serializable interface, but does
not define a serialVersionUID field.
A change as simple as adding a reference to a .class object
will add synthetic fields to the class,
which will unfortunately change the implicit
serialVersionUID (e.g., adding a reference to String.class
will generate a static field class$java$lang$String).
Also, different source code to bytecode compilers may use different
naming conventions for synthetic variables generated for
references to class objects or inner classes.
To ensure interoperability of Serializable across versions,
consider adding an explicit serialVersionUID.
This method accesses the value of a Map entry, using a key that was retrieved from a keySet iterator. It is more efficient to use an iterator on the entrySet of the map, to avoid the Map.get(key) lookup.