PatternSet p = new PatternSet(); project.addReference("dummy", p); p.setRefid(new Reference("dummy")); try { p.getIncludePatterns(project); fail("Can make PatternSet a Reference to itself."); } catch (BuildException be) { assertEquals("This data type contains a circular reference.", be.getMessage()); } try { p.getExcludePatterns(project); fail("Can make PatternSet a Reference to itself."); } catch (BuildException be) { assertEquals("This data type contains a circular reference.", be.getMessage()); } // dummy1 --> dummy2 --> dummy3 --> dummy1 PatternSet p1 = new PatternSet(); project.addReference("dummy1", p1); p1.setRefid(new Reference("dummy2")); PatternSet p2 = new PatternSet(); project.addReference("dummy2", p2); p2.setRefid(new Reference("dummy3")); PatternSet p3 = new PatternSet(); project.addReference("dummy3", p3); p3.setRefid(new Reference("dummy1")); try { p1.getIncludePatterns(project); fail("Can make circular reference."); } catch (BuildException be) { assertEquals("This data type contains a circular reference.", be.getMessage()); } try { p1.getExcludePatterns(project); fail("Can make circular reference."); } catch (BuildException be) { assertEquals("This data type contains a circular reference.", be.getMessage()); } // dummy1 --> dummy2 --> dummy3 // (which holds patterns "include" and "exclude") p1 = new PatternSet(); project.addReference("dummy1", p1); p1.setRefid(new Reference("dummy2")); p2 = new PatternSet(); project.addReference("dummy2", p2); p2.setRefid(new Reference("dummy3")); p3 = new PatternSet(); project.addReference("dummy3", p3); p3.setIncludes("include"); p3.createExclude().setName("exclude"); String[] i = p1.getIncludePatterns(project); assertEquals("One include pattern buried deep inside a nested patternset structure", 1, i.length); assertEquals("include", i[0]); i = p3.getExcludePatterns(project); assertEquals("One exclude pattern buried deep inside a nested patternset structure", 1, i.length); assertEquals("exclude", i[0]);
FileList f = new FileList(); project.addReference("dummy", f); f.setRefid(new Reference("dummy")); try { f.getDir(project); fail("Can make FileList a Reference to itself."); } catch (BuildException be) { assertEquals("This data type contains a circular reference.", be.getMessage()); } try { f.getFiles(project); fail("Can make FileList a Reference to itself."); } catch (BuildException be) { assertEquals("This data type contains a circular reference.", be.getMessage()); } // dummy1 --> dummy2 --> dummy3 --> dummy1 FileList f1 = new FileList(); project.addReference("dummy1", f1); f1.setRefid(new Reference("dummy2")); FileList f2 = new FileList(); project.addReference("dummy2", f2); f2.setRefid(new Reference("dummy3")); FileList f3 = new FileList(); project.addReference("dummy3", f3); f3.setRefid(new Reference("dummy1")); try { f1.getDir(project); fail("Can make circular reference."); } catch (BuildException be) { assertEquals("This data type contains a circular reference.", be.getMessage()); } try { f1.getFiles(project); fail("Can make circular reference."); } catch (BuildException be) { assertEquals("This data type contains a circular reference.", be.getMessage()); } // dummy1 --> dummy2 --> dummy3 // (which has the Project's basedir as root). f1 = new FileList(); project.addReference("dummy1", f1); f1.setRefid(new Reference("dummy2")); f2 = new FileList(); project.addReference("dummy2", f2); f2.setRefid(new Reference("dummy3")); f3 = new FileList(); project.addReference("dummy3", f3); f3.setDir(project.resolveFile(".")); File dir = f1.getDir(project); assertEquals("Dir is basedir", dir, project.getBaseDir());
Clone fragments detected by clone detection tool
File path: /apache-ant-1.7.0/src/tests/junit/org/apache/tools/ant/types/PatternSetTest.java File path: /apache-ant-1.7.0/src/tests/junit/org/apache/tools/ant/types/FileListTest.java
Method name: void testCircularReferenceCheck() Method name: void testCircularReferenceCheck()
Number of AST nodes: 40 Number of AST nodes: 35
1
PatternSet p = new PatternSet();
1
FileList f = new FileList();
2
        project.addReference("dummy", p);
