This page contains reference information about the Java Duplicates Finder Build Runner fields. The Java Duplicates Finder Build Runner is intended for catching similar code fragments and providing a report on discovered repetitive blocks of Java code. The Java Duplicates Finder is based on IntelliJ IDEA capabilities, thus an IntelliJ IDEA project file (.ipr) file is necessary to configure the runner. The Duplicates Finder can also find Java duplicates in projects being built by Maven2.
Option
Description
Build runner
Select Duplicates Finder (Java) from the drop-down list. This runner is used for gathering IntelliJ IDEA duplicates results.
Additional Pre-Processing (Ant)
Option
Description
Run before build
In the appropriate fields, enter the Ant scripts and targets (optional) that you want to run prior to starting the build.
Duplicate Finder Settings
Option
Description
Test sources
If this option is checked, the test sources will be included in the duplicates analysis.
Detalization level
Use these options to define which elements of the source code should be distinguished when searching for repetitive code fragments. Code fragments can be considered duplicated, if they are structurally similar, but contain different variables, fields, methods, types or literals. Refer to the samples below:
Distinguish Variables
If this option is checked, the similar contents with different variable names will be recognized as different. If this option is not checked, such contents will be recognized as duplicated:
public static void main(String[] args) {
int i = 0;
int j = 0;
if (i == j) {
System.out.println("sum of " + i + " and " + j + " = " + i + j);
}
long k = 0;
long n = 0;
if (k == n) {
System.out.println("sum of " + k + " and " + n + " = " + k + n);
}
}
Distinguish Fields
If this option is checked, the similar contents with different field names will be recognized as different. If this option is not checked, such contents will be recognized as duplicated:
If this option is checked, the methods of similar structure will be recognized as different. If this option is not checked, such methods will be recognized as duplicated. In this case, they can be extracted and reused. Initial version:
public void buildCanceled(Build build, SessionData data) {
/* ... **/
for (IListener listener : getListeners()) {
listener.buildCanceled(build, data);
}
}
public void buildFinished(Build build, SessionData data) {
/* ... **/
for (IListener listener : getListeners()) {
listener.buildFinished(build, data);
}
}
After duplicates analysis without distinguishing methods, the duplicated fragments can be extracted:
public void buildCanceled(final Build build, final SessionData data) {
enumerateListeners(new Processor() {
public void process(final IListener listener) {
listener.buildCanceled(build, data);
}
});
}
public void buildFinished(final Build build, final SessionData data) {
enumerateListeners(new Processor() {
public void process(final IListener listener) {
listener.buildFinished(build, data);
}
});
}
private void enumerateListeners(Processor processor) {/* ... **/
for (IListener listener : getListeners()) {
processor.process(listener);
}
}
private interface Processor {
void process(IListener listener);
}
Distinguish Types
If this option is checked, the similar code fragments with different type names will be recognized as different. If this option is not checked, such code fragments will be recognized as duplicates.
new MyIDE().updateStatus()
new TheirIDE().updateStatus()
Distinguish Literals
If this option is checked, similar line of code with different litarels will be considered different If this option is not checked, such lines will be recognized as duplicates.
Complexity of the source code is defined by the amount of statements, expressions, declarations and method calls. Complexity of each of them is defined by its cost. Summarized costs of all these elements of the source code fragment yields the total complexity. Use this field to specify the lowest level of complexity of the source code to be taken into consideration when detecting duplicates. For meaningful results start with value 10.
Ignore Duplicate Subexpressions with Complexity Simpler Than
Use this field to specify the lowest level of complexity of subexpressions to be taken into consideration when detecting duplicates.
Check if Subexpression Can be Extracted
If this option is checked, the duplicated subexpressions can be extracted.