elements) {
20 | if (! elements.containsKey("nullable")) {
21 | BugInstance bug = new BugInstance(this, "IMPLICIT_NULLNESS", HIGH_PRIORITY).addClass(this);
22 | if (visitingMethod()) {
23 | bug.addMethod(this);
24 | } else if (visitingField()) {
25 | bug.addField(this);
26 | }
27 | getBugReporter().reportBug(bug);
28 | }
29 | }
30 | }
31 |
--------------------------------------------------------------------------------
/src/main/java/jp/co/worksap/oss/findbugs/jpa/LongColumnNameDetector.java:
--------------------------------------------------------------------------------
1 | package jp.co.worksap.oss.findbugs.jpa;
2 |
3 | import java.util.Map;
4 |
5 | import javax.annotation.Nonnull;
6 |
7 | import org.apache.bcel.classfile.ElementValue;
8 | import org.apache.bcel.classfile.Method;
9 | import org.apache.commons.lang.IllegalClassException;
10 |
11 | import com.google.common.base.Objects;
12 |
13 | import edu.umd.cs.findbugs.BugInstance;
14 | import edu.umd.cs.findbugs.BugReporter;
15 | import edu.umd.cs.findbugs.bcel.AnnotationDetector;
16 | import edu.umd.cs.findbugs.internalAnnotations.DottedClassName;
17 |
18 | /**
19 | * Detect column which has too long name. Note that {@code @Column} annotation should annotate FIELD.
20 | * Currently we do not support annotated METHOD.
21 | *
22 | * @author Kengo TODA
23 | */
24 | public class LongColumnNameDetector extends AnnotationDetector {
25 | /**
26 | *
Oracle database limits the length of column name, and max length is {@code 30} bytes.
27 | *
28 | * @see http://docs.oracle.com/cd/B19306_01/server.102/b14200/sql_elements008.htm
29 | * @see http://stackoverflow.com/questions/1378133/why-are-oracle-table-column-index-names-limited-to-30-characters
30 | */
31 | private static final int MAX_TABLE_LENGTH = 30;
32 |
33 | private final BugReporter bugReporter;
34 |
35 | public LongColumnNameDetector(@Nonnull BugReporter bugReporter) {
36 | this.bugReporter = bugReporter;
37 | }
38 |
39 | @Override
40 | public void visitAnnotation(@DottedClassName String annotationClass,
41 | Map map, boolean runtimeVisible) {
42 | if (!Objects.equal(annotationClass, "javax.persistence.Column")) {
43 | return;
44 | }
45 | ElementValue specifiedName = map.get("name");
46 | final String columnName;
47 | if (specifiedName != null) {
48 | columnName = specifiedName.stringifyValue();
49 | } else if (visitingField()){
50 | columnName = getFieldName();
51 | } else if (visitingMethod()) {
52 | Method targetMethod = getMethod();
53 | columnName = VisitedFieldFinder.findFieldWhichisVisitedInVisitingMethod(this);
54 | if (columnName == null) {
55 | throw new IllegalClassException(String.format(
56 | "Method which is annotated with @Column should access to field, but %s#%s does not access.",
57 | getClassContext().getClassDescriptor().getClassName().replace('/', '.'),
58 | targetMethod.getName()));
59 | }
60 | } else {
61 | throw new IllegalClassException("@Column should annotate method or field.");
62 | }
63 | detectLongName(columnName);
64 | }
65 |
66 | private void detectLongName(@Nonnull String tableName) {
67 | if (tableName.length() > MAX_TABLE_LENGTH) {
68 | bugReporter.reportBug(new BugInstance(this, "LONG_COLUMN_NAME",
69 | HIGH_PRIORITY).addClass(this));
70 | }
71 | }
72 | }
73 |
--------------------------------------------------------------------------------
/src/main/java/jp/co/worksap/oss/findbugs/jpa/LongIndexNameDetector.java:
--------------------------------------------------------------------------------
1 | package jp.co.worksap.oss.findbugs.jpa;
2 |
3 | import java.util.Map;
4 |
5 | import javax.annotation.Nonnull;
6 |
7 | import org.apache.bcel.classfile.ElementValue;
8 |
9 | import com.google.common.base.Objects;
10 |
11 | import edu.umd.cs.findbugs.BugInstance;
12 | import edu.umd.cs.findbugs.BugReporter;
13 | import edu.umd.cs.findbugs.bcel.AnnotationDetector;
14 | import edu.umd.cs.findbugs.internalAnnotations.DottedClassName;
15 |
16 | public class LongIndexNameDetector extends AnnotationDetector {
17 | /**
18 | * Oracle database limits the length of index name, and max length is {@code 30} bytes.
19 | *
20 | * @see http://docs.oracle.com/cd/B19306_01/server.102/b14200/sql_elements008.htm
21 | * @see http://stackoverflow.com/questions/1378133/why-are-oracle-table-column-index-names-limited-to-30-characters
22 | */
23 | private static final int MAX_INDEX_LENGTH = 30;
24 | private static final String PARAMETER_NAME_OF_HIBERNATE = "name";
25 | private static final String PARAMETER_NAME_OF_OPENJPA = "name";
26 | private final BugReporter bugReporter;
27 |
28 | public LongIndexNameDetector(@Nonnull BugReporter bugReporter) {
29 | this.bugReporter = bugReporter;
30 | }
31 |
32 | @Override
33 | public void visitAnnotation(@DottedClassName String annotationClass,
34 | Map map, boolean runtimeVisible) {
35 | if (visitingHibernateAnnotation(annotationClass)) {
36 | detectLongName(map, PARAMETER_NAME_OF_HIBERNATE);
37 | } else if (visitingOpenJPAAnnotation(annotationClass)) {
38 | detectLongName(map, PARAMETER_NAME_OF_OPENJPA);
39 | }
40 | }
41 |
42 | private boolean visitingOpenJPAAnnotation(
43 | @Nonnull @DottedClassName String annotationClass) {
44 | return Objects.equal(annotationClass, "org.apache.openjpa.persistence.jdbc.Index");
45 | }
46 |
47 | private boolean visitingHibernateAnnotation(
48 | @Nonnull @DottedClassName String annotationClass) {
49 | return Objects.equal(annotationClass, "org.hibernate.annotations.Index");
50 | }
51 |
52 | private void detectLongName(@Nonnull final Map map,
53 | @Nonnull final String parameterName) {
54 | final ElementValue indexName = map.get(parameterName);
55 | if (indexName != null
56 | && indexName.stringifyValue().length() > MAX_INDEX_LENGTH) {
57 | bugReporter.reportBug(new BugInstance(this, "LONG_INDEX_NAME",
58 | HIGH_PRIORITY).addClass(this).addField(this));
59 | }
60 | }
61 | }
62 |
--------------------------------------------------------------------------------
/src/main/java/jp/co/worksap/oss/findbugs/jpa/LongTableNameDetector.java:
--------------------------------------------------------------------------------
1 | package jp.co.worksap.oss.findbugs.jpa;
2 |
3 | import java.util.Map;
4 |
5 | import javax.annotation.Nonnull;
6 |
7 | import org.apache.bcel.classfile.ElementValue;
8 |
9 | import com.google.common.annotations.VisibleForTesting;
10 | import com.google.common.base.Objects;
11 |
12 | import edu.umd.cs.findbugs.BugInstance;
13 | import edu.umd.cs.findbugs.BugReporter;
14 | import edu.umd.cs.findbugs.bcel.AnnotationDetector;
15 | import edu.umd.cs.findbugs.internalAnnotations.DottedClassName;
16 | import edu.umd.cs.findbugs.internalAnnotations.SlashedClassName;
17 |
18 | public class LongTableNameDetector extends AnnotationDetector {
19 | /**
20 | * Oracle database limits the length of table name, and max length is {@code 30} bytes.
21 | *
22 | * @see http://docs.oracle.com/cd/B19306_01/server.102/b14200/sql_elements008.htm
23 | * @see http://stackoverflow.com/questions/1378133/why-are-oracle-table-column-index-names-limited-to-30-characters
24 | */
25 | private static final int MAX_TABLE_LENGTH = 30;
26 |
27 | private final BugReporter bugReporter;
28 |
29 | public LongTableNameDetector(@Nonnull BugReporter bugReporter) {
30 | this.bugReporter = bugReporter;
31 | }
32 |
33 | @Override
34 | public void visitAnnotation(@DottedClassName String annotationClass,
35 | Map map, boolean runtimeVisible) {
36 | if (!Objects.equal(annotationClass, "javax.persistence.Entity")) {
37 | return;
38 | }
39 | ElementValue specifiedName = map.get("name");
40 | if (specifiedName != null) {
41 | detectLongName(specifiedName.stringifyValue());
42 | } else {
43 | String entityClassName = trimPackage(getClassName());
44 | detectLongName(entityClassName);
45 | }
46 | }
47 |
48 | @VisibleForTesting
49 | @Nonnull String trimPackage(@Nonnull @SlashedClassName String className) {
50 | int index = className.lastIndexOf('/');
51 | if (index < 0) {
52 | return className;
53 | } else {
54 | return className.substring(index + 1);
55 | }
56 | }
57 |
58 | private void detectLongName(@Nonnull String tableName) {
59 | if (tableName.length() > MAX_TABLE_LENGTH) {
60 | bugReporter.reportBug(new BugInstance(this, "LONG_TABLE_NAME",
61 | HIGH_PRIORITY).addClass(this));
62 | }
63 | }
64 | }
65 |
--------------------------------------------------------------------------------
/src/main/java/jp/co/worksap/oss/findbugs/jpa/NullablePrimitiveDetector.java:
--------------------------------------------------------------------------------
1 | package jp.co.worksap.oss.findbugs.jpa;
2 |
3 | import java.util.Map;
4 |
5 | import javax.annotation.Nonnull;
6 |
7 | import org.apache.bcel.classfile.ElementValue;
8 | import org.apache.bcel.generic.ObjectType;
9 | import org.apache.bcel.generic.Type;
10 |
11 | import edu.umd.cs.findbugs.BugInstance;
12 | import edu.umd.cs.findbugs.BugReporter;
13 |
14 | public class NullablePrimitiveDetector extends AbstractColumnDetector {
15 |
16 | public NullablePrimitiveDetector(@Nonnull final BugReporter bugReporter) {
17 | super(bugReporter);
18 | }
19 |
20 | @Override
21 | protected void verifyColumn(Type columnType,
22 | Map elements) {
23 | if (! isPrimitive(columnType)) {
24 | return;
25 | }
26 |
27 | boolean isNullableColumn = detectNullability(elements);
28 | if (isNullableColumn) {
29 | reportNullablePrimitive(columnType);
30 | }
31 | }
32 |
33 | private void reportNullablePrimitive(@Nonnull final Type columnType) {
34 | BugInstance bug = new BugInstance(this, "NULLABLE_PRIMITIVE", NORMAL_PRIORITY)
35 | .addClass(this);
36 | if (visitingMethod()) {
37 | bug.addMethod(this);
38 | } else if (visitingField()) {
39 | bug.addField(this);
40 | }
41 |
42 | getBugReporter().reportBug(bug);
43 | }
44 |
45 | private boolean detectNullability(@Nonnull final Map elements) {
46 | if (! elements.containsKey("nullable")) {
47 | // in JPA 1.0 specification, default value of 'nullable' parameter is true
48 | // note that this case will be reported by ImplicitNullnessDetector.
49 | return true;
50 | }
51 |
52 | String nullability = elements.get("nullable").stringifyValue();
53 | return "true".equals(nullability);
54 | }
55 |
56 | /**
57 | * Checks whether a given type is a primitive value or not.
58 | *
59 | * @param columnType the type of the column.
60 | * @return true if column type is primitive value (not reference type).
61 | */
62 | private boolean isPrimitive(@Nonnull final Type columnType) {
63 | return ! (columnType instanceof ObjectType); // looks bad, but simple way to check primitive or not.
64 | }
65 |
66 | }
67 |
--------------------------------------------------------------------------------
/src/main/java/jp/co/worksap/oss/findbugs/jpa/VisitedFieldFinder.java:
--------------------------------------------------------------------------------
1 | package jp.co.worksap.oss.findbugs.jpa;
2 |
3 | import static com.google.common.base.Preconditions.checkNotNull;
4 |
5 | import javax.annotation.CheckReturnValue;
6 | import javax.annotation.Nonnull;
7 | import javax.annotation.Nullable;
8 |
9 | import org.apache.bcel.classfile.FieldOrMethod;
10 | import org.objectweb.asm.ClassReader;
11 | import org.objectweb.asm.ClassVisitor;
12 | import org.objectweb.asm.MethodVisitor;
13 | import org.objectweb.asm.Opcodes;
14 |
15 | import edu.umd.cs.findbugs.bcel.AnnotationDetector;
16 |
17 | /**
18 | *
19 | * Simple ClassVisitor implementation to find visited field in the specified
20 | * method.
21 | *
22 | *
23 | * To create instance, you need to provide name and descriptor to specify the
24 | * target method.
25 | *
26 | *
27 | * @author Kengo TODA
28 | */
29 | final class VisitedFieldFinder extends ClassVisitor {
30 | private final class MethodVisitorExtension extends MethodVisitor {
31 | private MethodVisitorExtension(final int api) {
32 | super(api);
33 | }
34 |
35 | @Override
36 | public void visitFieldInsn(final int opcode, final String owner, final String name, final String desc) {
37 | visitedFieldName = name;
38 | // super.visitFieldInsn(opcode, owner, name, desc);
39 | }
40 | }
41 |
42 | private static final int API_VERSION = Opcodes.ASM5;
43 | private final String targetMethodName;
44 | private final String targetMethodDescriptor;
45 |
46 | private String visitedFieldName;
47 |
48 | VisitedFieldFinder(@Nonnull final String targetMethodName, @Nonnull final String targetMethodDescriptor) {
49 | super(API_VERSION);
50 | this.targetMethodName = checkNotNull(targetMethodName);
51 | this.targetMethodDescriptor = checkNotNull(targetMethodDescriptor);
52 | }
53 |
54 | @Override
55 | public String toString() {
56 | return "VisitedFieldFinder [targetMethodName=" + targetMethodName + ", targetMethodDescriptor="
57 | + targetMethodDescriptor + ", visitedFieldName=" + visitedFieldName + "]";
58 | }
59 |
60 | @CheckReturnValue
61 | @Nullable
62 | private String getVisitedFieldName() {
63 | return visitedFieldName;
64 | }
65 |
66 | @Override
67 | public MethodVisitor visitMethod(final int access, final String name, final String descriptor,
68 | final String signature, final String[] exceptions) {
69 | if (name.equals(targetMethodName) && descriptor.equals(targetMethodDescriptor)) {
70 | return new MethodVisitorExtension(API_VERSION);
71 | } else {
72 | // We do not have to analyze this method.
73 | // Returning null let ASM skip parsing this method.
74 | return null;
75 | }
76 | }
77 |
78 | // @Override
79 | // public FieldVisitor visitField(int access, String name, String desc,
80 | // String signature, Object value) {
81 | // return null;
82 | //
83 | // }
84 |
85 | // @Override
86 | // public void visitFieldInsn(int code, String owner, String name, String
87 | // description) {
88 | // visitedFieldName = name;
89 | // }
90 |
91 | @Nullable
92 | @CheckReturnValue
93 | static String findFieldWhichisVisitedInVisitingMethod(@Nonnull final AnnotationDetector detector) {
94 | final byte[] classByteCode = detector.getClassContext().getJavaClass().getBytes();
95 | final ClassReader reader = new ClassReader(classByteCode);
96 |
97 | final FieldOrMethod targetMethod = detector.getMethod();
98 | // note: bcel's #getSignature() method returns String like "(J)V", this
99 | // is named as "descriptor" in the context of ASM.
100 | // This is the reason why we call `targetMethod.getSignature()` to get
101 | // value for `targetMethodDescriptor` argument.
102 | final VisitedFieldFinder visitedFieldFinder = new VisitedFieldFinder(targetMethod.getName(),
103 | targetMethod.getSignature());
104 | reader.accept(visitedFieldFinder, 0);
105 | return visitedFieldFinder.getVisitedFieldName();
106 | }
107 | }
108 |
--------------------------------------------------------------------------------
/src/main/java/jp/co/worksap/oss/findbugs/jsr305/BrokenImmutableClassDetector.java:
--------------------------------------------------------------------------------
1 | package jp.co.worksap.oss.findbugs.jsr305;
2 |
3 | import java.util.Map;
4 |
5 | import javax.annotation.Nonnull;
6 | import javax.annotation.Nullable;
7 |
8 | import org.apache.bcel.classfile.ElementValue;
9 | import org.apache.bcel.classfile.Field;
10 | import org.apache.bcel.classfile.JavaClass;
11 |
12 | import com.google.common.base.Objects;
13 |
14 | import edu.umd.cs.findbugs.BugInstance;
15 | import edu.umd.cs.findbugs.BugReporter;
16 | import edu.umd.cs.findbugs.bcel.AnnotationDetector;
17 | import edu.umd.cs.findbugs.internalAnnotations.DottedClassName;
18 |
19 | /**
20 | * Detector to check immutability of class.
21 | * Note that this detector does not ensure that "constructor stores deep-copied instance" and
22 | * "getter returns deep-copied instance". Use EI_EXPOSE_REP and EI_EXPOSE_REP2 to check it.
23 | *
24 | * @see http://findbugs.sourceforge.net/bugDescriptions.html#EI_EXPOSE_REP
25 | * @see http://findbugs.sourceforge.net/bugDescriptions.html#EI_EXPOSE_REP2
26 | * @author Kengo TODA
27 | */
28 | public class BrokenImmutableClassDetector extends AnnotationDetector {
29 |
30 | private final BugReporter reporter;
31 |
32 | /**
33 | * Create a new BrokenImmutableClassDetector.
34 | * @param reporter the Bug Reporter to use.
35 | */
36 | public BrokenImmutableClassDetector(@Nonnull final BugReporter reporter) {
37 | this.reporter = reporter;
38 | }
39 |
40 | @Override
41 | public void visitAnnotation(@DottedClassName String annotationClass,
42 | Map map, boolean runtimeVisible) {
43 | if (!Objects.equal(annotationClass, "javax.annotation.concurrent.Immutable")) {
44 | return;
45 | }
46 |
47 | JavaClass targetClass = getThisClass();
48 | if (!targetClass.isFinal()) {
49 | reporter.reportBug(new BugInstance(this, "IMMUTABLE_CLASS_SHOULD_BE_FINAL", HIGH_PRIORITY).addClass(this));
50 | }
51 |
52 | try {
53 | checkImmutability(targetClass);
54 | } catch (ClassNotFoundException e) {
55 | throw new IllegalStateException("Cannot find super class of " + targetClass.getClassName() + ". Check classpath.", e);
56 | }
57 | }
58 |
59 | private void checkImmutability(@Nullable final JavaClass immutableClass) throws ClassNotFoundException {
60 | if (immutableClass == null) {
61 | return;
62 | }
63 | for (final Field field : immutableClass.getFields()) {
64 | if (!field.isStatic() && !field.isFinal()) {
65 | reporter.reportBug(new BugInstance(this, "BROKEN_IMMUTABILITY", HIGH_PRIORITY)
66 | .addClass(immutableClass)
67 | .addString(field.getName())
68 | .addString(immutableClass.getClassName())
69 | .addString(getThisClass().getClassName()));
70 | }
71 | }
72 | checkImmutability(immutableClass.getSuperClass());
73 | }
74 | }
75 |
--------------------------------------------------------------------------------
/src/main/java/jp/co/worksap/oss/findbugs/jsr305/nullness/GenericsData.java:
--------------------------------------------------------------------------------
1 | package jp.co.worksap.oss.findbugs.jsr305.nullness;
2 |
3 | import java.util.ArrayList;
4 | import java.util.Collections;
5 | import java.util.HashMap;
6 | import java.util.List;
7 | import java.util.Map;
8 | import java.util.regex.Matcher;
9 | import java.util.regex.Pattern;
10 |
11 | import edu.umd.cs.findbugs.ba.XClass;
12 | import edu.umd.cs.findbugs.classfile.CheckedAnalysisException;
13 | import edu.umd.cs.findbugs.classfile.ClassDescriptor;
14 |
15 | public final class GenericsData {
16 | private final Map declaredGenerics;
17 | private final Map> superclassesGenerics;
18 | private final GenericsData enclossingClassData;
19 | private static final Pattern GENERICS_REFERENCE_PATTERN = Pattern.compile("([<;][-+]?)T([^;]+)(?=;)");
20 |
21 | public GenericsData(final XClass clazz) throws CheckedAnalysisException {
22 | this(clazz, Collections.emptyList());
23 | }
24 |
25 | public GenericsData(final XClass clazz, final List childBoundGenerics) throws CheckedAnalysisException {
26 | final String signature = clazz.getSourceSignature();
27 |
28 | // Anonymous inner classes
29 | if (signature == null) {
30 | declaredGenerics = Collections.emptyMap();
31 | superclassesGenerics = Collections.emptyMap();
32 | enclossingClassData = null;
33 | return;
34 | }
35 |
36 | final ClassDescriptor enclosingClass = clazz.getImmediateEnclosingClass();
37 | if (enclosingClass != null) {
38 | enclossingClassData = new GenericsData(enclosingClass.getXClass());
39 | } else {
40 | enclossingClassData = null;
41 | }
42 |
43 | // Parse signature
44 | final Map declared = new HashMap();
45 | final Map> superGenerics = new HashMap>();
46 | int pos = 0;
47 | int lastConsumedPos = 0;
48 |
49 | // No declared generics
50 | if (signature.charAt(0) == '<') {
51 | int openGenerics = 1;
52 | pos++;
53 | lastConsumedPos++;
54 |
55 | while (openGenerics > 0) {
56 | switch (signature.charAt(pos++)) {
57 | case '<':
58 | openGenerics++;
59 | break;
60 |
61 | case '>':
62 | openGenerics--;
63 | break;
64 |
65 | case ';':
66 | if (openGenerics == 1) {
67 | final String generic[] = signature.substring(lastConsumedPos, pos - 1).split(":");
68 | final String genericValue;
69 |
70 | if (!childBoundGenerics.isEmpty() && childBoundGenerics.size() >= declared.size()) {
71 | genericValue = childBoundGenerics.get(declared.size());
72 | } else {
73 | genericValue = generic[1];
74 | }
75 |
76 | declared.put(generic[0], genericValue);
77 | lastConsumedPos = pos;
78 | }
79 | }
80 | }
81 |
82 | lastConsumedPos = pos;
83 | }
84 |
85 | // From here on, we have "extends", and we are possibly binding generics
86 | while (pos < signature.length()) {
87 | switch (signature.charAt(pos++)) {
88 | case ';':
89 | // this class defines no generics, skip it
90 | lastConsumedPos = pos;
91 | break;
92 |
93 | case '<':
94 | final String className = signature.substring(lastConsumedPos, pos - 1);
95 | final List genericsList = new ArrayList();
96 | lastConsumedPos = pos;
97 | int openGenerics = 1;
98 |
99 | while (openGenerics > 0) {
100 | switch (signature.charAt(pos++)) {
101 | case '<':
102 | openGenerics++;
103 | break;
104 |
105 | case '>':
106 | openGenerics--;
107 | break;
108 |
109 | case ';':
110 | if (openGenerics == 1) {
111 | genericsList.add(signature.substring(lastConsumedPos, pos - 1));
112 | lastConsumedPos = pos;
113 | }
114 | }
115 | }
116 |
117 | superGenerics.put(className, genericsList);
118 |
119 | break;
120 | }
121 | }
122 |
123 |
124 | declaredGenerics = Collections.unmodifiableMap(declared);
125 | superclassesGenerics = Collections.unmodifiableMap(superGenerics);
126 | }
127 |
128 | private final String keyForSuperclass(final ClassDescriptor cd) {
129 | return "L" + cd.getClassName();
130 | }
131 |
132 | public List getMappedSuperClassdata(final ClassDescriptor cd) {
133 | final List list = superclassesGenerics.get(keyForSuperclass(cd));
134 | if (list == null) {
135 | return Collections.emptyList();
136 | }
137 |
138 | final List ret = new ArrayList(list.size());
139 |
140 | for (final String val : list) {
141 | if (val.charAt(0) == 'T') {
142 | final String genericName = val.substring(1);
143 | final String boundValue = declaredGenerics.get(genericName);
144 | if (boundValue != null) {
145 | ret.add(boundValue);
146 | } else {
147 | ret.add(getInheritedValue(genericName));
148 | }
149 | } else {
150 | // Has this value any references to generics such as Ljava/util/List ??
151 | final Matcher matcher = GENERICS_REFERENCE_PATTERN.matcher(val);
152 | String boundValue = val;
153 | while (matcher.find()) {
154 | boundValue = boundValue.replaceAll(Pattern.quote(matcher.group(1)) + "T" + matcher.group(2) + ";",
155 | Matcher.quoteReplacement(matcher.group(1)) + declaredGenerics.get(matcher.group(2)) + ";");
156 | }
157 | ret.add(boundValue);
158 | }
159 | }
160 |
161 | return Collections.unmodifiableList(ret);
162 | }
163 |
164 | private String getInheritedValue(final String boundValue) {
165 | if (enclossingClassData == null) {
166 | return "Ljava/lang/Object"; // not really cool, but a good default
167 | }
168 |
169 | if (enclossingClassData.declaredGenerics.containsKey(boundValue)) {
170 | return enclossingClassData.declaredGenerics.get(boundValue);
171 | }
172 |
173 | // Keep looking up!
174 | return enclossingClassData.getInheritedValue(boundValue);
175 | }
176 |
177 | public Map getDeclaredGenerics() {
178 | return declaredGenerics;
179 | }
180 |
181 | @Override
182 | public String toString() {
183 | return "GenericsData [declaredGenerics=" + declaredGenerics
184 | + ", superclassesGenerics=" + superclassesGenerics + "]";
185 | }
186 | }
--------------------------------------------------------------------------------
/src/main/java/jp/co/worksap/oss/findbugs/jsr305/nullness/UnknownNullnessDetector.java:
--------------------------------------------------------------------------------
1 | package jp.co.worksap.oss.findbugs.jsr305.nullness;
2 |
3 |
4 | import java.util.HashSet;
5 | import java.util.Map.Entry;
6 | import java.util.Set;
7 | import java.util.regex.Matcher;
8 | import java.util.regex.Pattern;
9 |
10 | import javax.annotation.Nonnull;
11 | import javax.annotation.Nullable;
12 |
13 | import org.apache.bcel.classfile.Method;
14 | import org.apache.bcel.generic.ReferenceType;
15 | import org.apache.bcel.generic.Type;
16 |
17 | import edu.umd.cs.findbugs.BugInstance;
18 | import edu.umd.cs.findbugs.BugReporter;
19 | import edu.umd.cs.findbugs.BytecodeScanningDetector;
20 | import edu.umd.cs.findbugs.ba.XClass;
21 | import edu.umd.cs.findbugs.ba.XMethod;
22 | import edu.umd.cs.findbugs.ba.jsr305.JSR305NullnessAnnotations;
23 | import edu.umd.cs.findbugs.ba.jsr305.TypeQualifierAnnotation;
24 | import edu.umd.cs.findbugs.ba.jsr305.TypeQualifierApplications;
25 | import edu.umd.cs.findbugs.ba.jsr305.TypeQualifierValue;
26 | import edu.umd.cs.findbugs.classfile.CheckedAnalysisException;
27 | import edu.umd.cs.findbugs.classfile.ClassDescriptor;
28 | import edu.umd.cs.findbugs.classfile.Global;
29 |
30 | public class UnknownNullnessDetector extends BytecodeScanningDetector {
31 |
32 | private static final TypeQualifierValue NULLNESS_QUALIFIER
33 | = TypeQualifierValue.getValue(JSR305NullnessAnnotations.NONNULL, null);
34 |
35 | private static final Pattern ANONYMOUS_CLASSNAME_PATTERN = Pattern.compile("\\$[0-9]+$");
36 |
37 | private final BugReporter bugReporter;
38 |
39 | /**
40 | * Creates a new UnknownNullnessDetector.
41 | * @param bugReporter the bug reporter to use.
42 | */
43 | public UnknownNullnessDetector(@Nonnull final BugReporter bugReporter) {
44 | this.bugReporter = bugReporter;
45 | }
46 |
47 | @Override
48 | public void visit(final Method method) {
49 | final XMethod xMethod = getXMethod();
50 | if (xMethod.isSynthetic()) {
51 | // Ignore methods not created by the developer himself
52 | return;
53 | }
54 |
55 | // Ignore constructors for anonymous classes, they can't be declared / overridden
56 | if ("".equals(xMethod.getName())) {
57 | final Matcher matcher = ANONYMOUS_CLASSNAME_PATTERN.matcher(getClassDescriptor().getClassName());
58 | if (matcher.find()) {
59 | return;
60 | }
61 | }
62 |
63 | // Enums have several false positives we need to ignore...
64 | if (isEnumIgnoredMethod(xMethod)) {
65 | return;
66 | }
67 |
68 | /*
69 | * Ignore inherited methods.. Nullness should be declared upstream
70 | * This also prevents us from reporting on methods whose expected nullness we don't control,
71 | * such as Object.equals and List.add.
72 | */
73 | if (findSuperMethods(xMethod).isEmpty()) {
74 | // Make sure our own annotations are in place
75 | detectUnknownNullnessOfParameter(method, NULLNESS_QUALIFIER);
76 | detectUnknowNullnessOfReturnedValue(method, NULLNESS_QUALIFIER);
77 | }
78 | }
79 |
80 | private boolean isEnumIgnoredMethod(@Nonnull final XMethod xMethod) {
81 | boolean checkForEnum = false;
82 | final String methodName = xMethod.getName();
83 | final String signature = xMethod.getSignature();
84 |
85 | // public static CCC[] values()
86 | if ("values".equals(methodName) && xMethod.isStatic() && xMethod.getNumParams() == 0) {
87 | checkForEnum = true;
88 | }
89 |
90 | // public static CCC valueOf(String)
91 | if ("valueOf".equals(methodName) && xMethod.isStatic()
92 | && signature.equals("(Ljava/lang/String;)L" + xMethod.getClassDescriptor().getClassName() + ";")) {
93 | checkForEnum = true;
94 | }
95 |
96 | if (checkForEnum) {
97 | return isCurrentClassAnEnum();
98 | }
99 |
100 | return false;
101 | }
102 |
103 | private boolean isCurrentClassAnEnum() {
104 | // enums can't be put into hierarchies, they must extend java.lang.Enum directly
105 |
106 | final XClass xclass = getXClass();
107 | if (xclass == null) {
108 | return false;
109 | }
110 | final ClassDescriptor superCD = xclass.getSuperclassDescriptor();
111 | if ("java.lang.Enum".equals(superCD.getDottedClassName())) {
112 | return true;
113 | }
114 |
115 | return false;
116 | }
117 |
118 | private void detectUnknownNullnessOfParameter(@Nonnull final Method method,
119 | @Nonnull final TypeQualifierValue nullness) {
120 | Type[] argumentTypes = method.getArgumentTypes();
121 | int initialIndex = 0;
122 |
123 | if ("".equals(method.getName())) {
124 | if (method.getSignature().startsWith("(Ljava/lang/String;I")) {
125 | // This may be an enum, in which case the first arg is inherited and can't be checked
126 | if (isCurrentClassAnEnum()) {
127 | initialIndex = 2;
128 | }
129 | } else if (!getXClass().isStatic() && method.getSignature()
130 | .startsWith("(L" + getXClass().getContainingScope().getClassDescriptor().getClassName() + ";")) {
131 | initialIndex = 1;
132 | }
133 | }
134 |
135 | for (int i = initialIndex; i < argumentTypes.length; ++i) {
136 | if (!(argumentTypes[i] instanceof ReferenceType)
137 | || getXMethod().isVariableSynthetic(i)
138 | || (i == argumentTypes.length - 1 && getXMethod().isVarArgs())) {
139 | continue;
140 | }
141 |
142 | TypeQualifierAnnotation annotation = TypeQualifierApplications.getEffectiveTypeQualifierAnnotation(
143 | getXMethod(), i, nullness);
144 | if (annotation == null) {
145 | bugReporter.reportBug(new BugInstance("UNKNOWN_NULLNESS_OF_PARAMETER", NORMAL_PRIORITY)
146 | .addClassAndMethod(this));
147 | }
148 | }
149 | }
150 |
151 | @Nonnull
152 | private static Set findSuperMethods(@Nonnull final XMethod m) {
153 | /*
154 | We can't use {@code Hierarchy2.findMatchingMethod} since it considers return types, which is incorrect
155 | for Java, and just doesn't work with generics.
156 | */
157 | final Set result = new HashSet();
158 |
159 | final ClassDescriptor c = m.getClassDescriptor();
160 | if (c != null) {
161 | try {
162 | final XClass xc = Global.getAnalysisCache().getClassAnalysis(XClass.class, c);
163 | final GenericsData gd = new GenericsData(xc);
164 | findSuperMethods(c, m, result, gd, gd);
165 | result.remove(m);
166 | } catch (final Throwable e) {
167 | // ignore it
168 | }
169 | }
170 | return result;
171 | }
172 |
173 | private static void findSuperMethods(@Nullable final ClassDescriptor c, @Nonnull final XMethod m,
174 | @Nonnull final Set accumulator, @Nonnull final GenericsData childGenericsData,
175 | @Nonnull final GenericsData originalGenericsData) {
176 | if (c == null) {
177 | return;
178 | }
179 |
180 | try {
181 | final XClass xc = Global.getAnalysisCache().getClassAnalysis(XClass.class, c);
182 | final GenericsData gd = new GenericsData(xc, childGenericsData.getMappedSuperClassdata(c));
183 |
184 | for (final XMethod xm : xc.getXMethods()) {
185 | if (xm.isStatic() == m.isStatic() && xm.getName().equals(m.getName())
186 | && signaturesMatches(xm, m, gd, originalGenericsData)) {
187 | if (accumulator.add(xm)) {
188 | // Found a match, we are done here
189 | break;
190 | } else {
191 | // We have alerady visited this class on another path
192 | return;
193 | }
194 | }
195 | }
196 |
197 | findSuperMethods(xc.getSuperclassDescriptor(), m, accumulator, gd, originalGenericsData);
198 | for (final ClassDescriptor i : xc.getInterfaceDescriptorList()) {
199 | findSuperMethods(i, m, accumulator, gd, originalGenericsData);
200 | }
201 |
202 | accumulator.add(m);
203 | } catch (final CheckedAnalysisException e) {
204 | // nothing to do
205 | }
206 | }
207 |
208 | private static boolean signaturesMatches(@Nonnull final XMethod superm, @Nonnull final XMethod m,
209 | @Nonnull final GenericsData gd, @Nonnull final GenericsData ogd) {
210 | // Are there generics?
211 | String signature = superm.getSourceSignature();
212 | if (signature == null) {
213 | return getArgumentSignature(superm).equals(getArgumentSignature(m));
214 | }
215 |
216 | final String actualSignature = m.getSourceSignature() == null ? m.getSignature() : m.getSourceSignature();
217 |
218 | // Replace all generics
219 | return replaceGenericsInSignature(gd, signature).equals(replaceGenericsInSignature(ogd, actualSignature));
220 | }
221 |
222 | private static String replaceGenericsInSignature(final GenericsData gd, final String signature) {
223 | String s = signature;
224 | for (final Entry entry : gd.getDeclaredGenerics().entrySet()) {
225 | s = s.replaceAll("T" + Pattern.quote(entry.getKey()) + ";", Matcher.quoteReplacement(entry.getValue()) + ";");
226 | }
227 | return s;
228 | }
229 |
230 | @Nonnull
231 | private static String getArgumentSignature(@Nonnull final XMethod xm) {
232 | final String signature = xm.getSignature();
233 | return signature.substring(0, signature.indexOf(')') + 1);
234 | }
235 |
236 | private void detectUnknowNullnessOfReturnedValue(@Nonnull final Method method,
237 | @Nonnull final TypeQualifierValue nullness) {
238 | if (!(method.getReturnType() instanceof ReferenceType)) {
239 | return;
240 | }
241 |
242 | final TypeQualifierAnnotation annotation = TypeQualifierApplications.getEffectiveTypeQualifierAnnotation(
243 | getXMethod(), nullness);
244 | if (annotation == null) {
245 | bugReporter.reportBug(new BugInstance("UNKNOWN_NULLNESS_OF_RETURNED_VALUE", NORMAL_PRIORITY)
246 | .addClassAndMethod(this));
247 | }
248 | }
249 | }
250 |
--------------------------------------------------------------------------------
/src/main/java/jp/co/worksap/oss/findbugs/junit/UndocumentedIgnoreDetector.java:
--------------------------------------------------------------------------------
1 | package jp.co.worksap.oss.findbugs.junit;
2 |
3 | import java.util.Map;
4 |
5 | import javax.annotation.Nonnull;
6 |
7 | import org.apache.bcel.classfile.ElementValue;
8 |
9 | import edu.umd.cs.findbugs.BugInstance;
10 | import edu.umd.cs.findbugs.BugReporter;
11 | import edu.umd.cs.findbugs.BytecodeScanningDetector;
12 | import edu.umd.cs.findbugs.internalAnnotations.DottedClassName;
13 |
14 | /***
15 | * UndocumentedIgnoreDetector detects if test cases are being ignored
16 | * without an explanation.
17 | */
18 | public class UndocumentedIgnoreDetector extends BytecodeScanningDetector {
19 |
20 | private final BugReporter bugReporter;
21 |
22 | /***
23 | * Creates an UndocumentedIgnoreDetector.
24 | * @param bugReporter the bug reporter to use.
25 | */
26 | public UndocumentedIgnoreDetector(@Nonnull final BugReporter bugReporter) {
27 | this.bugReporter = bugReporter;
28 | }
29 |
30 | @Override
31 | public void visitAnnotation(@DottedClassName final String annotationClass,
32 | final Map map, final boolean runtimeVisible) {
33 | if (!"org.junit.Ignore".equals(annotationClass)) {
34 | return;
35 | }
36 |
37 | final ElementValue reason = map.get("value");
38 | if (reason == null || reason.stringifyValue().trim().isEmpty()) {
39 | final BugInstance bugInstance = new BugInstance("UNDOCUMENTED_IGNORE",
40 | HIGH_PRIORITY).addClass(this);
41 | if (visitingMethod()) {
42 | bugInstance.addMethod(this).addSourceLine(this);
43 | }
44 | bugReporter.reportBug(bugInstance);
45 | }
46 | }
47 | }
48 |
--------------------------------------------------------------------------------
/src/main/resources/metadata/META-INF/MANIFEST.MF:
--------------------------------------------------------------------------------
1 | Manifest-Version: 1.0
2 |
3 |
--------------------------------------------------------------------------------
/src/main/resources/metadata/bugrank.txt:
--------------------------------------------------------------------------------
1 | 0 BugPattern FORBIDDEN_SYSTEM
2 | 0 BugPattern IMMUTABLE_CLASS_SHOULD_BE_FINAL
3 | 0 BugPattern BROKEN_IMMUTABILITY
4 | 0 BugPattern LONG_INDEX_NAME
5 | 0 BugPattern LONG_TABLE_NAME
6 | 0 BugPattern LONG_COLUMN_NAME
7 | 0 BugPattern UNKNOWN_NULLNESS_OF_PARAMETER
8 | 0 BugPattern UNKNOWN_NULLNESS_OF_RETURNED_VALUE
9 | 0 BugPattern UNDOCUMENTED_IGNORE
10 | 0 BugPattern IMPLICIT_NULLNESS
11 | 0 BugPattern IMPLICIT_LENGTH
12 | 0 BugPattern ILLEGAL_LENGTH
13 | 0 BugPattern USE_COLUMN_DEFINITION
14 | 0 BugPattern NULLABLE_PRIMITIVE
15 | 0 BugPattern GUAVA_UNEXPECTED_ACCESS_TO_VISIBLE_FOR_TESTING
16 | 0 BugPattern FINDBUGS_UNDOCUMENTED_SUPPRESS_WARNINGS
17 | 0 BugPattern MISSING_FIELD_IN_TO_STRING
18 | 0 BugPattern MISSING_TO_STRING_OVERRIDE
19 | 0 BugPattern DONT_OVERRIDE_EQUALS
20 |
--------------------------------------------------------------------------------
/src/main/resources/metadata/findbugs.xml:
--------------------------------------------------------------------------------
1 |
2 |
5 |
6 |
8 |
10 |
11 |
13 |
15 |
17 |
18 |
20 |
22 |
24 |
25 |
27 |
29 |
30 |
32 |
34 |
35 |
37 |
39 |
40 |
42 |
44 |
46 |
47 |
49 |
51 |
52 |
54 |
56 |
57 |
59 |
61 |
62 |
64 |
66 |
67 |
69 |
71 |
72 |
74 |
76 |
77 |
79 |
81 |
83 |
84 |
86 |
88 |
89 |
91 |
93 |
95 |
96 |
98 |
99 |
100 |
102 |
103 |
104 |
--------------------------------------------------------------------------------
/src/test/java/com/monits/findbugs/effectivejava/EqualsOverrideDetectorTest.java:
--------------------------------------------------------------------------------
1 | package com.monits.findbugs.effectivejava;
2 |
3 | import static org.mockito.Mockito.never;
4 | import static org.mockito.Mockito.spy;
5 | import static org.mockito.Mockito.verify;
6 |
7 | import org.junit.Before;
8 | import org.junit.Test;
9 |
10 | import com.h3xstream.findbugs.test.BaseDetectorTest;
11 | import com.h3xstream.findbugs.test.EasyBugReporter;
12 |
13 | public class EqualsOverrideDetectorTest extends BaseDetectorTest {
14 |
15 | private static final String DONT_OVERRIDE_EQUALS = "DONT_OVERRIDE_EQUALS";
16 |
17 | private EasyBugReporter reporter;
18 |
19 | @Before
20 | public void setup() {
21 | reporter = spy(new EasyBugReporter());
22 | }
23 |
24 | @Test
25 | public void testNoEqualsOverride() throws Exception {
26 | // Locate test code
27 | final String[] files = {
28 | getClassFilePath("samples/effectivejava/item8/BaseConcreteClass"),
29 | };
30 |
31 | // Run the analysis
32 | analyze(files, reporter);
33 |
34 | verify(reporter, never()).doReportBug(
35 | bugDefinition()
36 | .bugType(DONT_OVERRIDE_EQUALS)
37 | .build()
38 | );
39 | }
40 |
41 | @Test
42 | public void testGoodOverride() throws Exception {
43 | // Locate test code
44 | final String[] files = {
45 | getClassFilePath("samples/effectivejava/item8/BaseNonEqualsConcreteClass"),
46 | getClassFilePath("samples/effectivejava/item8/GoodEqualsOverride"),
47 | };
48 |
49 | // Run the analysis
50 | analyze(files, reporter);
51 |
52 | verify(reporter, never()).doReportBug(
53 | bugDefinition()
54 | .bugType(DONT_OVERRIDE_EQUALS)
55 | .build()
56 | );
57 | }
58 |
59 | @Test
60 | public void testBadOverride() throws Exception {
61 | // Locate test code
62 | final String[] files = {
63 | getClassFilePath("samples/effectivejava/item8/BaseConcreteClass"),
64 | getClassFilePath("samples/effectivejava/item8/BadEqualsOverride"),
65 | };
66 |
67 | // Run the analysis
68 | analyze(files, reporter);
69 |
70 | verify(reporter).doReportBug(
71 | bugDefinition()
72 | .bugType(DONT_OVERRIDE_EQUALS)
73 | .inClass("BadEqualsOverride")
74 | .build()
75 | );
76 | }
77 | }
78 |
--------------------------------------------------------------------------------
/src/test/java/com/monits/findbugs/jdk/InconsistentHashCodeEqualsDetectorTest.java:
--------------------------------------------------------------------------------
1 | package com.monits.findbugs.jdk;
2 |
3 | import static org.mockito.Mockito.never;
4 | import static org.mockito.Mockito.spy;
5 | import static org.mockito.Mockito.verify;
6 |
7 | import org.junit.Before;
8 | import org.junit.Test;
9 |
10 | import com.h3xstream.findbugs.test.BaseDetectorTest;
11 | import com.h3xstream.findbugs.test.EasyBugReporter;
12 |
13 | public class InconsistentHashCodeEqualsDetectorTest extends BaseDetectorTest {
14 |
15 | private EasyBugReporter reporter;
16 |
17 | @Before
18 | public void setup() {
19 | reporter = spy(new EasyBugReporter());
20 | }
21 |
22 | @Test
23 | public void testNoEqualsHashCodeErrors() throws Exception {
24 | final String[] files = {
25 | // Good implementation should not raise any errors
26 | getClassFilePath("samples/findbugs/GoodEqualsHashCodeImplementation"),
27 | // Classes with one overridden method should not raise any errors
28 | getClassFilePath("samples/findbugs/OnlyEqualsImplementation"),
29 | // Classes with neither methods overridden should not raise any errors
30 | getClassFilePath("samples/findbugs/NoEqualsHashCode"),
31 | };
32 |
33 | analyze(files, reporter);
34 |
35 | verify(reporter, never()).doReportBug(bugDefinition()
36 | .bugType("HASHCHODE_HAS_MORE_FIELDS_THAN_EQUALS")
37 | .build()
38 | );
39 |
40 | verify(reporter, never()).doReportBug(bugDefinition()
41 | .bugType("EQUALS_HAS_MORE_FIELDS_THAN_HASHCODE")
42 | .build()
43 | );
44 | }
45 |
46 | @Test
47 | public void testSubclassOfBadClassHasNoErrors() throws Exception {
48 | final String[] files = {
49 | getClassFilePath("samples/findbugs/HashCodeContainsEquals"),
50 | getClassFilePath("samples/findbugs/SubclassOfBadEqualsHashCode"),
51 | };
52 |
53 | analyze(files, reporter);
54 |
55 | // subclass must not have hashcode error ...
56 | verify(reporter, never()).doReportBug(
57 | bugDefinition()
58 | .bugType("HASHCHODE_HAS_MORE_FIELDS_THAN_EQUALS")
59 | .inClass("samples.findbugs.SubclassOfBadEqualsHashCode")
60 | .build()
61 | );
62 |
63 | // ... nor equals error
64 | verify(reporter, never()).doReportBug(
65 | bugDefinition()
66 | .bugType("EQUALS_HAS_MORE_FIELDS_THAN_HASHCODE")
67 | .inClass("samples.findbugs.SubclassOfBadEqualsHashCode")
68 | .build()
69 | );
70 |
71 | // superclass will rise hashcode error
72 | verify(reporter).doReportBug(
73 | bugDefinition()
74 | .bugType("HASHCHODE_HAS_MORE_FIELDS_THAN_EQUALS")
75 | .inClass("samples.findbugs.HashCodeContainsEquals")
76 | .atField("version")
77 | .build()
78 | );
79 | }
80 |
81 | @Test
82 | public void testHashCodeHasMoreFieldsThanEquals() throws Exception {
83 | final String[] files = {
84 | getClassFilePath("samples/findbugs/HashCodeContainsEquals"),
85 | };
86 |
87 | analyze(files, reporter);
88 |
89 | verify(reporter).doReportBug(
90 | bugDefinition()
91 | .bugType("HASHCHODE_HAS_MORE_FIELDS_THAN_EQUALS")
92 | .inClass("samples.findbugs.HashCodeContainsEquals")
93 | .inMethod("hashCode")
94 | .atField("version")
95 | .build()
96 | );
97 | }
98 |
99 | @Test
100 | public void testEqualsHasMoreFieldsThanHashCode() throws Exception {
101 | final String[] files = {
102 | getClassFilePath("samples/findbugs/EqualsContainsHashCode"),
103 | };
104 |
105 | analyze(files, reporter);
106 |
107 | verify(reporter).doReportBug(
108 | bugDefinition()
109 | .bugType("EQUALS_HAS_MORE_FIELDS_THAN_HASHCODE")
110 | .inClass("samples.findbugs.EqualsContainsHashCode")
111 | .inMethod("equals")
112 | .atField("version")
113 | .build()
114 | );
115 | }
116 |
117 | @Test
118 | public void testEqualsHashCodeDistinctFields() throws Exception {
119 | final String[] files = {
120 | getClassFilePath("samples/findbugs/EqualsHashCodeDifferentFields"),
121 | };
122 |
123 | analyze(files, reporter);
124 |
125 | verify(reporter).doReportBug(
126 | bugDefinition()
127 | .bugType("HASHCHODE_HAS_MORE_FIELDS_THAN_EQUALS")
128 | .inClass("samples.findbugs.EqualsHashCodeDifferentFields")
129 | .inMethod("hashCode")
130 | .atField("version")
131 | .build()
132 | );
133 |
134 | verify(reporter).doReportBug(
135 | bugDefinition()
136 | .bugType("EQUALS_HAS_MORE_FIELDS_THAN_HASHCODE")
137 | .inClass("samples.findbugs.EqualsHashCodeDifferentFields")
138 | .inMethod("equals")
139 | .atField("id")
140 | .build()
141 | );
142 | }
143 |
144 | }
145 |
--------------------------------------------------------------------------------
/src/test/java/com/monits/findbugs/jdk/PatternCompileTest.java:
--------------------------------------------------------------------------------
1 | package com.monits.findbugs.jdk;
2 |
3 | import static org.mockito.Mockito.never;
4 | import static org.mockito.Mockito.spy;
5 | import static org.mockito.Mockito.verify;
6 |
7 | import org.junit.Before;
8 | import org.junit.Test;
9 |
10 | import com.h3xstream.findbugs.test.BaseDetectorTest;
11 | import com.h3xstream.findbugs.test.EasyBugReporter;
12 |
13 | public class PatternCompileTest extends BaseDetectorTest {
14 |
15 | private EasyBugReporter reporter;
16 |
17 | @Before
18 | public void setup() {
19 | reporter = spy(new EasyBugReporter());
20 | }
21 |
22 | @Test
23 | public void testReportNonStaticPatternCompile() throws Exception {
24 | // Locate test code
25 | final String[] files = {
26 | getClassFilePath("samples/findbugs/jdk/patterncompile/NonStaticPatternCompile"),
27 | };
28 |
29 | // Run the analysis
30 | analyze(files, reporter);
31 |
32 | verify(reporter).doReportBug(
33 | bugDefinition()
34 | .bugType(NonStaticPatternCompileDetector.NON_STATIC_PATTERN_COMPILE_CALL)
35 | .inClass("NonStaticPatternCompile")
36 | .inMethod("testReportNonStaticPatternCompile")
37 | .build()
38 | );
39 | }
40 |
41 | @Test
42 | public void testReportNonStaticPatternCompileWithStaticRegex() throws Exception {
43 | // Locate test code
44 | final String[] files = {
45 | getClassFilePath("samples/findbugs/jdk/patterncompile/NonStaticPatternCompile"),
46 | };
47 |
48 | // Run the analysis
49 | analyze(files, reporter);
50 |
51 | verify(reporter).doReportBug(
52 | bugDefinition()
53 | .bugType(NonStaticPatternCompileDetector.NON_STATIC_PATTERN_COMPILE_CALL)
54 | .inClass("NonStaticPatternCompile")
55 | .inMethod("testReportNonStaticPatternCompileWithStaticRegex")
56 | .build()
57 | );
58 | }
59 |
60 | @Test
61 | public void testNeverReportNonStaticPatternCompileWithNonFinalLocalRegex() throws Exception {
62 | // Locate test code
63 | final String[] files = {
64 | getClassFilePath("samples/findbugs/jdk/patterncompile/NonStaticPatternCompile"),
65 | };
66 |
67 | // Run the analysis
68 | analyze(files, reporter);
69 |
70 | verify(reporter, never()).doReportBug(
71 | bugDefinition()
72 | .bugType(NonStaticPatternCompileDetector.NON_STATIC_PATTERN_COMPILE_CALL)
73 | .inClass("NonStaticPatternCompile")
74 | .inMethod("testNeverReportNonStaticPatternCompileWithNonFinalLocalRegex")
75 | .build()
76 | );
77 | }
78 |
79 | @Test
80 | public void testReportNonStaticPatternCompileWithFinalLocalRegex() throws Exception {
81 | // Locate test code
82 | final String[] files = {
83 | getClassFilePath("samples/findbugs/jdk/patterncompile/NonStaticPatternCompile"),
84 | };
85 |
86 | // Run the analysis
87 | analyze(files, reporter);
88 |
89 | verify(reporter).doReportBug(
90 | bugDefinition()
91 | .bugType(NonStaticPatternCompileDetector.NON_STATIC_PATTERN_COMPILE_CALL)
92 | .inClass("NonStaticPatternCompile")
93 | .inMethod("testReportNonStaticPatternCompileWithFinalLocalRegex")
94 | .build()
95 | );
96 | }
97 |
98 | @Test
99 | public void testNeverReportNonStaticPatternCompileWithFinalRegexParameter() throws Exception {
100 | // Locate test code
101 | final String[] files = {
102 | getClassFilePath("samples/findbugs/jdk/patterncompile/NonStaticPatternCompile"),
103 | };
104 |
105 | // Run the analysis
106 | analyze(files, reporter);
107 |
108 | verify(reporter, never()).doReportBug(
109 | bugDefinition()
110 | .bugType(NonStaticPatternCompileDetector.NON_STATIC_PATTERN_COMPILE_CALL)
111 | .inClass("NonStaticPatternCompile")
112 | .inMethod("testNeverReportNonStaticPatternCompileWithFinalRegexParameter")
113 | .build()
114 | );
115 | }
116 |
117 | @Test
118 | public void testNeverReportNonStaticPatternCompileWithNonFinalRegexParameter() throws Exception {
119 | // Locate test code
120 | final String[] files = {
121 | getClassFilePath("samples/findbugs/jdk/patterncompile/NonStaticPatternCompile"),
122 | };
123 |
124 | // Run the analysis
125 | analyze(files, reporter);
126 |
127 | verify(reporter, never()).doReportBug(
128 | bugDefinition()
129 | .bugType(NonStaticPatternCompileDetector.NON_STATIC_PATTERN_COMPILE_CALL)
130 | .inClass("NonStaticPatternCompile")
131 | .inMethod("testNeverReportNonStaticPatternCompileWithNonFinalRegexParameter")
132 | .build()
133 | );
134 | }
135 |
136 | @Test
137 | public void testNeverReportNonStaticPatternCompileWithRegexFromObject() throws Exception {
138 | // Locate test code
139 | final String[] files = {
140 | getClassFilePath("samples/findbugs/jdk/patterncompile/NonStaticPatternCompile"),
141 | };
142 |
143 | // Run the analysis
144 | analyze(files, reporter);
145 |
146 | verify(reporter, never()).doReportBug(
147 | bugDefinition()
148 | .bugType(NonStaticPatternCompileDetector.NON_STATIC_PATTERN_COMPILE_CALL)
149 | .inClass("NonStaticPatternCompile")
150 | .inMethod("testNeverReportNonStaticPatternCompileWithRegexFromObject")
151 | .build()
152 | );
153 | }
154 |
155 |
156 | @Test
157 | public void testMethodWithStaticPatternCompile() throws Exception {
158 | // Locate test code
159 | final String[] files = {
160 | getClassFilePath("samples/findbugs/jdk/patterncompile/StaticPatternCompile"),
161 | };
162 |
163 | // Run the analysis
164 | analyze(files, reporter);
165 |
166 | verify(reporter, never()).doReportBug(
167 | bugDefinition()
168 | .bugType(NonStaticPatternCompileDetector.NON_STATIC_PATTERN_COMPILE_CALL)
169 | .inClass("StaticPatternCompile")
170 | .inMethod("testStaticPatternCompile")
171 | .build()
172 | );
173 | }
174 |
175 | @Test
176 | public void testStaticPatternCompileInClass() throws Exception {
177 | // Locate test code
178 | final String[] files = {
179 | getClassFilePath("samples/findbugs/jdk/patterncompile/StaticPatternCompile"),
180 | };
181 |
182 | // Run the analysis
183 | analyze(files, reporter);
184 |
185 | verify(reporter, never()).doReportBug(
186 | bugDefinition()
187 | .bugType(NonStaticPatternCompileDetector.NON_STATIC_PATTERN_COMPILE_CALL)
188 | .inClass("StaticPatternCompile")
189 | .build()
190 | );
191 | }
192 |
193 | @SuppressWarnings("PMD.JUnitTestsShouldIncludeAssert")
194 | @Test
195 | public void testPatternCompileWithAConcatenatedRegex() throws Exception {
196 | // Locate test code
197 | final String[] files = {
198 | getClassFilePath("samples/findbugs/jdk/patterncompile/NonStaticPatternCompile"),
199 | };
200 |
201 | // Run the analysis
202 | analyze(files, reporter);
203 |
204 | verify(reporter, never()).doReportBug(
205 | bugDefinition()
206 | .bugType(NonStaticPatternCompileDetector.NON_STATIC_PATTERN_COMPILE_CALL)
207 | .inClass("NonStaticPatternCompile")
208 | .inMethod("testPatternCompileWithAConcatenatedRegex")
209 | .build()
210 | );
211 | }
212 | }
--------------------------------------------------------------------------------
/src/test/java/com/monits/findbugs/jdk/UselessStringValueOfTest.java:
--------------------------------------------------------------------------------
1 | package com.monits.findbugs.jdk;
2 |
3 | import static org.mockito.Mockito.never;
4 | import static org.mockito.Mockito.spy;
5 | import static org.mockito.Mockito.verify;
6 |
7 | import org.junit.Before;
8 | import org.junit.Test;
9 |
10 | import com.h3xstream.findbugs.test.BaseDetectorTest;
11 | import com.h3xstream.findbugs.test.EasyBugReporter;
12 |
13 | public class UselessStringValueOfTest extends BaseDetectorTest {
14 |
15 | private EasyBugReporter reporter;
16 |
17 | @Before
18 | public void setup() {
19 | reporter = spy(new EasyBugReporter());
20 | }
21 |
22 | @Test
23 | public void testUselessStringValueOfString() throws Exception {
24 | // Locate test code
25 | final String[] files = {
26 | getClassFilePath("samples/findbugs/jdk/UselessStringValueOfCall"),
27 | };
28 |
29 | // Run the analysis
30 | analyze(files, reporter);
31 |
32 | verify(reporter).doReportBug(
33 | bugDefinition()
34 | .bugType(UselessStringValueOfCallDetector.USELESS_STRING_VALUEOF_CALL)
35 | .inClass("UselessStringValueOfCall")
36 | .inMethod("getStringValueOfString")
37 | .build()
38 | );
39 | }
40 |
41 | @Test
42 | public void testUselessStringValueOfDummyString() throws Exception {
43 | // Locate test code
44 | final String[] files = {
45 | getClassFilePath("samples/findbugs/jdk/UselessStringValueOfCall"),
46 | };
47 |
48 | // Run the analysis
49 | analyze(files, reporter);
50 |
51 | verify(reporter).doReportBug(
52 | bugDefinition()
53 | .bugType(UselessStringValueOfCallDetector.USELESS_STRING_VALUEOF_CALL)
54 | .inClass("UselessStringValueOfCall")
55 | .inMethod("getStringValueOfDummyString")
56 | .build()
57 | );
58 | }
59 |
60 | @Test
61 | public void getStringValueOfPrimitiveInteger() throws Exception {
62 | // Locate test code
63 | final String[] files = {
64 | getClassFilePath("samples/findbugs/jdk/UselessStringValueOfCall"),
65 | };
66 |
67 | // Run the analysis
68 | analyze(files, reporter);
69 |
70 | verify(reporter, never()).doReportBug(
71 | bugDefinition()
72 | .bugType(UselessStringValueOfCallDetector.USELESS_STRING_VALUEOF_CALL)
73 | .inClass("UselessStringValueOfCall")
74 | .inMethod("getStringValueOfPrimitiveInteger")
75 | .build()
76 | );
77 | }
78 |
79 | @Test
80 | public void getString() throws Exception {
81 | // Locate test code
82 | final String[] files = {
83 | getClassFilePath("samples/findbugs/jdk/UselessStringValueOfCall"),
84 | };
85 |
86 | // Run the analysis
87 | analyze(files, reporter);
88 |
89 | verify(reporter, never()).doReportBug(
90 | bugDefinition()
91 | .bugType(UselessStringValueOfCallDetector.USELESS_STRING_VALUEOF_CALL)
92 | .inClass("UselessStringValueOfCall")
93 | .inMethod("getString")
94 | .build()
95 | );
96 | }
97 |
98 | @Test
99 | public void concatenatedStringFromParam() throws Exception {
100 | // Locate test code
101 | final String[] files = {
102 | getClassFilePath("samples/findbugs/jdk/UselessStringValueOfCall"),
103 | };
104 |
105 | // Run the analysis
106 | analyze(files, reporter);
107 |
108 | verify(reporter, never()).doReportBug(
109 | bugDefinition()
110 | .bugType(UselessStringValueOfCallDetector.USELESS_STRING_VALUEOF_CALL)
111 | .inClass("UselessStringValueOfCall")
112 | .inMethod("concatenatedStringFromParam")
113 | .build()
114 | );
115 | }
116 |
117 | @Test
118 | public void concatenatedLocalString() throws Exception {
119 | // Locate test code
120 | final String[] files = {
121 | getClassFilePath("samples/findbugs/jdk/UselessStringValueOfCall"),
122 | };
123 |
124 | // Run the analysis
125 | analyze(files, reporter);
126 |
127 | verify(reporter, never()).doReportBug(
128 | bugDefinition()
129 | .bugType(UselessStringValueOfCallDetector.USELESS_STRING_VALUEOF_CALL)
130 | .inClass("UselessStringValueOfCall")
131 | .inMethod("concatenatedLocalString")
132 | .build()
133 | );
134 | }
135 |
136 | @Test
137 | public void stringFromParamInValueOf() throws Exception {
138 | // Locate test code
139 | final String[] files = {
140 | getClassFilePath("samples/findbugs/jdk/UselessStringValueOfCall"),
141 | };
142 |
143 | // Run the analysis
144 | analyze(files, reporter);
145 |
146 | verify(reporter).doReportBug(
147 | bugDefinition()
148 | .bugType(UselessStringValueOfCallDetector.USELESS_STRING_VALUEOF_CALL)
149 | .inClass("UselessStringValueOfCall")
150 | .inMethod("stringFromParamInValueOf")
151 | .build()
152 | );
153 | }
154 | }
--------------------------------------------------------------------------------
/src/test/java/jp/co/worksap/oss/findbugs/ForbiddenSystemDetectorTest.java:
--------------------------------------------------------------------------------
1 | package jp.co.worksap.oss.findbugs;
2 |
3 | import static org.mockito.Mockito.spy;
4 | import static org.mockito.Mockito.verify;
5 |
6 | import org.junit.Before;
7 | import org.junit.Test;
8 |
9 | import com.h3xstream.findbugs.test.BaseDetectorTest;
10 | import com.h3xstream.findbugs.test.EasyBugReporter;
11 |
12 | public class ForbiddenSystemDetectorTest extends BaseDetectorTest {
13 | private EasyBugReporter reporter;
14 |
15 | @Before
16 | public void setup() {
17 | reporter = spy(new EasyBugReporter());
18 | }
19 |
20 | @Test
21 | public void testUseSystemOutBug() throws Exception {
22 | // Locate test code
23 | final String[] files = {
24 | getClassFilePath("samples/system/UseSystemOut")
25 | };
26 |
27 | // Run the analysis
28 | analyze(files, reporter);
29 |
30 | verify(reporter).doReportBug(
31 | bugDefinition()
32 | .bugType("FORBIDDEN_SYSTEM")
33 | .inClass("UseSystemOut")
34 | .build()
35 | );
36 | }
37 |
38 | @Test
39 | public void testUseSystemErrBug() throws Exception {
40 | // Locate test code
41 | final String[] files = {
42 | getClassFilePath("samples/system/UseSystemErr")
43 | };
44 |
45 | // Run the analysis
46 | analyze(files, reporter);
47 |
48 | verify(reporter).doReportBug(
49 | bugDefinition()
50 | .bugType("FORBIDDEN_SYSTEM")
51 | .inClass("UseSystemErr")
52 | .build()
53 | );
54 | }
55 |
56 | }
57 |
--------------------------------------------------------------------------------
/src/test/java/jp/co/worksap/oss/findbugs/findbugs/UndocumentedSuppressFBWarningsDetectorTest.java:
--------------------------------------------------------------------------------
1 | package jp.co.worksap.oss.findbugs.findbugs;
2 |
3 | import static org.mockito.Mockito.never;
4 | import static org.mockito.Mockito.spy;
5 | import static org.mockito.Mockito.verify;
6 |
7 | import org.junit.Before;
8 | import org.junit.Test;
9 |
10 | import com.h3xstream.findbugs.test.BaseDetectorTest;
11 | import com.h3xstream.findbugs.test.EasyBugReporter;
12 |
13 | public class UndocumentedSuppressFBWarningsDetectorTest extends BaseDetectorTest {
14 |
15 | private EasyBugReporter reporter;
16 |
17 | @Before
18 | public void setup() {
19 | reporter = spy(new EasyBugReporter());
20 | }
21 |
22 | @Test
23 | public void testDocumentedClasses() throws Exception {
24 | // Locate test code
25 | final String[] files = {
26 | getClassFilePath("samples/findbugs/DocumentedSuppressFBWarnings"),
27 | getClassFilePath("samples/findbugs/DocumentedSuppressWarnings")
28 | };
29 |
30 | // Run the analysis
31 | analyze(files, reporter);
32 |
33 | verify(reporter, never()).doReportBug(
34 | bugDefinition()
35 | .bugType("FINDBUGS_UNDOCUMENTED_SUPPRESS_WARNINGS")
36 | .build()
37 | );
38 | }
39 |
40 | @Test
41 | public void testUndocumentedClasses() throws Exception {
42 | // Locate test code
43 | final String[] files = {
44 | getClassFilePath("samples/findbugs/UndocumentedSuppressFBWarnings"),
45 | getClassFilePath("samples/findbugs/UndocumentedSuppressWarnings")
46 | };
47 |
48 | // Run the analysis
49 | analyze(files, reporter);
50 |
51 | verify(reporter).doReportBug(
52 | bugDefinition()
53 | .bugType("FINDBUGS_UNDOCUMENTED_SUPPRESS_WARNINGS")
54 | .inClass("UndocumentedSuppressFBWarnings")
55 | .build()
56 | );
57 | verify(reporter).doReportBug(
58 | bugDefinition()
59 | .bugType("FINDBUGS_UNDOCUMENTED_SUPPRESS_WARNINGS")
60 | .inClass("UndocumentedSuppressWarnings")
61 | .build()
62 | );
63 | }
64 |
65 | }
66 |
--------------------------------------------------------------------------------
/src/test/java/jp/co/worksap/oss/findbugs/guava/UnexpectedAccessDetectorTest.java:
--------------------------------------------------------------------------------
1 | package jp.co.worksap.oss.findbugs.guava;
2 |
3 | import static org.mockito.Mockito.never;
4 | import static org.mockito.Mockito.spy;
5 | import static org.mockito.Mockito.verify;
6 |
7 | import org.junit.Before;
8 | import org.junit.Test;
9 |
10 | import com.h3xstream.findbugs.test.BaseDetectorTest;
11 | import com.h3xstream.findbugs.test.EasyBugReporter;
12 |
13 |
14 | /**
15 | * @author tolina GmbH
16 | *
17 | */
18 | public class UnexpectedAccessDetectorTest extends BaseDetectorTest {
19 | private EasyBugReporter reporter;
20 |
21 | @Before
22 | public void setup() {
23 | reporter = spy(new EasyBugReporter());
24 | }
25 |
26 | @Test
27 | public void testNormalMethod() throws Exception {
28 | // Locate test code
29 | final String[] files = {
30 | getClassFilePath("samples/guava/ClassWhichCallsNormalMethod"),
31 | getClassFilePath("samples/guava/MethodWithoutVisibleForTesting")
32 | };
33 |
34 | // Run the analysis
35 | analyze(files, reporter);
36 |
37 | verify(reporter, never()).doReportBug(
38 | bugDefinition()
39 | .bugType("GUAVA_UNEXPECTED_ACCESS_TO_VISIBLE_FOR_TESTING")
40 | .build()
41 | );
42 | }
43 |
44 | @Test
45 | public void testCallFromJUnit4Test() throws Exception {
46 | // Locate test code
47 | final String[] files = {
48 | getClassFilePath("samples/guava/JUnit4Test"),
49 | getClassFilePath("samples/guava/MethodWithVisibleForTesting")
50 | };
51 |
52 | // Run the analysis
53 | analyze(files, reporter);
54 |
55 | verify(reporter, never()).doReportBug(
56 | bugDefinition()
57 | .bugType("GUAVA_UNEXPECTED_ACCESS_TO_VISIBLE_FOR_TESTING")
58 | .build()
59 | );
60 | }
61 |
62 | @Test
63 | public void testCallFromJUnit3Test() throws Exception {
64 | // Locate test code
65 | final String[] files = {
66 | getClassFilePath("samples/guava/JUnit3Test"),
67 | getClassFilePath("samples/guava/MethodWithVisibleForTesting")
68 | };
69 |
70 | // Run the analysis
71 | analyze(files, reporter);
72 |
73 | verify(reporter, never()).doReportBug(
74 | bugDefinition()
75 | .bugType("GUAVA_UNEXPECTED_ACCESS_TO_VISIBLE_FOR_TESTING")
76 | .build()
77 | );
78 | }
79 |
80 | @Test
81 | public void testCallingAnnotatedMethod() throws Exception {
82 | // Locate test code
83 | final String[] files = {
84 | getClassFilePath("samples/guava/ClassWhichCallsVisibleMethodForTesting"),
85 | getClassFilePath("samples/guava/MethodWithVisibleForTesting")
86 | };
87 |
88 | // Run the analysis
89 | analyze(files, reporter);
90 |
91 | verify(reporter).doReportBug(
92 | bugDefinition()
93 | .bugType("GUAVA_UNEXPECTED_ACCESS_TO_VISIBLE_FOR_TESTING")
94 | .inClass("ClassWhichCallsVisibleMethodForTesting")
95 | .build()
96 | );
97 | }
98 | }
99 |
--------------------------------------------------------------------------------
/src/test/java/jp/co/worksap/oss/findbugs/jpa/ColumnDefinitionTest.java:
--------------------------------------------------------------------------------
1 | package jp.co.worksap.oss.findbugs.jpa;
2 |
3 | import static org.mockito.Mockito.never;
4 | import static org.mockito.Mockito.spy;
5 | import static org.mockito.Mockito.verify;
6 |
7 | import org.junit.Before;
8 | import org.junit.Test;
9 |
10 | import com.h3xstream.findbugs.test.BaseDetectorTest;
11 | import com.h3xstream.findbugs.test.EasyBugReporter;
12 |
13 | public class ColumnDefinitionTest extends BaseDetectorTest {
14 |
15 | private EasyBugReporter reporter;
16 |
17 | @Before
18 | public void setup() {
19 | reporter = spy(new EasyBugReporter());
20 | }
21 |
22 | @Test
23 | public void testNormalClass() throws Exception {
24 | // Locate test code
25 | final String[] files = {
26 | getClassFilePath("samples/jpa/ShortColumnName")
27 | };
28 |
29 | // Run the analysis
30 | analyze(files, reporter);
31 |
32 | verify(reporter, never()).doReportBug(
33 | bugDefinition()
34 | .bugType("USE_COLUMN_DEFINITION")
35 | .build()
36 | );
37 | }
38 |
39 | @Test
40 | public void testWithColumnDefinition() throws Exception {
41 | // Locate test code
42 | final String[] files = {
43 | getClassFilePath("samples/jpa/UseColumnDefinition")
44 | };
45 |
46 | // Run the analysis
47 | analyze(files, reporter);
48 |
49 | verify(reporter).doReportBug(
50 | bugDefinition()
51 | .bugType("USE_COLUMN_DEFINITION")
52 | .inClass("UseColumnDefinition")
53 | .build()
54 | );
55 | }
56 | }
57 |
--------------------------------------------------------------------------------
/src/test/java/jp/co/worksap/oss/findbugs/jpa/ColumnNameLengthTest.java:
--------------------------------------------------------------------------------
1 | package jp.co.worksap.oss.findbugs.jpa;
2 |
3 | import static org.mockito.Mockito.never;
4 | import static org.mockito.Mockito.spy;
5 | import static org.mockito.Mockito.verify;
6 |
7 | import org.junit.Before;
8 | import org.junit.Test;
9 |
10 | import com.h3xstream.findbugs.test.BaseDetectorTest;
11 | import com.h3xstream.findbugs.test.EasyBugReporter;
12 |
13 | public class ColumnNameLengthTest extends BaseDetectorTest {
14 | private EasyBugReporter reporter;
15 |
16 | @Before
17 | public void setup() {
18 | reporter = spy(new EasyBugReporter());
19 | }
20 |
21 | @Test
22 | public void testShortName() throws Exception {
23 | // Locate test code
24 | final String[] files = {
25 | getClassFilePath("samples/jpa/ShortColumnName")
26 | };
27 |
28 | // Run the analysis
29 | analyze(files, reporter);
30 |
31 | verify(reporter, never()).doReportBug(
32 | bugDefinition()
33 | .bugType("LONG_COLUMN_NAME")
34 | .build()
35 | );
36 | }
37 |
38 | @Test
39 | public void testShortNameWithoutAnnotationParameter() throws Exception {
40 | // Locate test code
41 | final String[] files = {
42 | getClassFilePath("samples/jpa/ShortColumnNameWithoutAnnotationParameter")
43 | };
44 |
45 | // Run the analysis
46 | analyze(files, reporter);
47 |
48 | verify(reporter, never()).doReportBug(
49 | bugDefinition()
50 | .bugType("LONG_COLUMN_NAME")
51 | .build()
52 | );
53 | }
54 |
55 | @Test
56 | public void testLongName() throws Exception {
57 | // Locate test code
58 | final String[] files = {
59 | getClassFilePath("samples/jpa/LongColumnName")
60 | };
61 |
62 | // Run the analysis
63 | analyze(files, reporter);
64 |
65 | verify(reporter).doReportBug(
66 | bugDefinition()
67 | .bugType("LONG_COLUMN_NAME")
68 | .inClass("LongColumnName")
69 | .build()
70 | );
71 | }
72 |
73 | @Test
74 | public void testLongNameWithoutAnnotationParameter() throws Exception {
75 | // Locate test code
76 | final String[] files = {
77 | getClassFilePath("samples/jpa/LongColumnNameWithoutAnnotationParameter")
78 | };
79 |
80 | // Run the analysis
81 | analyze(files, reporter);
82 |
83 | verify(reporter).doReportBug(
84 | bugDefinition()
85 | .bugType("LONG_COLUMN_NAME")
86 | .inClass("LongColumnNameWithoutAnnotationParameter")
87 | .build()
88 | );
89 | }
90 |
91 | @Test
92 | public void testLongColumnNameByAnnotatedMethod() throws Exception {
93 | // Locate test code
94 | final String[] files = {
95 | getClassFilePath("samples/jpa/LongColumnNameByAnnotatedMethod")
96 | };
97 |
98 | // Run the analysis
99 | analyze(files, reporter);
100 |
101 | verify(reporter).doReportBug(
102 | bugDefinition()
103 | .bugType("LONG_COLUMN_NAME")
104 | .inClass("LongColumnNameByAnnotatedMethod")
105 | .build()
106 | );
107 | }
108 | }
109 |
--------------------------------------------------------------------------------
/src/test/java/jp/co/worksap/oss/findbugs/jpa/ImplicitLengthTest.java:
--------------------------------------------------------------------------------
1 | package jp.co.worksap.oss.findbugs.jpa;
2 |
3 | import static org.mockito.Mockito.never;
4 | import static org.mockito.Mockito.spy;
5 | import static org.mockito.Mockito.verify;
6 |
7 | import org.junit.Before;
8 | import org.junit.Test;
9 |
10 | import com.h3xstream.findbugs.test.BaseDetectorTest;
11 | import com.h3xstream.findbugs.test.EasyBugReporter;
12 |
13 | public class ImplicitLengthTest extends BaseDetectorTest {
14 | private EasyBugReporter reporter;
15 |
16 | @Before
17 | public void setup() {
18 | reporter = spy(new EasyBugReporter());
19 | }
20 |
21 | @Test
22 | public void testNegativeLength() throws Exception {
23 | // Locate test code
24 | final String[] files = {
25 | getClassFilePath("samples/jpa/ColumnWithNegativeLength")
26 | };
27 |
28 | // Run the analysis
29 | analyze(files, reporter);
30 |
31 | verify(reporter).doReportBug(
32 | bugDefinition()
33 | .bugType("ILLEGAL_LENGTH")
34 | .inClass("ColumnWithNegativeLength")
35 | .build()
36 | );
37 | }
38 |
39 | @Test
40 | public void testTooLongLength() throws Exception {
41 | // Locate test code
42 | final String[] files = {
43 | getClassFilePath("samples/jpa/ColumnWithTooLongLength"),
44 | getClassFilePath("samples/jpa/GetterWithTooLongLength")
45 | };
46 |
47 | // Run the analysis
48 | analyze(files, reporter);
49 |
50 | verify(reporter).doReportBug(
51 | bugDefinition()
52 | .bugType("ILLEGAL_LENGTH")
53 | .inClass("ColumnWithTooLongLength")
54 | .build()
55 | );
56 | verify(reporter).doReportBug(
57 | bugDefinition()
58 | .bugType("ILLEGAL_LENGTH")
59 | .inClass("GetterWithTooLongLength")
60 | .build()
61 | );
62 | }
63 |
64 | @Test
65 | public void testLongLengthWithLob() throws Exception {
66 | // Locate test code
67 | final String[] files = {
68 | getClassFilePath("samples/jpa/ColumnWithLongLengthAndLob"),
69 | getClassFilePath("samples/jpa/GetterWithLongLengthAndLob")
70 | };
71 |
72 | // Run the analysis
73 | analyze(files, reporter);
74 |
75 | verify(reporter, never()).doReportBug(
76 | bugDefinition()
77 | .bugType("LONG_COLUMN_NAME")
78 | .build()
79 | );
80 | }
81 |
82 | @Test
83 | public void testExplicitLength() throws Exception {
84 | // Locate test code
85 | final String[] files = {
86 | getClassFilePath("samples/jpa/ColumnWithLength")
87 | };
88 |
89 | // Run the analysis
90 | analyze(files, reporter);
91 |
92 | verify(reporter, never()).doReportBug(
93 | bugDefinition()
94 | .bugType("LONG_COLUMN_NAME")
95 | .build()
96 | );
97 | }
98 |
99 | @Test
100 | public void testImplicitLength() throws Exception {
101 | // Locate test code
102 | final String[] files = {
103 | getClassFilePath("samples/jpa/ColumnWithoutElement"),
104 | getClassFilePath("samples/jpa/GetterWithoutElement")
105 | };
106 |
107 | // Run the analysis
108 | analyze(files, reporter);
109 |
110 | verify(reporter).doReportBug(
111 | bugDefinition()
112 | .bugType("IMPLICIT_LENGTH")
113 | .inClass("ColumnWithoutElement")
114 | .build()
115 | );
116 | verify(reporter).doReportBug(
117 | bugDefinition()
118 | .bugType("IMPLICIT_LENGTH")
119 | .inClass("GetterWithoutElement")
120 | .build()
121 | );
122 | }
123 | }
124 |
--------------------------------------------------------------------------------
/src/test/java/jp/co/worksap/oss/findbugs/jpa/ImplicitNullnessTest.java:
--------------------------------------------------------------------------------
1 | package jp.co.worksap.oss.findbugs.jpa;
2 |
3 | import static org.mockito.Mockito.never;
4 | import static org.mockito.Mockito.spy;
5 | import static org.mockito.Mockito.verify;
6 |
7 | import org.junit.Before;
8 | import org.junit.Test;
9 |
10 | import com.h3xstream.findbugs.test.BaseDetectorTest;
11 | import com.h3xstream.findbugs.test.EasyBugReporter;
12 |
13 | public class ImplicitNullnessTest extends BaseDetectorTest {
14 | private EasyBugReporter reporter;
15 |
16 | @Before
17 | public void setup() {
18 | reporter = spy(new EasyBugReporter());
19 | }
20 |
21 | @Test
22 | public void testExplicitNullness() throws Exception {
23 | // Locate test code
24 | final String[] files = {
25 | getClassFilePath("samples/jpa/ColumnWithNullable")
26 | };
27 |
28 | // Run the analysis
29 | analyze(files, reporter);
30 |
31 | verify(reporter, never()).doReportBug(
32 | bugDefinition()
33 | .bugType("IMPLICIT_NULLNESS")
34 | .build()
35 | );
36 | }
37 |
38 | @Test
39 | public void testImplicitNullness() throws Exception {
40 | // Locate test code
41 | final String[] files = {
42 | getClassFilePath("samples/jpa/ColumnWithoutElement"),
43 | getClassFilePath("samples/jpa/GetterWithoutElement")
44 | };
45 |
46 | // Run the analysis
47 | analyze(files, reporter);
48 |
49 | verify(reporter).doReportBug(
50 | bugDefinition()
51 | .bugType("IMPLICIT_NULLNESS")
52 | .inClass("ColumnWithoutElement")
53 | .build()
54 | );
55 | verify(reporter).doReportBug(
56 | bugDefinition()
57 | .bugType("IMPLICIT_NULLNESS")
58 | .inClass("GetterWithoutElement")
59 | .build()
60 | );
61 | }
62 | }
63 |
--------------------------------------------------------------------------------
/src/test/java/jp/co/worksap/oss/findbugs/jpa/IndexNameLengthTest.java:
--------------------------------------------------------------------------------
1 | package jp.co.worksap.oss.findbugs.jpa;
2 |
3 | import static org.mockito.Mockito.never;
4 | import static org.mockito.Mockito.spy;
5 | import static org.mockito.Mockito.verify;
6 |
7 | import org.junit.Before;
8 | import org.junit.Test;
9 |
10 | import com.h3xstream.findbugs.test.BaseDetectorTest;
11 | import com.h3xstream.findbugs.test.EasyBugReporter;
12 |
13 | public class IndexNameLengthTest extends BaseDetectorTest {
14 | private EasyBugReporter reporter;
15 |
16 | @Before
17 | public void setup() {
18 | reporter = spy(new EasyBugReporter());
19 | }
20 |
21 | @Test
22 | public void testShortNameWithHibernate() throws Exception {
23 | // Locate test code
24 | final String[] files = {
25 | getClassFilePath("samples/jpa/ShortIndexNameForHibernate")
26 | };
27 |
28 | // Run the analysis
29 | analyze(files, reporter);
30 |
31 | verify(reporter, never()).doReportBug(
32 | bugDefinition()
33 | .bugType("LONG_INDEX_NAME")
34 | .build()
35 | );
36 | }
37 |
38 | @Test
39 | public void testLongNameWithHibernate() throws Exception {
40 | // Locate test code
41 | final String[] files = {
42 | getClassFilePath("samples/jpa/LongIndexNameForHibernate")
43 | };
44 |
45 | // Run the analysis
46 | analyze(files, reporter);
47 |
48 | verify(reporter).doReportBug(
49 | bugDefinition()
50 | .bugType("LONG_INDEX_NAME")
51 | .inClass("LongIndexNameForHibernate")
52 | .build()
53 | );
54 | }
55 |
56 | @Test
57 | public void testShortNameWithOpenJPA() throws Exception {
58 | // Locate test code
59 | final String[] files = {
60 | getClassFilePath("samples/jpa/ShortIndexNameForOpenJPA")
61 | };
62 |
63 | // Run the analysis
64 | analyze(files, reporter);
65 |
66 | verify(reporter, never()).doReportBug(
67 | bugDefinition()
68 | .bugType("LONG_INDEX_NAME")
69 | .build()
70 | );
71 | }
72 |
73 | @Test
74 | public void testLongNameWithOpenJPA() throws Exception {
75 | // Locate test code
76 | final String[] files = {
77 | getClassFilePath("samples/jpa/LongIndexNameForOpenJPA")
78 | };
79 |
80 | // Run the analysis
81 | analyze(files, reporter);
82 |
83 | verify(reporter).doReportBug(
84 | bugDefinition()
85 | .bugType("LONG_INDEX_NAME")
86 | .inClass("LongIndexNameForOpenJPA")
87 | .build()
88 | );
89 | }
90 | }
91 |
--------------------------------------------------------------------------------
/src/test/java/jp/co/worksap/oss/findbugs/jpa/NullablePrimitiveDetectorTest.java:
--------------------------------------------------------------------------------
1 | package jp.co.worksap.oss.findbugs.jpa;
2 |
3 | import static org.mockito.Mockito.never;
4 | import static org.mockito.Mockito.spy;
5 | import static org.mockito.Mockito.verify;
6 |
7 | import org.junit.Before;
8 | import org.junit.Test;
9 |
10 | import com.h3xstream.findbugs.test.BaseDetectorTest;
11 | import com.h3xstream.findbugs.test.EasyBugReporter;
12 |
13 | public class NullablePrimitiveDetectorTest extends BaseDetectorTest {
14 | private EasyBugReporter reporter;
15 |
16 | @Before
17 | public void setup() {
18 | reporter = spy(new EasyBugReporter());
19 | }
20 |
21 | @Test
22 | public void testNullableObject() throws Exception {
23 | // Locate test code
24 | final String[] files = {
25 | getClassFilePath("samples/jpa/UseColumnDefinition"),
26 | getClassFilePath("samples/jpa/ColumnWithoutElement")
27 | };
28 |
29 | // Run the analysis
30 | analyze(files, reporter);
31 |
32 | verify(reporter, never()).doReportBug(
33 | bugDefinition()
34 | .bugType("NULLABLE_PRIMITIVE")
35 | .build()
36 | );
37 | }
38 |
39 | @Test
40 | public void testNullablePrimitive() throws Exception {
41 | // Locate test code
42 | final String[] files = {
43 | getClassFilePath("samples/jpa/NullableBooleanColumn"),
44 | getClassFilePath("samples/jpa/NullableByteColumn"),
45 | getClassFilePath("samples/jpa/NullableShortColumn"),
46 | getClassFilePath("samples/jpa/NullableIntColumn"),
47 | getClassFilePath("samples/jpa/NullableLongColumn"),
48 | getClassFilePath("samples/jpa/NullableFloatColumn"),
49 | getClassFilePath("samples/jpa/NullableDoubleColumn"),
50 | getClassFilePath("samples/jpa/NullableBooleanGetter")
51 | };
52 |
53 | // Run the analysis
54 | analyze(files, reporter);
55 |
56 | verify(reporter).doReportBug(
57 | bugDefinition()
58 | .bugType("NULLABLE_PRIMITIVE")
59 | .inClass("NullableBooleanColumn")
60 | .build()
61 | );
62 | verify(reporter).doReportBug(
63 | bugDefinition()
64 | .bugType("NULLABLE_PRIMITIVE")
65 | .inClass("NullableByteColumn")
66 | .build()
67 | );
68 | verify(reporter).doReportBug(
69 | bugDefinition()
70 | .bugType("NULLABLE_PRIMITIVE")
71 | .inClass("NullableShortColumn")
72 | .build()
73 | );
74 | verify(reporter).doReportBug(
75 | bugDefinition()
76 | .bugType("NULLABLE_PRIMITIVE")
77 | .inClass("NullableIntColumn")
78 | .build()
79 | );
80 | verify(reporter).doReportBug(
81 | bugDefinition()
82 | .bugType("NULLABLE_PRIMITIVE")
83 | .inClass("NullableLongColumn")
84 | .build()
85 | );
86 | verify(reporter).doReportBug(
87 | bugDefinition()
88 | .bugType("NULLABLE_PRIMITIVE")
89 | .inClass("NullableFloatColumn")
90 | .build()
91 | );
92 | verify(reporter).doReportBug(
93 | bugDefinition()
94 | .bugType("NULLABLE_PRIMITIVE")
95 | .inClass("NullableDoubleColumn")
96 | .build()
97 | );
98 | verify(reporter).doReportBug(
99 | bugDefinition()
100 | .bugType("NULLABLE_PRIMITIVE")
101 | .inClass("NullableBooleanGetter")
102 | .build()
103 | );
104 | }
105 |
106 | @Test
107 | public void testNonNullableObject() throws Exception {
108 | // Locate test code
109 | final String[] files = {
110 | getClassFilePath("samples/jpa/ColumnWithNullable")
111 | };
112 |
113 | // Run the analysis
114 | analyze(files, reporter);
115 |
116 | verify(reporter, never()).doReportBug(
117 | bugDefinition()
118 | .bugType("NULLABLE_PRIMITIVE")
119 | .build()
120 | );
121 | }
122 |
123 | @Test
124 | public void testNonNullableInt() throws Exception {
125 | // Locate test code
126 | final String[] files = {
127 | getClassFilePath("samples/jpa/NonNullablePrimitiveColumn")
128 | };
129 |
130 | // Run the analysis
131 | analyze(files, reporter);
132 |
133 | verify(reporter, never()).doReportBug(
134 | bugDefinition()
135 | .bugType("NULLABLE_PRIMITIVE")
136 | .build()
137 | );
138 | }
139 |
140 | }
141 |
--------------------------------------------------------------------------------
/src/test/java/jp/co/worksap/oss/findbugs/jpa/TableNameLengthTest.java:
--------------------------------------------------------------------------------
1 | package jp.co.worksap.oss.findbugs.jpa;
2 |
3 | import static org.mockito.Mockito.never;
4 | import static org.mockito.Mockito.spy;
5 | import static org.mockito.Mockito.verify;
6 |
7 | import org.junit.Before;
8 | import org.junit.Test;
9 |
10 | import com.h3xstream.findbugs.test.BaseDetectorTest;
11 | import com.h3xstream.findbugs.test.EasyBugReporter;
12 |
13 | public class TableNameLengthTest extends BaseDetectorTest {
14 | private EasyBugReporter reporter;
15 |
16 | @Before
17 | public void setup() {
18 | reporter = spy(new EasyBugReporter());
19 | }
20 |
21 | @Test
22 | public void testShortName() throws Exception {
23 | // Locate test code
24 | final String[] files = {
25 | getClassFilePath("samples/jpa/ShortTableName")
26 | };
27 |
28 | // Run the analysis
29 | analyze(files, reporter);
30 |
31 | verify(reporter, never()).doReportBug(
32 | bugDefinition()
33 | .bugType("LONG_TABLE_NAME")
34 | .build()
35 | );
36 | }
37 |
38 | @Test
39 | public void testShortNameWithoutAnnotationParameter() throws Exception {
40 | // Locate test code
41 | final String[] files = {
42 | getClassFilePath("samples/jpa/ShortTableNameNoAnnotationPara")
43 | };
44 |
45 | // Run the analysis
46 | analyze(files, reporter);
47 |
48 | verify(reporter, never()).doReportBug(
49 | bugDefinition()
50 | .bugType("LONG_TABLE_NAME")
51 | .build()
52 | );
53 | }
54 |
55 | @Test
56 | public void testLongName() throws Exception {
57 | // Locate test code
58 | final String[] files = {
59 | getClassFilePath("samples/jpa/LongTableName")
60 | };
61 |
62 | // Run the analysis
63 | analyze(files, reporter);
64 |
65 | verify(reporter).doReportBug(
66 | bugDefinition()
67 | .bugType("LONG_TABLE_NAME")
68 | .inClass("LongTableName")
69 | .build()
70 | );
71 | }
72 |
73 | @Test
74 | public void testLongNameWithoutAnnotationParameter() throws Exception {
75 | // Locate test code
76 | final String[] files = {
77 | getClassFilePath("samples/jpa/LongTableNameWithoutAnnotationParameter")
78 | };
79 |
80 | // Run the analysis
81 | analyze(files, reporter);
82 |
83 | verify(reporter).doReportBug(
84 | bugDefinition()
85 | .bugType("LONG_TABLE_NAME")
86 | .inClass("LongTableNameWithoutAnnotationParameter")
87 | .build()
88 | );
89 | }
90 | }
91 |
--------------------------------------------------------------------------------
/src/test/java/jp/co/worksap/oss/findbugs/jsr305/BrokenImmutableClassDetectorTest.java:
--------------------------------------------------------------------------------
1 | package jp.co.worksap.oss.findbugs.jsr305;
2 |
3 |
4 | import static org.mockito.Mockito.never;
5 | import static org.mockito.Mockito.spy;
6 | import static org.mockito.Mockito.verify;
7 | import static org.mockito.Mockito.times;
8 |
9 | import org.junit.Before;
10 | import org.junit.Test;
11 |
12 | import com.h3xstream.findbugs.test.BaseDetectorTest;
13 | import com.h3xstream.findbugs.test.EasyBugReporter;
14 |
15 | public class BrokenImmutableClassDetectorTest extends BaseDetectorTest {
16 | private EasyBugReporter reporter;
17 |
18 | @Before
19 | public void setup() {
20 | reporter = spy(new EasyBugReporter());
21 | }
22 |
23 | @Test
24 | public void testGoodMutableClass() throws Exception {
25 | // Locate test code
26 | final String[] files = {
27 | getClassFilePath("samples/jsr305/GoodMutableClass")
28 | };
29 |
30 | // Run the analysis
31 | analyze(files, reporter);
32 |
33 | verify(reporter, never()).doReportBug(
34 | bugDefinition()
35 | .bugType("IMMUTABLE_CLASS_SHOULD_BE_FINAL")
36 | .build()
37 | );
38 | verify(reporter, never()).doReportBug(
39 | bugDefinition()
40 | .bugType("BROKEN_IMMUTABILITY")
41 | .build()
42 | );
43 | }
44 |
45 | @Test
46 | public void testEnumIsImmutable() throws Exception {
47 | // Locate test code
48 | final String[] files = {
49 | getClassFilePath("samples/jsr305/ImmutableEnum")
50 | };
51 |
52 | // Run the analysis
53 | analyze(files, reporter);
54 |
55 | verify(reporter, never()).doReportBug(
56 | bugDefinition()
57 | .bugType("IMMUTABLE_CLASS_SHOULD_BE_FINAL")
58 | .build()
59 | );
60 | verify(reporter, never()).doReportBug(
61 | bugDefinition()
62 | .bugType("BROKEN_IMMUTABILITY")
63 | .build()
64 | );
65 | }
66 |
67 | @Test
68 | public void testBadMutableClass() throws Exception {
69 | // Locate test code
70 | final String[] files = {
71 | getClassFilePath("samples/jsr305/BadImmutableClass"),
72 | getClassFilePath("samples/jsr305/ExtendsMutableClass")
73 | };
74 |
75 | // Run the analysis
76 | analyze(files, reporter);
77 |
78 | verify(reporter, times(2)).doReportBug(
79 | bugDefinition()
80 | .bugType("BROKEN_IMMUTABILITY")
81 | .inClass("BadImmutableClass")
82 | .build()
83 | );
84 | verify(reporter).doReportBug(
85 | bugDefinition()
86 | .bugType("IMMUTABLE_CLASS_SHOULD_BE_FINAL")
87 | .inClass("BadImmutableClass")
88 | .build()
89 | );
90 | }
91 | }
92 |
--------------------------------------------------------------------------------
/src/test/java/jp/co/worksap/oss/findbugs/junit/UndocumentedIgnoreDetectorTest.java:
--------------------------------------------------------------------------------
1 | package jp.co.worksap.oss.findbugs.junit;
2 |
3 | import static org.mockito.Mockito.never;
4 | import static org.mockito.Mockito.spy;
5 | import static org.mockito.Mockito.verify;
6 |
7 | import org.junit.Before;
8 | import org.junit.Test;
9 |
10 | import com.h3xstream.findbugs.test.BaseDetectorTest;
11 | import com.h3xstream.findbugs.test.EasyBugReporter;
12 |
13 | public class UndocumentedIgnoreDetectorTest extends BaseDetectorTest {
14 | private EasyBugReporter reporter;
15 |
16 | @Before
17 | public void setup() {
18 | reporter = spy(new EasyBugReporter());
19 | }
20 |
21 | @Test
22 | public void testIgnoreClassWithExplanation() throws Exception {
23 | // Locate test code
24 | final String[] files = {
25 | getClassFilePath("samples/junit/IgnoreClassWithExplanation")
26 | };
27 |
28 | // Run the analysis
29 | analyze(files, reporter);
30 |
31 | verify(reporter, never()).doReportBug(
32 | bugDefinition()
33 | .bugType("UNDOCUMENTED_IGNORE")
34 | .build()
35 | );
36 | }
37 |
38 | @Test
39 | public void testIgnoreMethodWithExplanation() throws Exception {
40 | // Locate test code
41 | final String[] files = {
42 | getClassFilePath("samples/junit/IgnoreMethodWithExplanation")
43 | };
44 |
45 | // Run the analysis
46 | analyze(files, reporter);
47 |
48 | verify(reporter, never()).doReportBug(
49 | bugDefinition()
50 | .bugType("UNDOCUMENTED_IGNORE")
51 | .build()
52 | );
53 | }
54 |
55 | @Test
56 | public void testIgnoreClassWithEmptyExplanation() throws Exception {
57 | // Locate test code
58 | final String[] files = {
59 | getClassFilePath("samples/junit/IgnoreClassWithEmptyExplanation")
60 | };
61 |
62 | // Run the analysis
63 | analyze(files, reporter);
64 |
65 | verify(reporter).doReportBug(
66 | bugDefinition()
67 | .bugType("UNDOCUMENTED_IGNORE")
68 | .inClass("IgnoreClassWithEmptyExplanation")
69 | .build()
70 | );
71 | }
72 |
73 | @Test
74 | public void testIgnoreMethodWithEmptyExplanation() throws Exception {
75 | // Locate test code
76 | final String[] files = {
77 | getClassFilePath("samples/junit/IgnoreMethodWithEmptyExplanation")
78 | };
79 |
80 | // Run the analysis
81 | analyze(files, reporter);
82 |
83 | verify(reporter).doReportBug(
84 | bugDefinition()
85 | .bugType("UNDOCUMENTED_IGNORE")
86 | .inClass("IgnoreMethodWithEmptyExplanation")
87 | .build()
88 | );
89 | }
90 |
91 | @Test
92 | public void testIgnoreClassWithoutExplanation() throws Exception {
93 | // Locate test code
94 | final String[] files = {
95 | getClassFilePath("samples/junit/IgnoreClassWithoutExplanation")
96 | };
97 |
98 | // Run the analysis
99 | analyze(files, reporter);
100 |
101 | verify(reporter).doReportBug(
102 | bugDefinition()
103 | .bugType("UNDOCUMENTED_IGNORE")
104 | .inClass("IgnoreClassWithoutExplanation")
105 | .build()
106 | );
107 | }
108 |
109 | @Test
110 | public void testIgnoreMethodWithoutExplanation() throws Exception {
111 | // Locate test code
112 | final String[] files = {
113 | getClassFilePath("samples/junit/IgnoreMethodWithoutExplanation")
114 | };
115 |
116 | // Run the analysis
117 | analyze(files, reporter);
118 |
119 | verify(reporter).doReportBug(
120 | bugDefinition()
121 | .bugType("UNDOCUMENTED_IGNORE")
122 | .inClass("IgnoreMethodWithoutExplanation")
123 | .build()
124 | );
125 | }
126 | }
127 |
--------------------------------------------------------------------------------
/src/test/java/samples/effectivejava/item10/ArrayMissingToStringClass.java:
--------------------------------------------------------------------------------
1 | package samples.effectivejava.item10;
2 |
3 | import java.util.Arrays;
4 |
5 | import javax.annotation.Nonnull;
6 |
7 | public class ArrayMissingToStringClass {
8 |
9 | private final byte[] rawData;
10 | private final String name;
11 |
12 | public ArrayMissingToStringClass(@Nonnull final byte[] rawData, @Nonnull final String name) {
13 | super();
14 | this.rawData = Arrays.copyOf(rawData, rawData.length);
15 | this.name = name;
16 | }
17 |
18 | @Override
19 | public String toString() {
20 | // Incomplete toString, not including rawData
21 | return "ArrayMissingToStringClass [name=" + name + "]";
22 | }
23 |
24 | @Nonnull
25 | public byte[] getRawData() {
26 | return Arrays.copyOf(rawData, rawData.length);
27 | }
28 |
29 | @Nonnull
30 | public String getName() {
31 | return name;
32 | }
33 | }
34 |
--------------------------------------------------------------------------------
/src/test/java/samples/effectivejava/item10/BadEnumCompositeClass.java:
--------------------------------------------------------------------------------
1 | package samples.effectivejava.item10;
2 |
3 | import javax.annotation.Nonnull;
4 |
5 | public class BadEnumCompositeClass {
6 |
7 | private final EnumWithState data;
8 | private final String name;
9 |
10 | public BadEnumCompositeClass(@Nonnull final String name,
11 | @Nonnull final EnumWithState data) {
12 | super();
13 | this.name = name;
14 | this.data = data;
15 | }
16 |
17 | @Override
18 | public String toString() {
19 | // Good toString uses all fields
20 | return "BadEnumCompositeClass [name=" + name + "]";
21 | }
22 |
23 | @Nonnull
24 | public EnumWithState getData() {
25 | return data;
26 | }
27 |
28 | }
29 |
--------------------------------------------------------------------------------
/src/test/java/samples/effectivejava/item10/BadToStringCompositeInterestingClass.java:
--------------------------------------------------------------------------------
1 | package samples.effectivejava.item10;
2 |
3 | import javax.annotation.Nonnull;
4 |
5 | public class BadToStringCompositeInterestingClass {
6 |
7 | private final int number;
8 | private final String name;
9 | private final GoodToStringClass gtsc;
10 |
11 | public BadToStringCompositeInterestingClass(final int number, @Nonnull final String name,
12 | @Nonnull final GoodToStringClass gtsc) {
13 | super();
14 | this.number = number;
15 | this.name = name;
16 | this.gtsc = gtsc;
17 | }
18 |
19 | @Override
20 | public String toString() {
21 | // Good toString uses all fields
22 | return "GoodToStringCompositeClass [number=" + number + ", name=" + name + "]";
23 | }
24 |
25 | @Nonnull
26 | public GoodToStringClass getGtsc() {
27 | return gtsc;
28 | }
29 |
30 | }
31 |
--------------------------------------------------------------------------------
/src/test/java/samples/effectivejava/item10/EnumWithState.java:
--------------------------------------------------------------------------------
1 | package samples.effectivejava.item10;
2 |
3 | public enum EnumWithState {
4 | ONE_VALUE(true),
5 | SECOND_VALUE(false);
6 |
7 | private final boolean innerVal;
8 |
9 | private EnumWithState(final boolean val) {
10 | innerVal = val;
11 | }
12 |
13 | public boolean isInnerVal() {
14 | return innerVal;
15 | }
16 | }
17 |
--------------------------------------------------------------------------------
/src/test/java/samples/effectivejava/item10/FakeCompleteToStringClass.java:
--------------------------------------------------------------------------------
1 | package samples.effectivejava.item10;
2 |
3 | public class FakeCompleteToStringClass {
4 |
5 | private final int number;
6 | private final String name;
7 |
8 | public FakeCompleteToStringClass(final int number, final String name) {
9 | super();
10 | this.number = number;
11 | this.name = name;
12 | }
13 |
14 | @Override
15 | public String toString() {
16 | System.out.println(name); // but we ARE accessing name for some other reason
17 | // Incomplete toString, not including name
18 | return "FakeCompleteToStringClass [number=" + number + "]";
19 | }
20 | }
21 |
--------------------------------------------------------------------------------
/src/test/java/samples/effectivejava/item10/GoodMissingArrayToStringClass.java:
--------------------------------------------------------------------------------
1 | package samples.effectivejava.item10;
2 |
3 | import java.util.Arrays;
4 |
5 | import javax.annotation.Nonnull;
6 |
7 | public class GoodMissingArrayToStringClass {
8 |
9 | private final NoFieldClass[] rawData;
10 | private final String name;
11 |
12 | public GoodMissingArrayToStringClass(@Nonnull final NoFieldClass[] rawData, @Nonnull final String name) {
13 | super();
14 | this.rawData = Arrays.copyOf(rawData, rawData.length);
15 | this.name = name;
16 | }
17 |
18 | @Override
19 | public String toString() {
20 | // valid toString, NoFieldClass has no inner state, and needs not be present
21 | return "GoodMissingArrayToStringClass [name=" + name + "]";
22 | }
23 |
24 | @Nonnull
25 | public NoFieldClass[] getRawData() {
26 | return Arrays.copyOf(rawData, rawData.length);
27 | }
28 |
29 | @Nonnull
30 | public String getName() {
31 | return name;
32 | }
33 | }
34 |
--------------------------------------------------------------------------------
/src/test/java/samples/effectivejava/item10/GoodSuppressedToStringComposite.java:
--------------------------------------------------------------------------------
1 | package samples.effectivejava.item10;
2 |
3 | public class GoodSuppressedToStringComposite {
4 |
5 | private final SuppressedToStringClass field;
6 |
7 | public GoodSuppressedToStringComposite(final SuppressedToStringClass field) {
8 | this.field = field;
9 | }
10 |
11 | public SuppressedToStringClass getField() {
12 | return field;
13 | }
14 | }
15 |
--------------------------------------------------------------------------------
/src/test/java/samples/effectivejava/item10/GoodToStringAllIgnoredFieldClass.java:
--------------------------------------------------------------------------------
1 | package samples.effectivejava.item10;
2 |
3 | import javax.annotation.Nonnull;
4 |
5 | import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
6 |
7 | public class GoodToStringAllIgnoredFieldClass {
8 |
9 | @SuppressFBWarnings(value = "MISSING_FIELD_IN_TO_STRING",
10 | justification = "Testing ignored fields")
11 | private final int number;
12 |
13 | @SuppressFBWarnings(value = "MISSING_FIELD_IN_TO_STRING",
14 | justification = "Testing ignored fields")
15 | private final String name;
16 |
17 | public GoodToStringAllIgnoredFieldClass(final int number, @Nonnull final String name) {
18 | super();
19 | this.number = number;
20 | this.name = name;
21 | }
22 |
23 | // No toString override, all fields are ignored
24 | }
25 |
--------------------------------------------------------------------------------
/src/test/java/samples/effectivejava/item10/GoodToStringClass.java:
--------------------------------------------------------------------------------
1 | package samples.effectivejava.item10;
2 |
3 | import javax.annotation.Nonnull;
4 |
5 | public class GoodToStringClass {
6 |
7 | private final int number;
8 | private final String name;
9 |
10 | public GoodToStringClass(final int number, @Nonnull final String name) {
11 | super();
12 | this.number = number;
13 | this.name = name;
14 | }
15 |
16 | @Override
17 | public String toString() {
18 | // Good toString uses all fields
19 | return "GoodToStringClass [number=" + number + ", name=" + name + "]";
20 | }
21 |
22 | }
23 |
--------------------------------------------------------------------------------
/src/test/java/samples/effectivejava/item10/GoodToStringCompositeClass.java:
--------------------------------------------------------------------------------
1 | package samples.effectivejava.item10;
2 |
3 | public class GoodToStringCompositeClass {
4 |
5 | private final int number;
6 | private final String name;
7 | private final NoFieldClass nfc;
8 |
9 | public GoodToStringCompositeClass(final int number, final String name, final NoFieldClass nfc) {
10 | super();
11 | this.number = number;
12 | this.name = name;
13 | this.nfc = nfc;
14 | }
15 |
16 | @Override
17 | public String toString() {
18 | // Good toString uses all fields
19 | return "GoodToStringCompositeClass [number=" + number + ", name=" + name + "]";
20 | }
21 |
22 | public NoFieldClass getNfc() {
23 | return nfc;
24 | }
25 |
26 | }
27 |
--------------------------------------------------------------------------------
/src/test/java/samples/effectivejava/item10/GoodToStringIgnoredFieldClass.java:
--------------------------------------------------------------------------------
1 | package samples.effectivejava.item10;
2 |
3 | import javax.annotation.Nonnull;
4 |
5 | import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
6 |
7 | public class GoodToStringIgnoredFieldClass {
8 |
9 | @SuppressFBWarnings(value = "MISSING_FIELD_IN_TO_STRING",
10 | justification = "Testing ignored fields")
11 | private final int number;
12 |
13 | private final String name;
14 |
15 | public GoodToStringIgnoredFieldClass(final int number, @Nonnull final String name) {
16 | super();
17 | this.number = number;
18 | this.name = name;
19 | }
20 |
21 | @Override
22 | public String toString() {
23 | // Good toString uses all fields not being ignored
24 | return "GoodToStringClass [name=" + name + "]";
25 | }
26 |
27 | }
28 |
--------------------------------------------------------------------------------
/src/test/java/samples/effectivejava/item10/GoodToStringWithStaticClass.java:
--------------------------------------------------------------------------------
1 | package samples.effectivejava.item10;
2 |
3 | public class GoodToStringWithStaticClass {
4 |
5 | public final static String NAME = "GoodToStringWithStaticClass";
6 |
7 | private final int number;
8 |
9 | public GoodToStringWithStaticClass(final int number) {
10 | super();
11 | this.number = number;
12 | }
13 |
14 | @Override
15 | public String toString() {
16 | // Good toString uses all non-static fields
17 | return "GoodToStringClass [number=" + number + "]";
18 | }
19 | }
20 |
--------------------------------------------------------------------------------
/src/test/java/samples/effectivejava/item10/IncompleteToStringClass.java:
--------------------------------------------------------------------------------
1 | package samples.effectivejava.item10;
2 |
3 | import javax.annotation.Nonnull;
4 |
5 | public class IncompleteToStringClass {
6 |
7 | private final int number;
8 | private final String name;
9 |
10 | public IncompleteToStringClass(final int number, @Nonnull final String name) {
11 | super();
12 | this.number = number;
13 | this.name = name;
14 | }
15 |
16 | @Override
17 | public String toString() {
18 | // Incomplete toString, not including name
19 | return "IncompleteToStringClas [number=" + number + "]";
20 | }
21 |
22 | public int getNumber() {
23 | return number;
24 | }
25 |
26 | @Nonnull
27 | public String getName() {
28 | return name;
29 | }
30 | }
31 |
--------------------------------------------------------------------------------
/src/test/java/samples/effectivejava/item10/InnerPublicStaticClass.java:
--------------------------------------------------------------------------------
1 | package samples.effectivejava.item10;
2 |
3 |
4 | // This class has no fields, it doesn't need a toString method
5 | public final class InnerPublicStaticClass {
6 |
7 | public void doNothing() {
8 | // we do nothing!
9 | }
10 |
11 | public static class MyInnerClass {
12 |
13 | }
14 | }
15 |
--------------------------------------------------------------------------------
/src/test/java/samples/effectivejava/item10/MissingToStringClass.java:
--------------------------------------------------------------------------------
1 | package samples.effectivejava.item10;
2 |
3 | import javax.annotation.Nonnull;
4 |
5 | public class MissingToStringClass {
6 |
7 | private final int number;
8 | private final String name;
9 |
10 | public MissingToStringClass(final int number, @Nonnull final String name) {
11 | super();
12 | this.number = number;
13 | this.name = name;
14 | }
15 |
16 | public int getNumber() {
17 | return number;
18 | }
19 |
20 | public String getName() {
21 | return name;
22 | }
23 |
24 | // No toString method!
25 | }
26 |
--------------------------------------------------------------------------------
/src/test/java/samples/effectivejava/item10/NoFieldClass.java:
--------------------------------------------------------------------------------
1 | package samples.effectivejava.item10;
2 |
3 | // This clas has no fields, it doesn't need a toString method
4 | public class NoFieldClass {
5 |
6 | public void doNothing() {
7 | // we do nothing!
8 | }
9 | }
10 |
--------------------------------------------------------------------------------
/src/test/java/samples/effectivejava/item10/NoToStringLibraryFieldClass.java:
--------------------------------------------------------------------------------
1 | package samples.effectivejava.item10;
2 |
3 | import javax.annotation.Nonnull;
4 |
5 | import de.ruedigermoeller.serialization.FSTConfiguration;
6 |
7 | public class NoToStringLibraryFieldClass {
8 |
9 | // A field of type FSTConfiguration, a library with no toString() method.
10 | private final FSTConfiguration aLibraryWithNoToString = FSTConfiguration.getDefaultConfiguration();
11 |
12 | @Nonnull
13 | public FSTConfiguration getaLibraryWithNoToString() {
14 | return aLibraryWithNoToString;
15 | }
16 | }
17 |
--------------------------------------------------------------------------------
/src/test/java/samples/effectivejava/item10/SuppressedToStringClass.java:
--------------------------------------------------------------------------------
1 | package samples.effectivejava.item10;
2 |
3 | import javax.annotation.Nonnull;
4 |
5 | import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
6 |
7 | @SuppressFBWarnings(value = "MISSING_TO_STRING_OVERRIDE", justification = "This is a test")
8 | public class SuppressedToStringClass {
9 |
10 | private final int number;
11 | private final String name;
12 |
13 | public SuppressedToStringClass(final int number, @Nonnull final String name) {
14 | super();
15 | this.number = number;
16 | this.name = name;
17 | }
18 |
19 | public int getNumber() {
20 | return number;
21 | }
22 |
23 | public String getName() {
24 | return name;
25 | }
26 | }
27 |
--------------------------------------------------------------------------------
/src/test/java/samples/effectivejava/item10/ToStringLibraryFieldClass.java:
--------------------------------------------------------------------------------
1 | package samples.effectivejava.item10;
2 |
3 | import javax.annotation.Nonnull;
4 |
5 | import de.ruedigermoeller.heapoff.structs.structtypes.StructString;
6 |
7 | public class ToStringLibraryFieldClass {
8 |
9 | // A field of type StructString, a library with a toString() method.
10 | private final StructString aLibraryWithToString = new StructString(1);
11 |
12 | @Nonnull
13 | public StructString getaLibraryWithToString() {
14 | return aLibraryWithToString;
15 | }
16 | }
17 |
--------------------------------------------------------------------------------
/src/test/java/samples/effectivejava/item8/BadEqualsOverride.java:
--------------------------------------------------------------------------------
1 | package samples.effectivejava.item8;
2 |
3 |
4 | public class BadEqualsOverride extends BaseConcreteClass {
5 | private int version;
6 |
7 | public BadEqualsOverride() {
8 | super(BadEqualsOverride.class.getSimpleName());
9 | version = 1;
10 | }
11 |
12 | public int getVersion() {
13 | return version;
14 | }
15 |
16 | public void setVersion(final int version) {
17 | this.version = version;
18 | }
19 |
20 | @Override
21 | public int hashCode() {
22 | final int prime = 31;
23 | int result = super.hashCode();
24 | result = prime * result + version;
25 | return result;
26 | }
27 |
28 | @Override
29 | public boolean equals(final Object obj) {
30 | if (this == obj) {
31 | return true;
32 | }
33 | if (!super.equals(obj)) {
34 | return false;
35 | }
36 | if (getClass() != obj.getClass()) {
37 | return false;
38 | }
39 | final BadEqualsOverride other = (BadEqualsOverride) obj;
40 | if (version != other.version) {
41 | return false;
42 | }
43 | return true;
44 | }
45 |
46 | @Override
47 | public String toString() {
48 | return "BadEqualsOverride [version=" + version + "]";
49 | }
50 | }
51 |
--------------------------------------------------------------------------------
/src/test/java/samples/effectivejava/item8/BaseConcreteClass.java:
--------------------------------------------------------------------------------
1 | package samples.effectivejava.item8;
2 |
3 | import javax.annotation.Nonnull;
4 |
5 | public class BaseConcreteClass {
6 |
7 | private final String name;
8 |
9 | public BaseConcreteClass(@Nonnull final String name) {
10 | this.name = name;
11 | }
12 |
13 | @Override
14 | public int hashCode() {
15 | final int prime = 31;
16 | int result = 1;
17 | result = prime * result + ((name == null) ? 0 : name.hashCode());
18 | return result;
19 | }
20 |
21 | @Override
22 | public boolean equals(final Object obj) {
23 | if (this == obj) {
24 | return true;
25 | }
26 | if (obj == null) {
27 | return false;
28 | }
29 | if (getClass() != obj.getClass()) {
30 | return false;
31 | }
32 | final BaseConcreteClass other = (BaseConcreteClass) obj;
33 | if (name == null) {
34 | if (other.name != null) {
35 | return false;
36 | }
37 | } else if (!name.equals(other.name)) {
38 | return false;
39 | }
40 | return true;
41 | }
42 |
43 | @Override
44 | public String toString() {
45 | return "BaseConcreteClass [name=" + name + "]";
46 | }
47 |
48 | }
49 |
--------------------------------------------------------------------------------
/src/test/java/samples/effectivejava/item8/BaseNonEqualsConcreteClass.java:
--------------------------------------------------------------------------------
1 | package samples.effectivejava.item8;
2 |
3 | import javax.annotation.Nonnull;
4 |
5 | public class BaseNonEqualsConcreteClass {
6 |
7 | private final String name;
8 |
9 | public BaseNonEqualsConcreteClass(@Nonnull final String name) {
10 | this.name = name;
11 | }
12 |
13 | @Override
14 | public String toString() {
15 | return "BaseNonEqualsConcreteClass [name=" + name + "]";
16 | }
17 |
18 | }
19 |
--------------------------------------------------------------------------------
/src/test/java/samples/effectivejava/item8/GoodEqualsOverride.java:
--------------------------------------------------------------------------------
1 | package samples.effectivejava.item8;
2 |
3 | import javax.annotation.Nonnull;
4 |
5 |
6 | public class GoodEqualsOverride extends BaseNonEqualsConcreteClass {
7 | private String code;
8 |
9 | public GoodEqualsOverride() {
10 | super(GoodEqualsOverride.class.getSimpleName());
11 | code = "example";
12 | }
13 |
14 | @Nonnull
15 | public String getCode() {
16 | return code;
17 | }
18 |
19 | public void setVersion(@Nonnull final String code) {
20 | this.code = code;
21 | }
22 |
23 | @Override
24 | public int hashCode() {
25 | final int prime = 31;
26 | int result = super.hashCode();
27 | result = prime * result + code.hashCode();
28 | return result;
29 | }
30 |
31 | @Override
32 | public boolean equals(final Object obj) {
33 | if (this == obj) {
34 | return true;
35 | }
36 | if (!super.equals(obj)) {
37 | return false;
38 | }
39 | if (getClass() != obj.getClass()) {
40 | return false;
41 | }
42 | final GoodEqualsOverride other = (GoodEqualsOverride) obj;
43 | if (!code.equals(other.code)) {
44 | return false;
45 | }
46 | return true;
47 | }
48 |
49 | @Override
50 | public String toString() {
51 | return "GoodEqualsOverride [code=" + code + "]";
52 | }
53 | }
54 |
--------------------------------------------------------------------------------
/src/test/java/samples/findbugs/DocumentedSuppressFBWarnings.java:
--------------------------------------------------------------------------------
1 | package samples.findbugs;
2 |
3 | import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
4 |
5 | public class DocumentedSuppressFBWarnings {
6 | @SuppressFBWarnings(justification = "only for unit test.")
7 | public void method() {
8 | }
9 | }
10 |
--------------------------------------------------------------------------------
/src/test/java/samples/findbugs/DocumentedSuppressWarnings.java:
--------------------------------------------------------------------------------
1 | package samples.findbugs;
2 |
3 | import edu.umd.cs.findbugs.annotations.SuppressWarnings;
4 |
5 | @java.lang.SuppressWarnings("deprecation")
6 | @SuppressWarnings(justification = "only for unit test.")
7 | public class DocumentedSuppressWarnings {
8 |
9 | }
10 |
--------------------------------------------------------------------------------
/src/test/java/samples/findbugs/EqualsContainsHashCode.java:
--------------------------------------------------------------------------------
1 | package samples.findbugs;
2 |
3 | public class EqualsContainsHashCode {
4 |
5 | private static final int LONG_SHIFT_VALUE = 32;
6 |
7 | private final long id;
8 | private final long version;
9 |
10 | public EqualsContainsHashCode(final long id, final long version) {
11 | this.id = id;
12 | this.version = version;
13 | }
14 |
15 | @Override
16 | public int hashCode() {
17 | final int prime = 31;
18 | int result = 1;
19 | result = prime * result + (int) (id ^ (id >>> LONG_SHIFT_VALUE));
20 | return result;
21 | }
22 |
23 | @Override
24 | public boolean equals(final Object obj) {
25 | if (this == obj) {
26 | return true;
27 | }
28 | if (obj == null) {
29 | return false;
30 | }
31 | if (getClass() != obj.getClass()) {
32 | return false;
33 | }
34 | final EqualsContainsHashCode other = (EqualsContainsHashCode) obj;
35 | if (id != other.id) {
36 | return false;
37 | }
38 | if (version != other.version) {
39 | return false;
40 | }
41 | return true;
42 | }
43 |
44 | @Override
45 | public String toString() {
46 | return "EqualsContainsHashCode [id=" + id + ", version=" + version + "]";
47 | }
48 |
49 | }
50 |
--------------------------------------------------------------------------------
/src/test/java/samples/findbugs/EqualsHashCodeDifferentFields.java:
--------------------------------------------------------------------------------
1 | package samples.findbugs;
2 |
3 | public class EqualsHashCodeDifferentFields {
4 |
5 | private static final int LONG_SHIFT_VALUE = 32;
6 | private final long id;
7 | private final long version;
8 | private final long type;
9 |
10 | public EqualsHashCodeDifferentFields(final long id, final long version, final long type) {
11 | this.id = id;
12 | this.version = version;
13 | this.type = type;
14 | }
15 |
16 | @Override
17 | public int hashCode() {
18 | final int prime = 31;
19 | int result = 1;
20 | result = prime * result + (int) (type ^ (type >>> LONG_SHIFT_VALUE));
21 | result = prime * result + (int) (version ^ (version >>> LONG_SHIFT_VALUE));
22 | return result;
23 | }
24 |
25 | @Override
26 | public boolean equals(final Object obj) {
27 | if (this == obj) {
28 | return true;
29 | }
30 | if (obj == null) {
31 | return false;
32 | }
33 | if (getClass() != obj.getClass()) {
34 | return false;
35 | }
36 | final EqualsHashCodeDifferentFields other = (EqualsHashCodeDifferentFields) obj;
37 | if (id != other.id) {
38 | return false;
39 | }
40 | if (type != other.type) {
41 | return false;
42 | }
43 | return true;
44 | }
45 |
46 | @Override
47 | public String toString() {
48 | return "EqualsHashCodeDifferentFields [id=" + id + ", version=" + version + ", type=" + type + "]";
49 | }
50 |
51 | }
52 |
--------------------------------------------------------------------------------
/src/test/java/samples/findbugs/GoodEqualsHashCodeImplementation.java:
--------------------------------------------------------------------------------
1 | package samples.findbugs;
2 |
3 | import java.util.List;
4 |
5 | import javax.annotation.Nonnull;
6 |
7 | public class GoodEqualsHashCodeImplementation {
8 |
9 | private static final int LONG_SHIFT_VALUE = 32;
10 | private final long id;
11 | private final List versions;
12 |
13 | public GoodEqualsHashCodeImplementation(final long id, @Nonnull final List versions) {
14 | this.id = id;
15 | this.versions = versions;
16 | }
17 |
18 | @Override
19 | public int hashCode() {
20 | final int prime = 31;
21 | int result = 1;
22 | result = prime * result + (int) (id ^ (id >>> LONG_SHIFT_VALUE));
23 | result = prime * result + ((versions == null) ? 0 : versions.hashCode());
24 | return result;
25 | }
26 |
27 | @Override
28 | public boolean equals(final Object obj) {
29 | if (this == obj) {
30 | return true;
31 | }
32 | if (obj == null) {
33 | return false;
34 | }
35 | if (getClass() != obj.getClass()) {
36 | return false;
37 | }
38 | final GoodEqualsHashCodeImplementation other = (GoodEqualsHashCodeImplementation) obj;
39 | if (id != other.id) {
40 | return false;
41 | }
42 | if (versions == null) {
43 | if (other.versions != null) {
44 | return false;
45 | }
46 | } else if (!versions.equals(other.versions)) {
47 | return false;
48 | }
49 | return true;
50 | }
51 |
52 | @Override
53 | public String toString() {
54 | return "GoodEqualsHashCodeImplementation [id=" + id + ", versions=" + versions + "]";
55 | }
56 |
57 | }
58 |
--------------------------------------------------------------------------------
/src/test/java/samples/findbugs/HashCodeContainsEquals.java:
--------------------------------------------------------------------------------
1 | package samples.findbugs;
2 |
3 | public class HashCodeContainsEquals {
4 |
5 | private static final int LONG_SHIFT_VALUE = 32;
6 | private final long id;
7 | private final long version;
8 |
9 | public HashCodeContainsEquals(final long id, final long version) {
10 | this.id = id;
11 | this.version = version;
12 | }
13 |
14 | @Override
15 | public int hashCode() {
16 | final int prime = 31;
17 | int result = 1;
18 | result = prime * result + (int) (id ^ (id >>> LONG_SHIFT_VALUE));
19 | result = prime * result + (int) (version ^ (version >>> LONG_SHIFT_VALUE));
20 | return result;
21 | }
22 |
23 | @Override
24 | public boolean equals(final Object obj) {
25 | if (this == obj) {
26 | return true;
27 | }
28 | if (obj == null) {
29 | return false;
30 | }
31 | if (getClass() != obj.getClass()) {
32 | return false;
33 | }
34 | final HashCodeContainsEquals other = (HashCodeContainsEquals) obj;
35 | if (id != other.id) {
36 | return false;
37 | }
38 | return true;
39 | }
40 |
41 | @Override
42 | public String toString() {
43 | return "HashCodeContainsEquals [id=" + id + ", version=" + version + "]";
44 | }
45 |
46 | }
47 |
--------------------------------------------------------------------------------
/src/test/java/samples/findbugs/NoEqualsHashCode.java:
--------------------------------------------------------------------------------
1 | package samples.findbugs;
2 |
3 | import javax.annotation.Nonnull;
4 |
5 | public class NoEqualsHashCode {
6 |
7 | private final long id;
8 | private final String description;
9 |
10 | public NoEqualsHashCode(final long id, @Nonnull final String description) {
11 | this.id = id;
12 | this.description = description;
13 | }
14 |
15 | public long getId() {
16 | return id;
17 | }
18 |
19 | @Nonnull
20 | public String getDescription() {
21 | return description;
22 | }
23 |
24 | @Override
25 | public String toString() {
26 | return "NoEqualsHashCode [id=" + id + ", description=" + description + "]";
27 | }
28 |
29 | }
30 |
--------------------------------------------------------------------------------
/src/test/java/samples/findbugs/OnlyEqualsImplementation.java:
--------------------------------------------------------------------------------
1 | package samples.findbugs;
2 |
3 | import java.util.List;
4 |
5 | import javax.annotation.Nonnull;
6 |
7 | @SuppressWarnings({ "PMD.OverrideBothEqualsAndHashcode", "checkstyle:equalshashcode" })
8 | public class OnlyEqualsImplementation {
9 |
10 | private final List versions;
11 |
12 | public OnlyEqualsImplementation(@Nonnull final List versions) {
13 | this.versions = versions;
14 | }
15 |
16 | @Override
17 | public boolean equals(final Object obj) {
18 | if (this == obj) {
19 | return true;
20 | }
21 | if (obj == null) {
22 | return false;
23 | }
24 | if (getClass() != obj.getClass()) {
25 | return false;
26 | }
27 | final OnlyEqualsImplementation other = (OnlyEqualsImplementation) obj;
28 | if (versions == null) {
29 | if (other.versions != null) {
30 | return false;
31 | }
32 | } else if (!versions.equals(other.versions)) {
33 | return false;
34 | }
35 | return true;
36 | }
37 |
38 | @Override
39 | public String toString() {
40 | return "OnlyEqualsImplementation [versions=" + versions + "]";
41 | }
42 |
43 | }
44 |
--------------------------------------------------------------------------------
/src/test/java/samples/findbugs/SubclassOfBadEqualsHashCode.java:
--------------------------------------------------------------------------------
1 | package samples.findbugs;
2 |
3 | import javax.annotation.Nonnull;
4 |
5 | public class SubclassOfBadEqualsHashCode extends HashCodeContainsEquals {
6 |
7 | private final String description;
8 |
9 | public SubclassOfBadEqualsHashCode(final long id, final long version, @Nonnull final String description) {
10 | super(id, version);
11 | this.description = description;
12 | }
13 |
14 | @Nonnull
15 | public String getDescription() {
16 | return description;
17 | }
18 |
19 | @Override
20 | @Nonnull
21 | public String toString() {
22 | return "SubclassOfBadEqualsHashCode [description=" + description + "]";
23 | }
24 |
25 | }
26 |
--------------------------------------------------------------------------------
/src/test/java/samples/findbugs/UndocumentedSuppressFBWarnings.java:
--------------------------------------------------------------------------------
1 | package samples.findbugs;
2 |
3 | import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
4 |
5 | public class UndocumentedSuppressFBWarnings {
6 | @SuppressFBWarnings("SF_SWITCH_NO_DEFAULT")
7 | public void method() {
8 | }
9 | }
10 |
--------------------------------------------------------------------------------
/src/test/java/samples/findbugs/UndocumentedSuppressWarnings.java:
--------------------------------------------------------------------------------
1 | package samples.findbugs;
2 |
3 | import edu.umd.cs.findbugs.annotations.SuppressWarnings;
4 |
5 | @java.lang.SuppressWarnings("deprecation")
6 | @SuppressWarnings("SF_SWITCH_NO_DEFAULT")
7 | public class UndocumentedSuppressWarnings {
8 |
9 | }
10 |
--------------------------------------------------------------------------------
/src/test/java/samples/findbugs/jdk/UselessStringValueOfCall.java:
--------------------------------------------------------------------------------
1 | package samples.findbugs.jdk;
2 |
3 | import javax.annotation.Nonnull;
4 |
5 | public class UselessStringValueOfCall {
6 |
7 | private final DummyObject dummy = new DummyObject();
8 |
9 | @Nonnull
10 | public String getStringValueOfString() {
11 | return String.valueOf("some string");
12 | }
13 |
14 | @Nonnull
15 | public String getStringValueOfDummyString() {
16 | return String.valueOf(dummy.getString());
17 | }
18 |
19 | @Nonnull
20 | public String getString() {
21 | return "other string";
22 | }
23 |
24 | @Nonnull
25 | public String getStringValueOfPrimitiveInteger() {
26 | return String.valueOf(2);
27 | }
28 |
29 | /**
30 | * Test concatenated string
31 | * @param text the text to concatenate
32 | */
33 | public void concatenatedStringFromParam(@Nonnull final String text) {
34 | new StringBuilder("some text").append(text + " other text");
35 | }
36 |
37 | /**
38 | * Test concatenated local string
39 | */
40 | public void concatenatedLocalString() {
41 | final String text = " dummy ";
42 | new StringBuilder("some").append(text + "text");
43 | }
44 |
45 | /**
46 | * Test string from parameter in a String.valueOf
47 | * @param text the text to concatenate
48 | * @return the string concatenated
49 | */
50 | @Nonnull
51 | public String stringFromParamInValueOf(@Nonnull final String text) {
52 | return String.valueOf(text + " some text").toString();
53 | }
54 |
55 | private static class DummyObject {
56 | public String getString() {
57 | return "dummy string";
58 | }
59 | }
60 | }
--------------------------------------------------------------------------------
/src/test/java/samples/findbugs/jdk/patterncompile/NonStaticPatternCompile.java:
--------------------------------------------------------------------------------
1 | package samples.findbugs.jdk.patterncompile;
2 |
3 | import java.util.regex.Matcher;
4 | import java.util.regex.Pattern;
5 |
6 | import javax.annotation.Nonnull;
7 |
8 | public class NonStaticPatternCompile {
9 |
10 | private static final String STRING_REGEX = "[ade]";
11 |
12 | /**
13 | * Test non static Pattern.compile
14 | * @return a matcher
15 | */
16 | @Nonnull
17 | public Matcher testReportNonStaticPatternCompile() {
18 | final String test = "abecedario";
19 | final Pattern ptrn = Pattern.compile("[abc]");
20 | return ptrn.matcher(test);
21 | }
22 |
23 | /**
24 | * Test non static Pattern.compile with static regex
25 | * @return a matcher
26 | */
27 | @Nonnull
28 | public Matcher testReportNonStaticPatternCompileWithStaticRegex() {
29 | final String test = "cabecera";
30 | final Pattern patcom = Pattern.compile(STRING_REGEX);
31 | return patcom.matcher(test);
32 | }
33 |
34 | /**
35 | * Test non static Pattern.compile with local regex
36 | * @return a matcher
37 | */
38 | @Nonnull
39 | public Matcher testReportNonStaticPatternCompileWithFinalLocalRegex() {
40 | final String regex = "[bcd]";
41 | final String test = "cabecera";
42 | final String regex2 = regex + "[e]";
43 | final Pattern pattern = Pattern.compile(regex2);
44 | return pattern.matcher(test);
45 | }
46 |
47 | /**
48 | * Test non static Pattern.compile with non-final local regex
49 | * @return a matcher
50 | */
51 | @SuppressWarnings({"checkstyle:finallocalvariable", "PMD.LocalVariableCouldBeFinal"})
52 | @Nonnull
53 | public Matcher testNeverReportNonStaticPatternCompileWithNonFinalLocalRegex() {
54 | final String regex = "[fgt]";
55 | String regex2 = regex;
56 | final String test = "foddgata";
57 | final Pattern pattern = Pattern.compile(regex2);
58 | return pattern.matcher(test);
59 | }
60 |
61 | /**
62 | * Test non static Pattern.compile with final regex parameter
63 | * @param regex the regex
64 | * @return a matcher
65 | */
66 | @Nonnull
67 | public Matcher testNeverReportNonStaticPatternCompileWithFinalRegexParameter(@Nonnull final String regex) {
68 | final Pattern ptrn = Pattern.compile(regex);
69 | return ptrn.matcher("test");
70 | }
71 |
72 | /**
73 | * Test non static Pattern.compile with non final regex parameter
74 | * @param regex the regex
75 | * @return a matcher
76 | */
77 | @SuppressWarnings("checkstyle:finalparameters")
78 | @Nonnull
79 | public Matcher testNeverReportNonStaticPatternCompileWithNonFinalRegexParameter(@Nonnull String regex) {
80 | final Pattern ptrn = Pattern.compile(regex);
81 | return ptrn.matcher("test");
82 | }
83 |
84 | /**
85 | * Test non static Pattern.compile with regex from object
86 | * @return a matcher
87 | */
88 | @Nonnull
89 | public Matcher testNeverReportNonStaticPatternCompileWithRegexFromObject() {
90 | final String test = "vecindario";
91 | final DummyRegex dummyRegex = new DummyRegex();
92 | final Pattern pattern = Pattern.compile(dummyRegex.getRegex());
93 | return pattern.matcher(test);
94 | }
95 |
96 | /**
97 | * Test pattern compile with a concatenated regex
98 | * @param email the email
99 | * @return The pattern with the compiled regex
100 | */
101 | @Nonnull
102 | public Pattern testPatternCompileWithAConcatenatedRegex(@Nonnull final String email) {
103 | final String[] parts = email.split("@");
104 | return Pattern.compile("^" + parts[0] + "\\+([^@]+)@" + parts[1] + "$");
105 | }
106 |
107 | private static class DummyRegex {
108 | public String getRegex() {
109 | return "[cdv]";
110 | }
111 | }
112 | }
--------------------------------------------------------------------------------
/src/test/java/samples/findbugs/jdk/patterncompile/StaticPatternCompile.java:
--------------------------------------------------------------------------------
1 | package samples.findbugs.jdk.patterncompile;
2 |
3 | import java.util.regex.Matcher;
4 | import java.util.regex.Pattern;
5 |
6 | import javax.annotation.Nonnull;
7 |
8 | public class StaticPatternCompile {
9 |
10 | private static final String STRING_REGEX = "[def]";
11 | private static final Pattern PATTERN = Pattern.compile(STRING_REGEX);
12 |
13 | /**
14 | * Test static Pattern.compile
15 | * @return a matcher
16 | */
17 | @Nonnull
18 | public Matcher testStaticPatternCompile() {
19 | final String test = "defecto";
20 | return PATTERN.matcher(test);
21 | }
22 | }
--------------------------------------------------------------------------------
/src/test/java/samples/guava/ClassWhichCallsNormalMethod.java:
--------------------------------------------------------------------------------
1 | package samples.guava;
2 |
3 | public class ClassWhichCallsNormalMethod {
4 | public void method() {
5 | new MethodWithoutVisibleForTesting().method();
6 | }
7 |
8 | public void anotherMethod() {
9 | System.out.println("this method invoking has no problem, because package isn't same.");
10 | method();
11 | }
12 | }
13 |
--------------------------------------------------------------------------------
/src/test/java/samples/guava/ClassWhichCallsVisibleMethodForTesting.java:
--------------------------------------------------------------------------------
1 | package samples.guava;
2 |
3 | public class ClassWhichCallsVisibleMethodForTesting {
4 | public void method() {
5 | new MethodWithVisibleForTesting().method();
6 | }
7 | }
8 |
--------------------------------------------------------------------------------
/src/test/java/samples/guava/JUnit3Test.java:
--------------------------------------------------------------------------------
1 | /*
2 | * (c) tolina GmbH, 2014
3 | */
4 | package samples.guava;
5 |
6 | import jp.co.worksap.oss.findbugs.guava.UnexpectedAccessDetector;
7 | import junit.framework.TestCase;
8 |
9 | import org.junit.Ignore;
10 |
11 | /**
12 | * Class used only for {@link UnexpectedAccessDetector}-tests
13 | * @author Juan Martin Sotuyo Dodero
14 | *
15 | */
16 | @Ignore("Not a real test, but used as test sample")
17 | public class JUnit3Test extends TestCase {
18 |
19 | void testCallVisibleForTestingMethod() {
20 | new MethodWithVisibleForTesting().method();
21 | }
22 | }
--------------------------------------------------------------------------------
/src/test/java/samples/guava/JUnit4Test.java:
--------------------------------------------------------------------------------
1 | /*
2 | * (c) tolina GmbH, 2014
3 | */
4 | package samples.guava;
5 |
6 | import org.junit.After;
7 | import org.junit.Before;
8 | import org.junit.BeforeClass;
9 | import org.junit.Ignore;
10 | import org.junit.Test;
11 |
12 | /**
13 | * Class used only for
14 | * {@link jp.co.worksap.oss.findbugs.guava.UnexpectedAccessDetector}-tests
15 | *
16 | * @author tolina GmbH
17 | *
18 | */
19 | @Ignore("Not a real test, but used as test sample")
20 | public class JUnit4Test {
21 |
22 | @Before
23 | void setUp() {
24 | new MethodWithVisibleForTesting().method();
25 | }
26 |
27 | @BeforeClass
28 | void onlyOnce() {
29 | new MethodWithVisibleForTesting().method();
30 | }
31 |
32 | @After
33 | void tearDown() {
34 | new MethodWithVisibleForTesting().method();
35 | }
36 |
37 | @Test
38 | void test() {
39 | new MethodWithVisibleForTesting().method();
40 | }
41 | }
42 |
--------------------------------------------------------------------------------
/src/test/java/samples/guava/MethodWithVisibleForTesting.java:
--------------------------------------------------------------------------------
1 | package samples.guava;
2 |
3 | import com.google.common.annotations.VisibleForTesting;
4 |
5 | public class MethodWithVisibleForTesting {
6 | @VisibleForTesting
7 | void method() {
8 | }
9 | }
10 |
--------------------------------------------------------------------------------
/src/test/java/samples/guava/MethodWithoutVisibleForTesting.java:
--------------------------------------------------------------------------------
1 | package samples.guava;
2 |
3 | public class MethodWithoutVisibleForTesting {
4 | void method() {
5 | }
6 | }
7 |
--------------------------------------------------------------------------------
/src/test/java/samples/jpa/ColumnWithLength.java:
--------------------------------------------------------------------------------
1 | package samples.jpa;
2 |
3 | import javax.persistence.Column;
4 |
5 | public class ColumnWithLength {
6 | @Column(length = 100)
7 | private String name;
8 |
9 | public String getName() {
10 | return name;
11 | }
12 | }
13 |
--------------------------------------------------------------------------------
/src/test/java/samples/jpa/ColumnWithLongLengthAndLob.java:
--------------------------------------------------------------------------------
1 | package samples.jpa;
2 |
3 | import javax.persistence.Column;
4 | import javax.persistence.Lob;
5 |
6 | public class ColumnWithLongLengthAndLob {
7 | @Lob
8 | @Column(length = 10000)
9 | private String name;
10 |
11 | public String getName() {
12 | return name;
13 | }
14 | }
15 |
--------------------------------------------------------------------------------
/src/test/java/samples/jpa/ColumnWithNegativeLength.java:
--------------------------------------------------------------------------------
1 | package samples.jpa;
2 |
3 | import javax.persistence.Column;
4 |
5 | public class ColumnWithNegativeLength {
6 | @Column(length = -1)
7 | private String name;
8 |
9 | public String getName() {
10 | return name;
11 | }
12 | }
13 |
--------------------------------------------------------------------------------
/src/test/java/samples/jpa/ColumnWithNullable.java:
--------------------------------------------------------------------------------
1 | package samples.jpa;
2 |
3 | import javax.persistence.Column;
4 |
5 | public class ColumnWithNullable {
6 | @Column(nullable = false)
7 | private String name;
8 |
9 | public String getName() {
10 | return name;
11 | }
12 | }
13 |
--------------------------------------------------------------------------------
/src/test/java/samples/jpa/ColumnWithTooLongLength.java:
--------------------------------------------------------------------------------
1 | package samples.jpa;
2 |
3 | import javax.persistence.Column;
4 |
5 | public class ColumnWithTooLongLength {
6 | @Column(length = 10000)
7 | private String name;
8 |
9 | public String getName() {
10 | return name;
11 | }
12 | }
13 |
--------------------------------------------------------------------------------
/src/test/java/samples/jpa/ColumnWithoutElement.java:
--------------------------------------------------------------------------------
1 | package samples.jpa;
2 |
3 | import javax.persistence.Column;
4 |
5 | public class ColumnWithoutElement {
6 | @Column
7 | private String name;
8 |
9 | public String getName() {
10 | return name;
11 | }
12 | }
13 |
--------------------------------------------------------------------------------
/src/test/java/samples/jpa/GetterWithLongLengthAndLob.java:
--------------------------------------------------------------------------------
1 | package samples.jpa;
2 |
3 | import javax.persistence.Column;
4 | import javax.persistence.Lob;
5 |
6 | public class GetterWithLongLengthAndLob {
7 | private String name;
8 |
9 | @Lob
10 | @Column(length = 10000)
11 | public String getName() {
12 | return name;
13 | }
14 | }
15 |
--------------------------------------------------------------------------------
/src/test/java/samples/jpa/GetterWithTooLongLength.java:
--------------------------------------------------------------------------------
1 | package samples.jpa;
2 |
3 | import javax.persistence.Column;
4 |
5 | public class GetterWithTooLongLength {
6 | private String name;
7 |
8 | @Column(length = 10000)
9 | public String getName() {
10 | return name;
11 | }
12 | }
13 |
--------------------------------------------------------------------------------
/src/test/java/samples/jpa/GetterWithoutElement.java:
--------------------------------------------------------------------------------
1 | package samples.jpa;
2 |
3 | import javax.persistence.Column;
4 |
5 | public class GetterWithoutElement {
6 | private String name;
7 |
8 | @Column
9 | public String getName() {
10 | return name;
11 | }
12 | }
13 |
--------------------------------------------------------------------------------
/src/test/java/samples/jpa/LongColumnName.java:
--------------------------------------------------------------------------------
1 | package samples.jpa;
2 |
3 | import javax.persistence.Column;
4 | import javax.persistence.Entity;
5 | import javax.persistence.Id;
6 |
7 | @Entity
8 | public class LongColumnName {
9 | @Id
10 | private long id;
11 |
12 | @Column(name = "columnname_longer_than_30_bytes")
13 | private String value;
14 |
15 | public long getId() {
16 | return id;
17 | }
18 |
19 | public void setId(long id) {
20 | this.id = id;
21 | }
22 |
23 | public String getValue() {
24 | return value;
25 | }
26 |
27 | public void setValue(String value) {
28 | this.value = value;
29 | }
30 |
31 | }
32 |
--------------------------------------------------------------------------------
/src/test/java/samples/jpa/LongColumnNameByAnnotatedMethod.java:
--------------------------------------------------------------------------------
1 | package samples.jpa;
2 |
3 | import javax.persistence.Column;
4 | import javax.persistence.Entity;
5 | import javax.persistence.Id;
6 |
7 | @Entity
8 | public class LongColumnNameByAnnotatedMethod {
9 | @Id
10 | private long id;
11 |
12 | private String longColumnNameByAnnotatedMethod;
13 |
14 | public long getId() {
15 | return id;
16 | }
17 |
18 | public void setId(long id) {
19 | this.id = id;
20 | }
21 |
22 | @Column
23 | public String getSomething() { // Plugin has to alert even if method name is short
24 | return longColumnNameByAnnotatedMethod;
25 | }
26 |
27 | public void setLongColumnNameByAnnotatedMethod(
28 | String longColumnNameByAnnotatedMethod) {
29 | this.longColumnNameByAnnotatedMethod = longColumnNameByAnnotatedMethod;
30 | }
31 |
32 | }
33 |
--------------------------------------------------------------------------------
/src/test/java/samples/jpa/LongColumnNameWithoutAnnotationParameter.java:
--------------------------------------------------------------------------------
1 | package samples.jpa;
2 |
3 | import javax.persistence.Column;
4 | import javax.persistence.Entity;
5 | import javax.persistence.Id;
6 |
7 | @Entity
8 | public class LongColumnNameWithoutAnnotationParameter {
9 | @Id
10 | private long id;
11 |
12 | @Column
13 | private String longColumnNameWithoutAnnotationParameter;
14 |
15 | public long getId() {
16 | return id;
17 | }
18 |
19 | public void setId(long id) {
20 | this.id = id;
21 | }
22 |
23 | public String getLongColumnNameWithoutAnnotationParameter() {
24 | return longColumnNameWithoutAnnotationParameter;
25 | }
26 |
27 | public void setLongColumnNameWithoutAnnotationParameter(
28 | String longColumnNameWithoutAnnotationParameter) {
29 | this.longColumnNameWithoutAnnotationParameter = longColumnNameWithoutAnnotationParameter;
30 | }
31 |
32 | }
33 |
--------------------------------------------------------------------------------
/src/test/java/samples/jpa/LongIndexNameForHibernate.java:
--------------------------------------------------------------------------------
1 | package samples.jpa;
2 |
3 | import javax.persistence.Column;
4 | import javax.persistence.Entity;
5 | import javax.persistence.Id;
6 |
7 | import org.hibernate.annotations.Index;
8 |
9 | @Entity
10 | public class LongIndexNameForHibernate {
11 | @Id
12 | private long id;
13 |
14 | @Column(nullable = true)
15 | @Index(name = "index_name_longer_than_30_bytes")
16 | private String value;
17 |
18 | public long getId() {
19 | return id;
20 | }
21 |
22 | public void setId(long id) {
23 | this.id = id;
24 | }
25 |
26 | public String getValue() {
27 | return value;
28 | }
29 |
30 | public void setValue(String value) {
31 | this.value = value;
32 | }
33 |
34 | }
35 |
--------------------------------------------------------------------------------
/src/test/java/samples/jpa/LongIndexNameForOpenJPA.java:
--------------------------------------------------------------------------------
1 | package samples.jpa;
2 |
3 | import javax.persistence.Column;
4 | import javax.persistence.Entity;
5 | import javax.persistence.Id;
6 |
7 | import org.apache.openjpa.persistence.jdbc.Index;
8 |
9 | @Entity
10 | public class LongIndexNameForOpenJPA {
11 | @Id
12 | private long id;
13 |
14 | @Column(nullable = true)
15 | @Index(name = "index_name_longer_than_30_bytes")
16 | private String value;
17 |
18 | public long getId() {
19 | return id;
20 | }
21 |
22 | public void setId(long id) {
23 | this.id = id;
24 | }
25 |
26 | public String getValue() {
27 | return value;
28 | }
29 |
30 | public void setValue(String value) {
31 | this.value = value;
32 | }
33 |
34 | }
35 |
--------------------------------------------------------------------------------
/src/test/java/samples/jpa/LongTableName.java:
--------------------------------------------------------------------------------
1 | package samples.jpa;
2 |
3 | import javax.persistence.Entity;
4 | import javax.persistence.Id;
5 |
6 | @Entity(name="table_name_longer_than_30_bytes")
7 | public class LongTableName {
8 |
9 | @Id
10 | private long id;
11 |
12 | public LongTableName(long id) {
13 | this.id = id;
14 | }
15 |
16 | public long getId() {
17 | return id;
18 | }
19 |
20 | }
21 |
--------------------------------------------------------------------------------
/src/test/java/samples/jpa/LongTableNameWithoutAnnotationParameter.java:
--------------------------------------------------------------------------------
1 | package samples.jpa;
2 |
3 | import javax.persistence.Entity;
4 | import javax.persistence.Id;
5 |
6 | @Entity
7 | public class LongTableNameWithoutAnnotationParameter {
8 |
9 | @Id
10 | private long id;
11 |
12 | public LongTableNameWithoutAnnotationParameter(long id) {
13 | this.id = id;
14 | }
15 |
16 | public long getId() {
17 | return id;
18 | }
19 |
20 | }
21 |
--------------------------------------------------------------------------------
/src/test/java/samples/jpa/NonNullablePrimitiveColumn.java:
--------------------------------------------------------------------------------
1 | package samples.jpa;
2 |
3 | import javax.persistence.Column;
4 | import javax.persistence.Entity;
5 |
6 | @Entity
7 | public class NonNullablePrimitiveColumn {
8 | @Column(nullable = false)
9 | private boolean booleanValue;
10 |
11 | @Column(nullable = false)
12 | private byte byteValue;
13 |
14 | @Column(nullable = false)
15 | private short shortValue;
16 |
17 | @Column(nullable = false)
18 | private int intValue;
19 |
20 | @Column(nullable = false)
21 | private long longValue;
22 |
23 | @Column(nullable = false)
24 | private float floatValue;
25 |
26 | @Column(nullable = false)
27 | private double doubleValue;
28 | }
29 |
--------------------------------------------------------------------------------
/src/test/java/samples/jpa/NullableBooleanColumn.java:
--------------------------------------------------------------------------------
1 | package samples.jpa;
2 |
3 | import javax.persistence.Column;
4 | import javax.persistence.Entity;
5 |
6 | @Entity
7 | public class NullableBooleanColumn {
8 | @Column(nullable = true)
9 | private boolean booleanValue;
10 | }
11 |
--------------------------------------------------------------------------------
/src/test/java/samples/jpa/NullableBooleanGetter.java:
--------------------------------------------------------------------------------
1 | package samples.jpa;
2 |
3 | import javax.persistence.Column;
4 | import javax.persistence.Entity;
5 |
6 | @Entity
7 | public class NullableBooleanGetter {
8 | private boolean booleanValue;
9 |
10 | @Column(nullable = true)
11 | public boolean isBooleanValue() {
12 | return booleanValue;
13 | }
14 | }
15 |
--------------------------------------------------------------------------------
/src/test/java/samples/jpa/NullableByteColumn.java:
--------------------------------------------------------------------------------
1 | package samples.jpa;
2 |
3 | import javax.persistence.Column;
4 | import javax.persistence.Entity;
5 |
6 | @Entity
7 | public class NullableByteColumn {
8 | @Column(nullable = true)
9 | private byte byteValue;
10 | }
11 |
--------------------------------------------------------------------------------
/src/test/java/samples/jpa/NullableDoubleColumn.java:
--------------------------------------------------------------------------------
1 | package samples.jpa;
2 |
3 | import javax.persistence.Column;
4 | import javax.persistence.Entity;
5 |
6 | @Entity
7 | public class NullableDoubleColumn {
8 | @Column(nullable = true)
9 | private double doubleValue;
10 | }
11 |
--------------------------------------------------------------------------------
/src/test/java/samples/jpa/NullableFloatColumn.java:
--------------------------------------------------------------------------------
1 | package samples.jpa;
2 |
3 | import javax.persistence.Column;
4 | import javax.persistence.Entity;
5 |
6 | @Entity
7 | public class NullableFloatColumn {
8 | @Column(nullable = true)
9 | private float floatValue;
10 | }
11 |
--------------------------------------------------------------------------------
/src/test/java/samples/jpa/NullableIntColumn.java:
--------------------------------------------------------------------------------
1 | package samples.jpa;
2 |
3 | import javax.persistence.Column;
4 | import javax.persistence.Entity;
5 |
6 | @Entity
7 | public class NullableIntColumn {
8 | @Column(nullable = true)
9 | private int intValue;
10 | }
11 |
--------------------------------------------------------------------------------
/src/test/java/samples/jpa/NullableLongColumn.java:
--------------------------------------------------------------------------------
1 | package samples.jpa;
2 |
3 | import javax.persistence.Column;
4 | import javax.persistence.Entity;
5 |
6 | @Entity
7 | public class NullableLongColumn {
8 | @Column(nullable = true)
9 | private long longValue;
10 | }
11 |
--------------------------------------------------------------------------------
/src/test/java/samples/jpa/NullableShortColumn.java:
--------------------------------------------------------------------------------
1 | package samples.jpa;
2 |
3 | import javax.persistence.Column;
4 | import javax.persistence.Entity;
5 |
6 | @Entity
7 | public class NullableShortColumn {
8 | @Column(nullable = true)
9 | private short shortValue;
10 | }
11 |
--------------------------------------------------------------------------------
/src/test/java/samples/jpa/ShortColumnName.java:
--------------------------------------------------------------------------------
1 | package samples.jpa;
2 |
3 | import javax.persistence.Column;
4 | import javax.persistence.Entity;
5 | import javax.persistence.Id;
6 |
7 | @Entity
8 | public class ShortColumnName {
9 | @Id
10 | private long id;
11 |
12 | @Column(name = "col_name_shorter_than_31_bytes")
13 | private String value;
14 |
15 | public long getId() {
16 | return id;
17 | }
18 |
19 | public void setId(long id) {
20 | this.id = id;
21 | }
22 |
23 | public String getValue() {
24 | return value;
25 | }
26 |
27 | public void setValue(String value) {
28 | this.value = value;
29 | }
30 | }
31 |
--------------------------------------------------------------------------------
/src/test/java/samples/jpa/ShortColumnNameWithoutAnnotationParameter.java:
--------------------------------------------------------------------------------
1 | package samples.jpa;
2 |
3 | import javax.persistence.Column;
4 | import javax.persistence.Entity;
5 | import javax.persistence.Id;
6 |
7 | @Entity
8 | public class ShortColumnNameWithoutAnnotationParameter {
9 | @Id
10 | private long id;
11 |
12 | @Column
13 | private String shortColumnNameNoAnnotationPrm;
14 |
15 | private String another;
16 |
17 | public long getId() {
18 | return id;
19 | }
20 |
21 | public void setId(long id) {
22 | this.id = id;
23 | }
24 |
25 | public String getShortColumnNameNoAnnotationPrm() {
26 | return shortColumnNameNoAnnotationPrm;
27 | }
28 |
29 | public void setShortColumnNameNoAnnotationPrm(
30 | String shortColumnNameNoAnnotationPrm) {
31 | this.shortColumnNameNoAnnotationPrm = shortColumnNameNoAnnotationPrm;
32 | }
33 |
34 | @Column
35 | public String getAnother() {
36 | return another;
37 | }
38 |
39 | public void setAnother(String another) {
40 | this.another = another;
41 | }
42 | }
43 |
--------------------------------------------------------------------------------
/src/test/java/samples/jpa/ShortIndexNameForHibernate.java:
--------------------------------------------------------------------------------
1 | package samples.jpa;
2 |
3 | import javax.persistence.Column;
4 | import javax.persistence.Entity;
5 | import javax.persistence.Id;
6 |
7 | import org.hibernate.annotations.Index;
8 |
9 | @Entity
10 | public class ShortIndexNameForHibernate {
11 | @Id
12 | private long id;
13 |
14 | @Column(nullable = true)
15 | @Index(name = "idx_name_shorter_than_31_bytes")
16 | private String value;
17 |
18 | public long getId() {
19 | return id;
20 | }
21 |
22 | public void setId(long id) {
23 | this.id = id;
24 | }
25 |
26 | public String getValue() {
27 | return value;
28 | }
29 |
30 | public void setValue(String value) {
31 | this.value = value;
32 | }
33 |
34 | }
35 |
--------------------------------------------------------------------------------
/src/test/java/samples/jpa/ShortIndexNameForOpenJPA.java:
--------------------------------------------------------------------------------
1 | package samples.jpa;
2 |
3 | import javax.persistence.Column;
4 | import javax.persistence.Entity;
5 | import javax.persistence.Id;
6 |
7 | import org.apache.openjpa.persistence.jdbc.Index;
8 |
9 | @Entity
10 | public class ShortIndexNameForOpenJPA {
11 | @Id
12 | private long id;
13 |
14 | @Column(nullable = true)
15 | @Index(name = "idx_name_shorter_than_31_bytes")
16 | private String value;
17 |
18 | public long getId() {
19 | return id;
20 | }
21 |
22 | public void setId(long id) {
23 | this.id = id;
24 | }
25 |
26 | public String getValue() {
27 | return value;
28 | }
29 |
30 | public void setValue(String value) {
31 | this.value = value;
32 | }
33 |
34 | }
35 |
--------------------------------------------------------------------------------
/src/test/java/samples/jpa/ShortTableName.java:
--------------------------------------------------------------------------------
1 | package samples.jpa;
2 |
3 | import javax.persistence.Entity;
4 | import javax.persistence.Id;
5 |
6 | @Entity(name="tbl_name_shorter_than_31_bytes")
7 | public class ShortTableName {
8 |
9 | @Id
10 | private long id;
11 |
12 | public ShortTableName(long id) {
13 | this.id = id;
14 | }
15 |
16 | public long getId() {
17 | return id;
18 | }
19 |
20 | }
21 |
--------------------------------------------------------------------------------
/src/test/java/samples/jpa/ShortTableNameNoAnnotationPara.java:
--------------------------------------------------------------------------------
1 | package samples.jpa;
2 |
3 | import javax.persistence.Entity;
4 | import javax.persistence.Id;
5 |
6 | @Entity
7 | public class ShortTableNameNoAnnotationPara {
8 |
9 | @Id
10 | private long id;
11 |
12 | public ShortTableNameNoAnnotationPara(long id) {
13 | this.id = id;
14 | }
15 |
16 | public long getId() {
17 | return id;
18 | }
19 |
20 | }
21 |
--------------------------------------------------------------------------------
/src/test/java/samples/jpa/UseColumnDefinition.java:
--------------------------------------------------------------------------------
1 | package samples.jpa;
2 |
3 | import javax.persistence.Column;
4 | import javax.persistence.Entity;
5 | import javax.persistence.Id;
6 |
7 | @Entity
8 | public class UseColumnDefinition {
9 | @Id
10 | private long id;
11 |
12 | @Column(columnDefinition = "NVARCHAR2(100)")
13 | private String value;
14 |
15 | public long getId() {
16 | return id;
17 | }
18 |
19 | public void setId(long id) {
20 | this.id = id;
21 | }
22 |
23 | public String getValue() {
24 | return value;
25 | }
26 |
27 | public void setValue(String value) {
28 | this.value = value;
29 | }
30 | }
31 |
--------------------------------------------------------------------------------
/src/test/java/samples/jsr305/BadImmutableClass.java:
--------------------------------------------------------------------------------
1 | package samples.jsr305;
2 |
3 | import javax.annotation.concurrent.Immutable;
4 | import javax.annotation.concurrent.NotThreadSafe;
5 |
6 | @NotThreadSafe
7 | @Immutable // marked as immutable, but field is not final
8 | public class BadImmutableClass {
9 | public String value;
10 | }
11 |
--------------------------------------------------------------------------------
/src/test/java/samples/jsr305/ExtendsMutableClass.java:
--------------------------------------------------------------------------------
1 | package samples.jsr305;
2 |
3 | import javax.annotation.concurrent.Immutable;
4 |
5 |
6 | @Immutable // this class looks immutable, but it extends mutable class
7 | public final class ExtendsMutableClass extends BadImmutableClass {
8 | private final String string;
9 |
10 | public ExtendsMutableClass(String string) {
11 | this.string = string;
12 | }
13 |
14 | public String getString() {
15 | return string;
16 | }
17 | }
18 |
--------------------------------------------------------------------------------
/src/test/java/samples/jsr305/GoodMutableClass.java:
--------------------------------------------------------------------------------
1 | package samples.jsr305;
2 |
3 | // Not marked as immutable
4 | public class GoodMutableClass {
5 | public String value;
6 | }
7 |
--------------------------------------------------------------------------------
/src/test/java/samples/jsr305/ImmutableEnum.java:
--------------------------------------------------------------------------------
1 | package samples.jsr305;
2 |
3 | import javax.annotation.concurrent.Immutable;
4 |
5 | @Immutable
6 | public enum ImmutableEnum {
7 |
8 | }
9 |
--------------------------------------------------------------------------------
/src/test/java/samples/jsr305/nullness/AnnotatedArgument.java:
--------------------------------------------------------------------------------
1 | package samples.jsr305.nullness;
2 |
3 | import javax.annotation.Nullable;
4 |
5 | public class AnnotatedArgument {
6 | public void methodWithNullableArgument(@Nullable Object value) {}
7 | }
8 |
--------------------------------------------------------------------------------
/src/test/java/samples/jsr305/nullness/AnnotatedArgumentsEnum.java:
--------------------------------------------------------------------------------
1 | package samples.jsr305.nullness;
2 |
3 | import javax.annotation.Nonnull;
4 |
5 | public enum AnnotatedArgumentsEnum {
6 | VALUE("whatever");
7 |
8 | private AnnotatedArgumentsEnum(@Nonnull final String value) {
9 | }
10 |
11 | }
12 |
--------------------------------------------------------------------------------
/src/test/java/samples/jsr305/nullness/AnnotatedClass.java:
--------------------------------------------------------------------------------
1 | package samples.jsr305.nullness;
2 |
3 | import javax.annotation.ParametersAreNonnullByDefault;
4 |
5 | @ParametersAreNonnullByDefault
6 | public class AnnotatedClass {
7 | public void method(Object value) {}
8 | }
9 |
--------------------------------------------------------------------------------
/src/test/java/samples/jsr305/nullness/AnnotatedInnerClassArguments.java:
--------------------------------------------------------------------------------
1 | package samples.jsr305.nullness;
2 |
3 | import javax.annotation.Nonnull;
4 |
5 |
6 | public class AnnotatedInnerClassArguments {
7 |
8 | public class Inner {
9 | public void method(@Nonnull Object value) {}
10 | }
11 | }
12 |
--------------------------------------------------------------------------------
/src/test/java/samples/jsr305/nullness/AnnotatedMethod.java:
--------------------------------------------------------------------------------
1 | package samples.jsr305.nullness;
2 |
3 | import javax.annotation.ParametersAreNonnullByDefault;
4 |
5 | public class AnnotatedMethod {
6 | @ParametersAreNonnullByDefault
7 | public void methodAnnotatedWithByDefault(Object value) {}
8 | }
9 |
--------------------------------------------------------------------------------
/src/test/java/samples/jsr305/nullness/AnnotatedReturnValue.java:
--------------------------------------------------------------------------------
1 | package samples.jsr305.nullness;
2 |
3 | import javax.annotation.Nullable;
4 |
5 | public class AnnotatedReturnValue {
6 | @Nullable
7 | public Object method() {
8 | return null;
9 | }
10 | }
11 |
--------------------------------------------------------------------------------
/src/test/java/samples/jsr305/nullness/AnonymousClassConstructor.java:
--------------------------------------------------------------------------------
1 | package samples.jsr305.nullness;
2 |
3 | import java.util.Comparator;
4 |
5 | import javax.annotation.Nonnull;
6 |
7 |
8 |
9 | public class AnonymousClassConstructor {
10 |
11 | public void method() {
12 | @SuppressWarnings("unused")
13 | final Comparator comparator = new Comparator() {
14 |
15 | @Override
16 | public int compare(@Nonnull Long o1, @Nonnull Long o2) {
17 | return 0;
18 | }
19 | };
20 | }
21 | }
22 |
--------------------------------------------------------------------------------
/src/test/java/samples/jsr305/nullness/ChildOfUnannotatedBoundGenerics.java:
--------------------------------------------------------------------------------
1 | package samples.jsr305.nullness;
2 |
3 | import java.util.Iterator;
4 |
5 | public class ChildOfUnannotatedBoundGenerics extends UnannotatedBoundGenerics implements Iterable {
6 |
7 | @Override
8 | public int compareTo(final UnannotatedBoundGenerics o) {
9 | return 0;
10 | }
11 |
12 | @Override
13 | public Iterator iterator() {
14 | return null;
15 | }
16 | }
17 |
--------------------------------------------------------------------------------
/src/test/java/samples/jsr305/nullness/ComplexGenerics.java:
--------------------------------------------------------------------------------
1 | package samples.jsr305.nullness;
2 |
3 | import java.util.ArrayList;
4 | import java.util.List;
5 | import java.util.concurrent.TimeUnit;
6 |
7 | import javax.annotation.concurrent.GuardedBy;
8 |
9 | import rx.Observable;
10 | import rx.Scheduler;
11 | import rx.Subscriber;
12 | import rx.Subscription;
13 | import rx.exceptions.Exceptions;
14 | import rx.functions.Action0;
15 | import rx.observers.SerializedSubscriber;
16 | import rx.schedulers.Schedulers;
17 |
18 | /**
19 | * Rx Operator: Store items in a buffer, emits items if the buffer is full or by timeout.
20 | * If the buffer is full the operator will emit the items.
21 | * If the timeout is consumed and the buffer is not empty the items will be emitted.
22 | * onComplete emits remaining items.
23 | * onError will not emit any remaining items.
24 | */
25 | public final class ComplexGenerics implements Observable.Operator, T> {
26 | private final long timeout;
27 | private final TimeUnit unit;
28 | private final int count;
29 | private final Scheduler scheduler;
30 | private Subscription timeoutSubscription;
31 |
32 | /**
33 | * @param count the maximum size of the buffer. Once a buffer reaches this size, it is emitted
34 | * @param timeout the amount of time all chunks must be actively collect values before being emitted
35 | * @param unit the {@link TimeUnit} defining the unit of time for the timeout
36 | */
37 | public ComplexGenerics(final int count, final long timeout, final TimeUnit unit) {
38 | this(count, timeout, unit, Schedulers.computation());
39 | }
40 |
41 | /**
42 | * @param count the maximum size of the buffer. Once a buffer reaches this size, it is emitted
43 | * @param timeout the amount of time all chunks must be actively collect values before being emitted
44 | * @param unit the {@link TimeUnit} defining the unit of time for the timeout
45 | * @param scheduler the {@link Scheduler} to use for timeout
46 | */
47 | public ComplexGenerics(final int count, final long timeout, final TimeUnit unit, final Scheduler scheduler) {
48 | this.count = count;
49 | this.timeout = timeout >= 0 ? timeout : 0;
50 | this.unit = unit;
51 | this.scheduler = scheduler;
52 | }
53 |
54 | @Override
55 | public Subscriber call(final Subscriber> child) {
56 | final Scheduler.Worker inner = scheduler.createWorker();
57 | final SerializedSubscriber> serialized = new SerializedSubscriber<>(child);
58 | final BufferSubscriber bufferSubscriber = new BufferSubscriber(serialized, inner);
59 | bufferSubscriber.add(inner);
60 | child.add(bufferSubscriber);
61 | return bufferSubscriber;
62 | }
63 |
64 | private final class BufferSubscriber extends Subscriber {
65 | /* default */ final Subscriber> child;
66 | /* default */ final Scheduler.Worker inner;
67 | /* default */ List chunk;
68 | /* default */ boolean done;
69 |
70 | BufferSubscriber(final Subscriber> child, final Scheduler.Worker inner) {
71 | this.child = child;
72 | this.inner = inner;
73 | this.chunk = new ArrayList<>();
74 | }
75 |
76 | @Override
77 | public void onNext(final T t) {
78 | synchronized (this) {
79 | unsubscribeTimeout();
80 | if (done) {
81 | return;
82 | }
83 | chunk.add(t);
84 | if (chunk.size() == count) {
85 | emit();
86 | } else {
87 | scheduleTimeout();
88 | }
89 | }
90 | }
91 |
92 | @Override
93 | public void onError(final Throwable e) {
94 | synchronized (this) {
95 | unsubscribeTimeout();
96 | done = true;
97 | chunk = null;
98 | child.onError(e);
99 | unsubscribe();
100 | }
101 | }
102 |
103 | @Override
104 | public void onCompleted() {
105 | synchronized (this) {
106 | unsubscribeTimeout();
107 | emit();
108 | done = true;
109 | chunk = null;
110 | child.onCompleted();
111 | unsubscribe();
112 | }
113 | }
114 |
115 | private void unsubscribeTimeout() {
116 | if (timeoutSubscription != null && !timeoutSubscription.isUnsubscribed()) {
117 | timeoutSubscription.unsubscribe();
118 | }
119 | }
120 |
121 | private void scheduleTimeout() {
122 | timeoutSubscription = inner.schedule(new Action0() {
123 | @Override
124 | public void call() {
125 | synchronized (this) {
126 | emit();
127 | }
128 | }
129 | }, timeout, unit);
130 | }
131 |
132 | @GuardedBy("this")
133 | private void emit() {
134 | if (done) {
135 | return;
136 | }
137 | final List toEmit;
138 | toEmit = chunk;
139 | chunk = new ArrayList<>();
140 | if (toEmit != null && !toEmit.isEmpty()) {
141 | try {
142 | child.onNext(toEmit);
143 | } catch (final Throwable t) {
144 | Exceptions.throwOrReport(t, this);
145 | }
146 | }
147 | }
148 |
149 | @Override
150 | public String toString() {
151 | return "BufferSubscriber{"
152 | + "child=" + child
153 | + ", inner=" + inner
154 | + ", chunk=" + chunk
155 | + ", done=" + done
156 | + '}';
157 | }
158 | }
159 |
160 | @Override
161 | public String toString() {
162 | return "BufferTimeoutOperator{"
163 | + "timeout=" + timeout
164 | + ", unit=" + unit
165 | + ", count=" + count
166 | + ", scheduler=" + scheduler
167 | + ", timeoutSubscription=" + timeoutSubscription
168 | + '}';
169 | }
170 | }
--------------------------------------------------------------------------------
/src/test/java/samples/jsr305/nullness/NoAnnotation.java:
--------------------------------------------------------------------------------
1 | package samples.jsr305.nullness;
2 |
3 | public class NoAnnotation {
4 | public void method(Object value) {}
5 | }
6 |
--------------------------------------------------------------------------------
/src/test/java/samples/jsr305/nullness/PrimitiveArgument.java:
--------------------------------------------------------------------------------
1 | package samples.jsr305.nullness;
2 |
3 | public class PrimitiveArgument {
4 | public void method(int value) {}
5 | }
6 |
--------------------------------------------------------------------------------
/src/test/java/samples/jsr305/nullness/StandardEnum.java:
--------------------------------------------------------------------------------
1 | package samples.jsr305.nullness;
2 |
3 | public enum StandardEnum {
4 | PROCESS, CULTURE, AVAILABLE_DEVICES,
5 | EQUIPEMENT_REQUEST, SUPPORT_REQUEST,
6 | DEVICE_REQUEST, MANAGEMENT_ORDERS;
7 | }
8 |
--------------------------------------------------------------------------------
/src/test/java/samples/jsr305/nullness/UnannotatedBoundGenerics.java:
--------------------------------------------------------------------------------
1 | package samples.jsr305.nullness;
2 |
3 | public class UnannotatedBoundGenerics implements Comparable {
4 |
5 | @Override
6 | public int compareTo(final UnannotatedBoundGenerics o) {
7 | return 0;
8 | }
9 | }
10 |
--------------------------------------------------------------------------------
/src/test/java/samples/jsr305/nullness/UnannotatedEnumLookAlike.java:
--------------------------------------------------------------------------------
1 | package samples.jsr305.nullness;
2 |
3 |
4 | public class UnannotatedEnumLookAlike {
5 |
6 | /*
7 | * The signature of this method matches that of an enum's values(),
8 | * but it's not and should be reported
9 | */
10 | public static UnannotatedEnumLookAlike[] values() {
11 | return null;
12 | }
13 |
14 | /*
15 | * The signature of this method matches that of an enum's valueOf(String),
16 | * but it's not and should be reported
17 | */
18 | public static UnannotatedEnumLookAlike valueOf(final String s) {
19 | return null;
20 | }
21 | }
22 |
--------------------------------------------------------------------------------
/src/test/java/samples/jsr305/nullness/UnannotatedExtendingLibClass.java:
--------------------------------------------------------------------------------
1 | package samples.jsr305.nullness;
2 |
3 | import java.io.IOException;
4 |
5 | import de.ruedigermoeller.heapoff.FSTCompressed;
6 | import de.ruedigermoeller.serialization.FSTConfiguration;
7 |
8 |
9 | public class UnannotatedExtendingLibClass extends FSTCompressed {
10 |
11 | @Override
12 | public void set(String object) throws IOException {
13 | super.set(object);
14 | }
15 |
16 | @Override
17 | protected void storeArray(byte[] buffer, int written) {
18 | }
19 |
20 | @Override
21 | protected FSTConfiguration getConf() {
22 | return null;
23 | }
24 |
25 | @Override
26 | public byte[] getArray() {
27 | return null;
28 | }
29 |
30 | @Override
31 | public int getLen() {
32 | return 0;
33 | }
34 |
35 | @Override
36 | public int getOffset() {
37 | return 0;
38 | }
39 | }
40 |
--------------------------------------------------------------------------------
/src/test/java/samples/jsr305/nullness/UnannotatedExtendingLibClassPropagatingGenerics.java:
--------------------------------------------------------------------------------
1 | package samples.jsr305.nullness;
2 |
3 | import de.ruedigermoeller.heapoff.FSTByteBufferOffheap;
4 | import de.ruedigermoeller.heapoff.FSTOffHeapMap;
5 |
6 |
7 | public class UnannotatedExtendingLibClassPropagatingGenerics extends FSTOffHeapMap {
8 |
9 | public UnannotatedExtendingLibClassPropagatingGenerics(
10 | final FSTByteBufferOffheap heap) {
11 | super(heap);
12 | }
13 |
14 | @Override
15 | public Long put(String key, Long value) {
16 | return super.put(key, value);
17 | }
18 | }
19 |
--------------------------------------------------------------------------------
/src/test/java/samples/jsr305/nullness/UnannotatedIndirectGenericBinding.java:
--------------------------------------------------------------------------------
1 | package samples.jsr305.nullness;
2 |
3 | import java.util.HashMap;
4 |
5 |
6 | // Used generic types are purposely evil
7 | public class UnannotatedIndirectGenericBinding extends HashMap {
8 |
9 | private static final long serialVersionUID = 7026748794809094126L;
10 |
11 | public static class Bounded extends UnannotatedIndirectGenericBinding {
12 |
13 | private static final long serialVersionUID = 3142640311424915721L;
14 |
15 | @Override
16 | public Long put(final String key, final Long value) {
17 | return super.put(key, value);
18 | }
19 | }
20 | }
21 |
--------------------------------------------------------------------------------
/src/test/java/samples/jsr305/nullness/UnannotatedInnerClassArguments.java:
--------------------------------------------------------------------------------
1 | package samples.jsr305.nullness;
2 |
3 |
4 |
5 | public class UnannotatedInnerClassArguments {
6 |
7 | public class Inner {
8 | public void method(Object value) {}
9 | }
10 | }
11 |
--------------------------------------------------------------------------------
/src/test/java/samples/jsr305/nullness/UnannotatedReturnValue.java:
--------------------------------------------------------------------------------
1 | package samples.jsr305.nullness;
2 |
3 | public class UnannotatedReturnValue {
4 | public Object method() {
5 | return null;
6 | }
7 | }
8 |
--------------------------------------------------------------------------------
/src/test/java/samples/jsr305/nullness/UnannotatedVarargs.java:
--------------------------------------------------------------------------------
1 | package samples.jsr305.nullness;
2 |
3 |
4 | public class UnannotatedVarargs {
5 | public void methodWithNullableArgument(Object... values) {}
6 | }
7 |
--------------------------------------------------------------------------------
/src/test/java/samples/jsr305/nullness/annotatedpackage/AnnotatedPackage.java:
--------------------------------------------------------------------------------
1 | package samples.jsr305.nullness.annotatedpackage;
2 |
3 | public class AnnotatedPackage {
4 | public void method(Object value) {}
5 | }
6 |
--------------------------------------------------------------------------------
/src/test/java/samples/jsr305/nullness/annotatedpackage/package-info.java:
--------------------------------------------------------------------------------
1 | @javax.annotation.ParametersAreNonnullByDefault
2 | package samples.jsr305.nullness.annotatedpackage;
3 |
--------------------------------------------------------------------------------
/src/test/java/samples/junit/IgnoreClassWithEmptyExplanation.java:
--------------------------------------------------------------------------------
1 | package samples.junit;
2 |
3 | import org.junit.Ignore;
4 |
5 | @Ignore("")
6 | public class IgnoreClassWithEmptyExplanation {
7 | }
8 |
--------------------------------------------------------------------------------
/src/test/java/samples/junit/IgnoreClassWithExplanation.java:
--------------------------------------------------------------------------------
1 | package samples.junit;
2 |
3 | import org.junit.Ignore;
4 |
5 | @Ignore("Good explanation to tell the reason.")
6 | public class IgnoreClassWithExplanation {
7 | }
8 |
--------------------------------------------------------------------------------
/src/test/java/samples/junit/IgnoreClassWithoutExplanation.java:
--------------------------------------------------------------------------------
1 | package samples.junit;
2 |
3 | import org.junit.Ignore;
4 |
5 | @Ignore
6 | public class IgnoreClassWithoutExplanation {
7 | }
8 |
--------------------------------------------------------------------------------
/src/test/java/samples/junit/IgnoreMethodWithEmptyExplanation.java:
--------------------------------------------------------------------------------
1 | package samples.junit;
2 |
3 | import org.junit.Ignore;
4 |
5 | public class IgnoreMethodWithEmptyExplanation {
6 | @Ignore("")
7 | public void method() {
8 | }
9 | }
10 |
--------------------------------------------------------------------------------
/src/test/java/samples/junit/IgnoreMethodWithExplanation.java:
--------------------------------------------------------------------------------
1 | package samples.junit;
2 |
3 | import org.junit.Ignore;
4 |
5 | public class IgnoreMethodWithExplanation {
6 | @Ignore("Good explanation to tell the reason.")
7 | public void method() {
8 | }
9 | }
10 |
--------------------------------------------------------------------------------
/src/test/java/samples/junit/IgnoreMethodWithoutExplanation.java:
--------------------------------------------------------------------------------
1 | package samples.junit;
2 |
3 | import org.junit.Ignore;
4 |
5 | public class IgnoreMethodWithoutExplanation {
6 | @Ignore
7 | public void method() {
8 | }
9 | }
10 |
--------------------------------------------------------------------------------
/src/test/java/samples/system/UseSystemErr.java:
--------------------------------------------------------------------------------
1 | package samples.system;
2 |
3 | public class UseSystemErr {
4 |
5 | public void test() {
6 | System.err.println("hello world");
7 | }
8 | }
9 |
--------------------------------------------------------------------------------
/src/test/java/samples/system/UseSystemOut.java:
--------------------------------------------------------------------------------
1 | package samples.system;
2 |
3 | public class UseSystemOut {
4 |
5 | public void test() {
6 | System.out.println("hello world");
7 | }
8 |
9 | }
10 |
--------------------------------------------------------------------------------
/src/test/resources/fst-1.63.jar:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Monits/findbugs-plugin/6f12771c65be30b2a96d24bab8d6c07f40822fc9/src/test/resources/fst-1.63.jar
--------------------------------------------------------------------------------
/src/test/resources/rxjava-1.0.16.jar:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Monits/findbugs-plugin/6f12771c65be30b2a96d24bab8d6c07f40822fc9/src/test/resources/rxjava-1.0.16.jar
--------------------------------------------------------------------------------