2
        project.addReference("dummy", f);
3
        p.setRefid(new Reference("dummy"));
3
        f.setRefid(new Reference("dummy"));
4
        try {
4
        try {
5
            p.getIncludePatterns(project);
5
            f.getDir(project);
6
            fail("Can make PatternSet a Reference to itself.");
6
            fail("Can make FileList a Reference to itself.");
7
        } catch (BuildException be) {
7
        } catch (BuildException be) {
8
            assertEquals("This data type contains a circular reference.",
8
            assertEquals("This data type contains a circular reference.",
9
                         be.getMessage());
9
                         be.getMessage());
10
        }
10
        }
11
        try {
11
        try {
12
            p.getExcludePatterns(project);
12
            f.getFiles(project);
13
            fail("Can make PatternSet a Reference to itself.");
13
            fail("Can make FileList a Reference to itself.");
14
        } catch (BuildException be) {
14
        } catch (BuildException be) {
15
            assertEquals("This data type contains a circular reference.",
15
            assertEquals("This data type contains a circular reference.",
16
                         be.getMessage());
16
                         be.getMessage());
17
        }
17
        }
18
        // dummy1 --> dummy2 --> dummy3 --> dummy1
18
        // dummy1 --> dummy2 --> dummy3 --> dummy1
19
        PatternSet p1 = new PatternSet();
19
        FileList f1 = new FileList();
20
        project.addReference("dummy1", p1);
20
        project.addReference("dummy1", f1);
21
        p1.setRefid(new Reference("dummy2"));
21
        f1.setRefid(new Reference("dummy2"));
22
        PatternSet p2 = new PatternSet();
22
        FileList f2 = new FileList();
23
        project.addReference("dummy2", p2);
23
        project.addReference("dummy2", f2);
24
        p2.setRefid(new Reference("dummy3"));
24
        f2.setRefid(new Reference("dummy3"));
25
        PatternSet p3 = new PatternSet();
25
        FileList f3 = new FileList();
26
        project.addReference("dummy3", p3);
26
        project.addReference("dummy3", f3);
27
        p3.setRefid(new Reference("dummy1"));
27
        f3.setRefid(new Reference("dummy1"));
28
        try {
28
        try {
29
            p1.getIncludePatterns(project);
29
            f1.getDir(project);
30
            fail("Can make circular reference.");
30
            fail("Can make circular reference.");
31
        } catch (BuildException be) {
31
        } catch (BuildException be) {
32
            assertEquals("This data type contains a circular reference.",
32
            assertEquals("This data type contains a circular reference.",
33
                         be.getMessage());
33
                         be.getMessage());
34
        }
34
        }
35
        try {
35
        try {
36
            p1.getExcludePatterns(project);
36
            f1.getFiles(project);
37
            fail("Can make circular reference.");
37
            fail("Can make circular reference.");
38
        } catch (BuildException be) {
38
        } catch (BuildException be) {
39
            assertEquals("This data type contains a circular reference.",
39
            assertEquals("This data type contains a circular reference.",
40
                         be.getMessage());
40
                         be.getMessage());
41
        }
41
        }
42
        // dummy1 --> dummy2 --> dummy3
42
        // dummy1 --> dummy2 --> dummy3
43
        // (which holds patterns "include" and "exclude")
43
        // (which has the Project's basedir as root).
44
        p1 = new PatternSet();
44
        f1 = new FileList();
45
        project.addReference("dummy1", p1);
45
        project.addReference("dummy1", f1);
46
        p1.setRefid(new Reference("dummy2"));
46
        f1.setRefid(new Reference("dummy2"));
47
        p2 = new PatternSet();
47
        f2 = new FileList();
48
        project.addReference("dummy2", p2);
48
        project.addReference("dummy2", f2);
49
        p2.setRefid(new Reference("dummy3"));
49
        f2.setRefid(new Reference("dummy3"));
50
        p3 = new PatternSet();
50
        f3 = new FileList();
51
        project.addReference("dummy3", p3);
51
        project.addReference("dummy3", f3);
52
        p3.setIncludes("include");
52
        f3.set
53
        p3.createExclude().setName("exclude");
53
Dir(project.resolveFile("."));
54
        String[] i = p1.getIncludePatterns(project);
54
        File dir = f1.getDir(project);
55
        assertEquals("One include pattern buried deep inside a nested patternset structure",
55
        assertEquals("
56
                     1, i.length);
57
        assertEquals("include", i[0]);
58
        i = p3.getExcludePatterns(project);
59
        assertEquals("One exclude pattern buried deep inside a nested patternset structure",
60
                     1, i.length);
61
        assertEquals("exclude", i[0]);
56
Dir is basedir", dir, project.getBaseDir());
Summary
Number of common nesting structure subtrees1
Number of refactorable cases0
Number of non-refactorable cases1
Time elapsed for finding largest common nesting structure subtrees (ms)13.4
Clones locationClones are in different classes having the same super class
Number of node comparisons380
  1. {Non-refactorable}
    Mapping Summary
    Number of mapped statements32
    Number of unmapped statements in the first code fragment8
    Number of unmapped statements in the second code fragment3
    Time elapsed for statement mapping (ms)235.1
    Clone typeType 3
    Mapped Statements
    ID Statement ID Statement
    1
    PatternSet p = new PatternSet();
    1
    PatternSet p = new PatternSet();
    1
    FileList f = new FileList();
    Differences
    Expression1Expression2Difference
    org.apache.tools.ant.types.PatternSetorg.apache.tools.ant.types.FileListSUBCLASS_TYPE_MISMATCH
    pfVARIABLE_NAME_MISMATCH
    org.apache.tools.ant.types.PatternSetorg.apache.tools.ant.types.FileListSUBCLASS_TYPE_MISMATCH
    org.apache.tools.ant.types.PatternSetorg.apache.tools.ant.types.FileListSUBCLASS_TYPE_MISMATCH
    1
    FileList f = new FileList();
    2
    project.addReference("dummy", p);
    2
    project.addReference("dummy", p);
    2
    project.addReference("dummy", f);
    Differences
    Expression1Expression2Difference
    pfVARIABLE_NAME_MISMATCH
    org.apache.tools.ant.types.PatternSetorg.apache.tools.ant.types.FileListSUBCLASS_TYPE_MISMATCH
    Preondition Violations
    Expression p cannot be parameterized, because it has dependencies to/from statements that will be extracted
    Expression f cannot be parameterized, because it has dependencies to/from statements that will be extracted
    2
    project.addReference("dummy", f);
    3
    p.setRefid(new Reference("dummy"));
    3
    p.setRefid(new Reference("dummy"));
    3
    f.setRefid(new Reference("dummy"));
    Differences
    Expression1Expression2Difference
    pfVARIABLE_NAME_MISMATCH
    org.apache.tools.ant.types.PatternSetorg.apache.tools.ant.types.FileListSUBCLASS_TYPE_MISMATCH
    Preondition Violations
    Expression p cannot be parameterized, because it has dependencies to/from statements that will be extracted
    Expression f cannot be parameterized, because it has dependencies to/from statements that will be extracted
    3
    f.setRefid(new Reference("dummy"));
    4
    try
    7
    try
    5
    p.getIncludePatterns(project);
    5
    p.getIncludePatterns(project);
    8
    f.getFiles(project);
    Differences
    Expression1Expression2Difference
    getIncludePatternsgetFilesMETHOD_INVOCATION_NAME_MISMATCH
    pfVARIABLE_NAME_MISMATCH
    org.apache.tools.ant.types.PatternSetorg.apache.tools.ant.types.FileListSUBCLASS_TYPE_MISMATCH
    Preondition Violations
    Expression p.getIncludePatterns(project) cannot be parameterized, because it has dependencies to/from statements that will be extracted
    Expression f.getFiles(project) cannot be parameterized, because it has dependencies to/from statements that will be extracted
    Expression p cannot be parameterized, because it has dependencies to/from statements that will be extracted
    Expression f cannot be parameterized, because it has dependencies to/from statements that will be extracted
    8
    f.getFiles(project);
    6
    fail("Can make PatternSet a Reference to itself.");
    6
    fail("Can make PatternSet a Reference to itself.");
    9
    fail("Can make FileList a Reference to itself.");
    Differences
    Expression1Expression2Difference
    "Can make PatternSet a Reference to itself.""Can make FileList a Reference to itself."LITERAL_VALUE_MISMATCH
    9
    fail("Can make FileList a Reference to itself.");
    7
    try
    22
    try
    8
    p.getExcludePatterns(project);
    8
    p.getExcludePatterns(project);
    23
    f1.getFiles(project);
    Differences
    Expression1Expression2Difference
    getExcludePatternsgetFilesMETHOD_INVOCATION_NAME_MISMATCH
    pf1VARIABLE_NAME_MISMATCH
    org.apache.tools.ant.types.PatternSetorg.apache.tools.ant.types.FileListSUBCLASS_TYPE_MISMATCH
    Preondition Violations
    Expression p.getExcludePatterns(project) cannot be parameterized, because it has dependencies to/from statements that will be extracted
    Expression f1.getFiles(project) cannot be parameterized, because it has dependencies to/from statements that will be extracted
    Expression p cannot be parameterized, because it has dependencies to/from statements that will be extracted
    Expression f1 cannot be parameterized, because it has dependencies to/from statements that will be extracted
    23
    f1.getFiles(project);
    9
    fail("Can make PatternSet a Reference to itself.");
    9
    fail("Can make PatternSet a Reference to itself.");
    24
    fail("Can make circular reference.");
    Differences
    Expression1Expression2Difference
    "Can make PatternSet a Reference to itself.""Can make circular reference."LITERAL_VALUE_MISMATCH
    24
    fail("Can make circular reference.");
    10
    PatternSet p1 = new PatternSet();
    10
    PatternSet p1 = new PatternSet();
    10
    FileList f1 = new FileList();
    Differences
    Expression1Expression2Difference
    org.apache.tools.ant.types.PatternSetorg.apache.tools.ant.types.FileListSUBCLASS_TYPE_MISMATCH
    p1f1VARIABLE_NAME_MISMATCH
    org.apache.tools.ant.types.PatternSetorg.apache.tools.ant.types.FileListSUBCLASS_TYPE_MISMATCH
    org.apache.tools.ant.types.PatternSetorg.apache.tools.ant.types.FileListSUBCLASS_TYPE_MISMATCH
    10
    FileList f1 = new FileList();
    11
    project.addReference("dummy1", p1);
    11
    project.addReference("dummy1", p1);
    11
    project.addReference("dummy1", f1);
    Differences
    Expression1Expression2Difference
    p1f1VARIABLE_NAME_MISMATCH
    org.apache.tools.ant.types.PatternSetorg.apache.tools.ant.types.FileListSUBCLASS_TYPE_MISMATCH
    Preondition Violations
    Expression p1 cannot be parameterized, because it has dependencies to/from statements that will be extracted
    Expression f1 cannot be parameterized, because it has dependencies to/from statements that will be extracted
    11
    project.addReference("dummy1", f1);
    12
    p1.setRefid(new Reference("dummy2"));
    12
    p1.setRefid(new Reference("dummy2"));
    12
    f1.setRefid(new Reference("dummy2"));
    Differences
    Expression1Expression2Difference
    p1f1VARIABLE_NAME_MISMATCH
    org.apache.tools.ant.types.PatternSetorg.apache.tools.ant.types.FileListSUBCLASS_TYPE_MISMATCH
    Preondition Violations
    Expression p1 cannot be parameterized, because it has dependencies to/from statements that will be extracted
    Expression f1 cannot be parameterized, because it has dependencies to/from statements that will be extracted
    12
    f1.setRefid(new Reference("dummy2"));
    13
    PatternSet p2 = new PatternSet();
    13
    PatternSet p2 = new PatternSet();
    13
    FileList f2 = new FileList();
    Differences
    Expression1Expression2Difference
    org.apache.tools.ant.types.PatternSetorg.apache.tools.ant.types.FileListSUBCLASS_TYPE_MISMATCH
    p2f2VARIABLE_NAME_MISMATCH
    org.apache.tools.ant.types.PatternSetorg.apache.tools.ant.types.FileListSUBCLASS_TYPE_MISMATCH
    org.apache.tools.ant.types.PatternSetorg.apache.tools.ant.types.FileListSUBCLASS_TYPE_MISMATCH
    13
    FileList f2 = new FileList();
    14
    project.addReference("dummy2", p2);
    14
    project.addReference("dummy2", p2);
    14
    project.addReference("dummy2", f2);
    Differences
    Expression1Expression2Difference
    p2f2VARIABLE_NAME_MISMATCH
    org.apache.tools.ant.types.PatternSetorg.apache.tools.ant.types.FileListSUBCLASS_TYPE_MISMATCH
    14
    project.addReference("dummy2", f2);
    15
    p2.setRefid(new Reference("dummy3"));
    15
    p2.setRefid(new Reference("dummy3"));
    15
    f2.setRefid(new Reference("dummy3"));
    Differences
    Expression1Expression2Difference
    p2f2VARIABLE_NAME_MISMATCH
    org.apache.tools.ant.types.PatternSetorg.apache.tools.ant.types.FileListSUBCLASS_TYPE_MISMATCH
    15
    f2.setRefid(new Reference("dummy3"));
    16
    PatternSet p3 = new PatternSet();
    16
    PatternSet p3 = new PatternSet();
    16
    FileList f3 = new FileList();
    Differences
    Expression1Expression2Difference
    org.apache.tools.ant.types.PatternSetorg.apache.tools.ant.types.FileListSUBCLASS_TYPE_MISMATCH
    p3f3VARIABLE_NAME_MISMATCH
    org.apache.tools.ant.types.PatternSetorg.apache.tools.ant.types.FileListSUBCLASS_TYPE_MISMATCH
    org.apache.tools.ant.types.PatternSetorg.apache.tools.ant.types.FileListSUBCLASS_TYPE_MISMATCH
    16
    FileList f3 = new FileList();
    17
    project.addReference("dummy3", p3);
    17
    project.addReference("dummy3", p3);
    17
    project.addReference("dummy3", f3);
    Differences
    Expression1Expression2Difference
    p3f3VARIABLE_NAME_MISMATCH
    org.apache.tools.ant.types.PatternSetorg.apache.tools.ant.types.FileListSUBCLASS_TYPE_MISMATCH
    17
    project.addReference("dummy3", f3);
    18
    p3.setRefid(new Reference("dummy1"));
    18
    p3.setRefid(new Reference("dummy1"));
    18
    f3.setRefid(new Reference("dummy1"));
    Differences
    Expression1Expression2Difference
    p3f3VARIABLE_NAME_MISMATCH
    org.apache.tools.ant.types.PatternSetorg.apache.tools.ant.types.FileListSUBCLASS_TYPE_MISMATCH
    18
    f3.setRefid(new Reference("dummy1"));
    19
    try
    19
    try
                                                  
    20
    f1.getDir(project);
    Preondition Violations
    Unmatched statement f1.getDir(project); cannot be moved before or after the extracted code, because it has dependencies to/from statements that will be extracted
    20
    f1.getDir(project);
    20
    p1.getIncludePatterns(project);
    20
    p1.getIncludePatterns(project);
    Preondition Violations
    Unmatched statement p1.getIncludePatterns(project); cannot be moved before or after the extracted code, because it has dependencies to/from statements that will be extracted
                                                                          
    21
    fail("Can make circular reference.");
    21
    fail("Can make circular reference.");
    22
    try
    4
    try
                                              
    5
    f.getDir(project);
    23
    p1.getExcludePatterns(project);
    23
    p1.getExcludePatterns(project);
    Preondition Violations
    Unmatched statement p1.getExcludePatterns(project); cannot be moved before or after the extracted code, because it has dependencies to/from statements that will be extracted
                                                                          
    24
    fail("Can make circular reference.");
    24
    fail("Can make circular reference.");
    6
    fail("Can make FileList a Reference to itself.");
    Differences
    Expression1Expression2Difference
    "Can make circular reference.""Can make FileList a Reference to itself."LITERAL_VALUE_MISMATCH
    6
    fail("Can make FileList a Reference to itself.");
    25
    p1 = new PatternSet();
    25
    p1 = new PatternSet();
    25
    f1 = new FileList();
    Differences
    Expression1Expression2Difference
    p1f1VARIABLE_NAME_MISMATCH
    org.apache.tools.ant.types.PatternSetorg.apache.tools.ant.types.FileListSUBCLASS_TYPE_MISMATCH
    org.apache.tools.ant.types.PatternSetorg.apache.tools.ant.types.FileListSUBCLASS_TYPE_MISMATCH
    Preondition Violations
    Expression p1 cannot be parameterized, because it has dependencies to/from statements that will be extracted
    Expression f1 cannot be parameterized, because it has dependencies to/from statements that will be extracted
    25
    f1 = new FileList();
    26
    project.addReference("dummy1", p1);
    26
    project.addReference("dummy1", p1);
    26
    project.addReference("dummy1", f1);
    Differences
    Expression1Expression2Difference
    p1f1VARIABLE_NAME_MISMATCH
    org.apache.tools.ant.types.PatternSetorg.apache.tools.ant.types.FileListSUBCLASS_TYPE_MISMATCH
    Preondition Violations
    Expression p1 cannot be parameterized, because it has dependencies to/from statements that will be extracted
    Expression f1 cannot be parameterized, because it has dependencies to/from statements that will be extracted
    26
    project.addReference("dummy1", f1);
    27
    p1.setRefid(new Reference("dummy2"));
    27
    p1.setRefid(new Reference("dummy2"));
    27
    f1.setRefid(new Reference("dummy2"));
    Differences
    Expression1Expression2Difference
    p1f1VARIABLE_NAME_MISMATCH
    org.apache.tools.ant.types.PatternSetorg.apache.tools.ant.types.FileListSUBCLASS_TYPE_MISMATCH
    Preondition Violations
    Expression p1 cannot be parameterized, because it has dependencies to/from statements that will be extracted
    Expression f1 cannot be parameterized, because it has dependencies to/from statements that will be extracted
    27
    f1.setRefid(new Reference("dummy2"));
    28
    p2 = new PatternSet();
    28
    p2 = new PatternSet();
    28
    f2 = new FileList();
    Differences
    Expression1Expression2Difference
    p2f2VARIABLE_NAME_MISMATCH
    org.apache.tools.ant.types.PatternSetorg.apache.tools.ant.types.FileListSUBCLASS_TYPE_MISMATCH
    org.apache.tools.ant.types.PatternSetorg.apache.tools.ant.types.FileListSUBCLASS_TYPE_MISMATCH
    28
    f2 = new FileList();
    29
    project.addReference("dummy2", p2);
    29
    project.addReference("dummy2", p2);
    29
    project.addReference("dummy2", f2);
    Differences
    Expression1Expression2Difference
    p2f2VARIABLE_NAME_MISMATCH
    org.apache.tools.ant.types.PatternSetorg.apache.tools.ant.types.FileListSUBCLASS_TYPE_MISMATCH
    29
    project.addReference("dummy2", f2);
    30
    p2.setRefid(new Reference("dummy3"));
    30
    p2.setRefid(new Reference("dummy3"));
    30
    f2.setRefid(new Reference("dummy3"));
    Differences
    Expression1Expression2Difference
    p2f2VARIABLE_NAME_MISMATCH
    org.apache.tools.ant.types.PatternSetorg.apache.tools.ant.types.FileListSUBCLASS_TYPE_MISMATCH
    30
    f2.setRefid(new Reference("dummy3"));
    31
    p3 = new PatternSet();
    31
    p3 = new PatternSet();
    31
    f3 = new FileList();
    Differences
    Expression1Expression2Difference
    p3f3VARIABLE_NAME_MISMATCH
    org.apache.tools.ant.types.PatternSetorg.apache.tools.ant.types.FileListSUBCLASS_TYPE_MISMATCH
    org.apache.tools.ant.types.PatternSetorg.apache.tools.ant.types.FileListSUBCLASS_TYPE_MISMATCH
    31
    f3 = new FileList();
    32
    project.addReference("dummy3", p3);
    32
    project.addReference("dummy3", p3);
    32
    project.addReference("dummy3", f3);
    Differences
    Expression1Expression2Difference
    p3f3VARIABLE_NAME_MISMATCH
    org.apache.tools.ant.types.PatternSetorg.apache.tools.ant.types.FileListSUBCLASS_TYPE_MISMATCH
    32
    project.addReference("dummy3", f3);
    33
    p3.setIncludes("include");
                                                                
    34
    p3.createExclude().setName("exclude");
                                                                                        
    35
    String[] i = p1.getIncludePatterns(project);
    35
    String[] i = p1.getIncludePatterns(project);
    Preondition Violations
    Unmatched statement String[] i=p1.getIncludePatterns(project); cannot be moved before or after the extracted code, because it has dependencies to/from statements that will be extracted
                                                                                                
    36
    assertEquals("One include pattern buried deep inside a nested patternset structure", 1, i.length);
    36
    assertEquals("One include pattern buried deep inside a nested patternset structure", 1, i.length);
    33
    f3.setDir(project.resolveFile("."));
    Differences
    Expression1Expression2Difference
    assertEqualssetDirMETHOD_INVOCATION_NAME_MISMATCH
    assertEquals("One include pattern buried deep inside a nested patternset structure",1,i.length)f3.setDir(project.resolveFile("."))ARGUMENT_NUMBER_MISMATCH
    f3MISSING_METHOD_INVOCATION_EXPRESSION
    Preondition Violations
    Expression f3.setDir(project.resolveFile(".")) cannot be parameterized, because it has dependencies to/from statements that will be extracted
    Expression assertEquals("One include pattern buried deep inside a nested patternset structure",1,i.length) is a void method call, and thus it cannot be parameterized
    Expression f3.setDir(project.resolveFile(".")) is a void method call, and thus it cannot be parameterized
    Expression f3.setDir(project.resolveFile(".")) cannot be parameterized, because it has dependencies to/from statements that will be extracted
    Expression assertEquals("One include pattern buried deep inside a nested patternset structure",1,i.length) is a void method call, and thus it cannot be parameterized
    Expression f3.setDir(project.resolveFile(".")) is a void method call, and thus it cannot be parameterized
    33
    f3.setDir(project.resolveFile("."));
                                                                    
    34
    File dir = f1.getDir(project);
    Preondition Violations
    Unmatched statement File dir=f1.getDir(project); cannot be moved before or after the extracted code, because it has dependencies to/from statements that will be extracted
    34
    File dir = f1.getDir(project);
    37
    assertEquals("include", i[0]);
    37
    assertEquals("include", i[0]);
    35
    assertEquals("Dir is basedir", dir, project.getBaseDir());
    Differences
    Expression1Expression2Difference
    assertEquals("include",i[0])assertEquals("Dir is basedir",dir,project.getBaseDir())ARGUMENT_NUMBER_MISMATCH
    Preondition Violations
    Expression assertEquals("Dir is basedir",dir,project.getBaseDir()) cannot be parameterized, because it has dependencies to/from statements that will be extracted
    Expression assertEquals("include",i[0]) is a void method call, and thus it cannot be parameterized
    Expression assertEquals("Dir is basedir",dir,project.getBaseDir()) is a void method call, and thus it cannot be parameterized
    35
    assertEquals("Dir is basedir", dir, project.getBaseDir());
    38
    i = p3.getExcludePatterns(project);
    38
    i = p3.getExcludePatterns(project);
    Preondition Violations
    Unmatched statement i=p3.getExcludePatterns(project); cannot be moved before or after the extracted code, because it has dependencies to/from statements that will be extracted
                                                                              
    39
    assertEquals("One exclude pattern buried deep inside a nested patternset structure", 1, i.length);
                                                                                                                                                                                                            
    40
    assertEquals("exclude", i[0]);
                                                                      
    Precondition Violations (38)
    Row Violation
    1Expression p cannot be parameterized, because it has dependencies to/from statements that will be extracted
    2Expression f cannot be parameterized, because it has dependencies to/from statements that will be extracted
    3Expression p cannot be parameterized, because it has dependencies to/from statements that will be extracted
    4Expression f cannot be parameterized, because it has dependencies to/from statements that will be extracted
    5Expression p.getIncludePatterns(project) cannot be parameterized, because it has dependencies to/from statements that will be extracted
    6Expression f.getFiles(project) cannot be parameterized, because it has dependencies to/from statements that will be extracted
    7Expression p cannot be parameterized, because it has dependencies to/from statements that will be extracted
    8Expression f cannot be parameterized, because it has dependencies to/from statements that will be extracted
    9Expression p.getExcludePatterns(project) cannot be parameterized, because it has dependencies to/from statements that will be extracted
    10Expression f1.getFiles(project) cannot be parameterized, because it has dependencies to/from statements that will be extracted
    11Expression p cannot be parameterized, because it has dependencies to/from statements that will be extracted
    12Expression f1 cannot be parameterized, because it has dependencies to/from statements that will be extracted
    13Expression p1 cannot be parameterized, because it has dependencies to/from statements that will be extracted
    14Expression f1 cannot be parameterized, because it has dependencies to/from statements that will be extracted
    15Expression p1 cannot be parameterized, because it has dependencies to/from statements that will be extracted
    16Expression f1 cannot be parameterized, because it has dependencies to/from statements that will be extracted
    17Unmatched statement f1.getDir(project); cannot be moved before or after the extracted code, because it has dependencies to/from statements that will be extracted
    18Unmatched statement p1.getIncludePatterns(project); cannot be moved before or after the extracted code, because it has dependencies to/from statements that will be extracted
    19Unmatched statement p1.getExcludePatterns(project); cannot be moved before or after the extracted code, because it has dependencies to/from statements that will be extracted
    20Expression p1 cannot be parameterized, because it has dependencies to/from statements that will be extracted
    21Expression f1 cannot be parameterized, because it has dependencies to/from statements that will be extracted
    22Expression p1 cannot be parameterized, because it has dependencies to/from statements that will be extracted
    23Expression f1 cannot be parameterized, because it has dependencies to/from statements that will be extracted
    24Expression p1 cannot be parameterized, because it has dependencies to/from statements that will be extracted
    25Expression f1 cannot be parameterized, because it has dependencies to/from statements that will be extracted
    26Unmatched statement String[] i=p1.getIncludePatterns(project); cannot be moved before or after the extracted code, because it has dependencies to/from statements that will be extracted
    27Expression f3.setDir(project.resolveFile(".")) cannot be parameterized, because it has dependencies to/from statements that will be extracted
    28Expression assertEquals("One include pattern buried deep inside a nested patternset structure",1,i.length) is a void method call, and thus it cannot be parameterized
    29Expression f3.setDir(project.resolveFile(".")) is a void method call, and thus it cannot be parameterized
    30Expression f3.setDir(project.resolveFile(".")) cannot be parameterized, because it has dependencies to/from statements that will be extracted
    31Expression assertEquals("One include pattern buried deep inside a nested patternset structure",1,i.length) is a void method call, and thus it cannot be parameterized
    32Expression f3.setDir(project.resolveFile(".")) is a void method call, and thus it cannot be parameterized
    33Unmatched statement File dir=f1.getDir(project); cannot be moved before or after the extracted code, because it has dependencies to/from statements that will be extracted
    34Expression assertEquals("Dir is basedir",dir,project.getBaseDir()) cannot be parameterized, because it has dependencies to/from statements that will be extracted
    35Expression assertEquals("include",i[0]) is a void method call, and thus it cannot be parameterized
    36Expression assertEquals("Dir is basedir",dir,project.getBaseDir()) is a void method call, and thus it cannot be parameterized
    37Unmatched statement i=p3.getExcludePatterns(project); cannot be moved before or after the extracted code, because it has dependencies to/from statements that will be extracted
    38Clone fragment #1 returns variables p1, p3 , while Clone fragment #2 returns variables f, f1