refactor(spgroup#31): rename test cases and update comments

barbosamaatheus · Aug 11, 2021 · e0c7264 · e0c7264
1 parent ff728a5
commit e0c7264
Show file tree

Hide file tree

Showing 44 changed files with 154 additions and 150 deletions.
diff --git a/src/test/java/br/unb/cic/analysis/ioa/InterproceduralOverridingAssignmentAnalysisTest.java b/src/test/java/br/unb/cic/analysis/ioa/InterproceduralOverridingAssignmentAnalysisTest.java
diff --git a/...ToArrayConflictInterProceduralSample.java → ...es/ioa/AdditionToArrayConflictSample.java b/...ToArrayConflictInterProceduralSample.java → ...es/ioa/AdditionToArrayConflictSample.java
@@ -4,7 +4,7 @@
 import java.util.List;
 
 // Conflict: [left, m():11] --> [right, m():12]
-public class OverridingAssignmentAdditionToArrayConflictInterProceduralSample {
+public class AdditionToArrayConflictSample {
 
     public void m() {
         List<String> validParameterAnnotations = new ArrayList<String>();

diff --git a/...liasingConflictInterProceduralSample.java → ...ples/ioa/ArrayAliasingConflictSample.java b/...liasingConflictInterProceduralSample.java → ...ples/ioa/ArrayAliasingConflictSample.java
@@ -1,12 +1,12 @@
 package br.unb.cic.analysis.samples.ioa;
 
-// Conflict: [left, foo():15] --> [right, bar():19]
-public class OverridingAssignmentArrayAliasingConflictInterProceduralSample {
+// Conflict: [left, foo():17] --> [right, bar():21]
+public class ArrayAliasingConflictSample {
     private int[] arr, barr;
 
     public static void main(String[] args) {
-        OverridingAssignmentArrayAliasingConflictInterProceduralSample m =
-                new OverridingAssignmentArrayAliasingConflictInterProceduralSample();
+        ArrayAliasingConflictSample m =
+                new ArrayAliasingConflictSample();
         m.arr = new int[]{0, 0, 0, 0, 0};
         m.barr = m.arr;
         m.foo(); // LEFT

diff --git a/src/test/java/br/unb/cic/analysis/samples/ioa/ArrayDiferentIndexNotConflictSample.java b/src/test/java/br/unb/cic/analysis/samples/ioa/ArrayDiferentIndexNotConflictSample.java
@@ -1,5 +1,5 @@
 package br.unb.cic.analysis.samples.ioa;
-
+// Not Conflict
 public class ArrayDiferentIndexNotConflictSample {
     private int[] arr;
 

diff --git a/src/test/java/br/unb/cic/analysis/samples/ioa/ArraySameIndexConflictSample.java b/src/test/java/br/unb/cic/analysis/samples/ioa/ArraySameIndexConflictSample.java
@@ -1,6 +1,6 @@
 package br.unb.cic.analysis.samples.ioa;
 
-// Conflict: [left, foo():14] --> [right, bar():18]
+// Conflict: [left, foo():15] --> [right, bar():19]
 public class ArraySameIndexConflictSample {
     private int[] arr;
 

diff --git a/...ssFieldConflictInterProceduralSample.java → ...s/ioa/ArraysClassFieldConflictSample.java b/...ssFieldConflictInterProceduralSample.java → ...s/ioa/ArraysClassFieldConflictSample.java
@@ -1,7 +1,7 @@
 package br.unb.cic.analysis.samples.ioa;
 
 // Conflict: [left, foo():13] --> [right, bar():17]
-public class OverridingAssignmentArraysClassFieldConflictInterProceduralSample {
+public class ArraysClassFieldConflictSample {
     public static int[] y;
 
     public static void main(String[] args) {

diff --git a/...ieldNotConflictInterProceduralSample.java → ...oa/ArraysClassFieldNotConflictSample.java b/...ieldNotConflictInterProceduralSample.java → ...oa/ArraysClassFieldNotConflictSample.java
@@ -1,7 +1,7 @@
 package br.unb.cic.analysis.samples.ioa;
 
 // Not Conflict
-public class OverridingAssignmentArraysClassFieldNotConflictInterProceduralSample {
+public class ArraysClassFieldNotConflictSample {
     public static int[] y;
 
     public static void main(String[] args) {

diff --git a/src/test/java/br/unb/cic/analysis/samples/ioa/BothMarkingConflictSample.java b/src/test/java/br/unb/cic/analysis/samples/ioa/BothMarkingConflictSample.java
@@ -5,10 +5,9 @@ public class BothMarkingConflictSample {
     private static int x;
 
     public void main() {
-        foo();
+        foo(); // LEFT
     }
 
-
     private static void foo() {
         x = 1; // RIGHT
     }

diff --git a/src/test/java/br/unb/cic/analysis/samples/ioa/CallGraphSample.java b/src/test/java/br/unb/cic/analysis/samples/ioa/CallGraphSample.java
@@ -1,16 +1,20 @@
 package br.unb.cic.analysis.samples.ioa;
+
+// Conflict: [{left, CallGraphClassImplements.baz():43] --> [right, CallGraphClassImplements<init>():38},
+// {left, CallGraphClassImplements<init>():38] --> [right, CallGraphClassImplements.baz():43}]
+
 public class CallGraphSample {
     private int[] arr;
 
     public void m() {
-        CallGraphInterface callGraphInterface = new CallGraphClassImplements();
-        callGraphInterface.baz();
+        CallGraphInterface callGraphInterface = new CallGraphClassImplements(); // LEFT
+        callGraphInterface.baz(); // RIGHT
 
-        CallGraphClassImplements callGraphClassImplements = new CallGraphClassImplements();
-        callGraphClassImplements.baz();
+        CallGraphClassImplements callGraphClassImplements = new CallGraphClassImplements(); // LEFT
+        callGraphClassImplements.baz(); // RIGHT
 
-        CallGraphClass callGraphClass = new CallGraphClass();
-        callGraphClass.bar();
+        CallGraphClass callGraphClass = new CallGraphClass(); // LEFT
+        callGraphClass.bar(); // RIGHT
 
         foo();
 

diff --git a/...tributeConflictInterProceduralSample.java → ...hangeInstanceAttributeConflictSample.java b/...tributeConflictInterProceduralSample.java → ...hangeInstanceAttributeConflictSample.java
@@ -1,12 +1,12 @@
 package br.unb.cic.analysis.samples.ioa;
 
-// Conflict: [left, m():17] --> [right, InstanceAttributeSample.setFoo():21]
-public class OverridingAssignmentChangeInstanceAttributeConflictInterProceduralSample {
+// Conflict: [left, InstanceAttributeSample():20] --> [right, InstanceAttributeSample.setFoo():24]
+public class ChangeInstanceAttributeConflictSample {
     private InstanceAttributeSample instanceAttributeSample;
 
     public static void main(String[] args) {
-        OverridingAssignmentChangeInstanceAttributeConflictInterProceduralSample m =
-                new OverridingAssignmentChangeInstanceAttributeConflictInterProceduralSample();
+        ChangeInstanceAttributeConflictSample m =
+                new ChangeInstanceAttributeConflictSample();
 
         m.instanceAttributeSample = new InstanceAttributeSample(); // LEFT
         m.instanceAttributeSample.setFoo(2); // RIGHT

diff --git a/...ributesConflictInterProceduralSample.java → ...ChangePublicAttributesConflictSample.java b/...ributesConflictInterProceduralSample.java → ...ChangePublicAttributesConflictSample.java
@@ -1,7 +1,7 @@
 package br.unb.cic.analysis.samples.ioa;
 
-// Conflict: [left, m():9] --> [right, <init>():19]
-public class OverridingAssignmentChangePublicAttributesConflictInterProceduralSample {
+// Conflict: [left, m():9] --> [right, Result<init>():19]
+public class ChangePublicAttributesConflictSample {
 
     public void m() {
         Result result = new Result(); // LEFT

diff --git a/src/test/java/br/unb/cic/analysis/samples/ioa/ClassFieldConflictSample.java b/src/test/java/br/unb/cic/analysis/samples/ioa/ClassFieldConflictSample.java
@@ -0,0 +1,17 @@
+package br.unb.cic.analysis.samples.ioa;
+
+// Conflict: [left, main():10] --> [right, foo():15]
+public class ClassFieldConflictSample {
+    private int x;
+
+    public static void main(String[] args) {
+        ClassFieldConflictSample m =
+                new ClassFieldConflictSample();
+        m.x = 0; // LEFT
+        m.foo(); // RIGHT
+    }
+
+    private void foo() {
+        x = 1;
+    }
+}
diff --git a/src/test/java/br/unb/cic/analysis/samples/ioa/ClassFieldConflictSample2.java b/src/test/java/br/unb/cic/analysis/samples/ioa/ClassFieldConflictSample2.java
@@ -0,0 +1,22 @@
+package br.unb.cic.analysis.samples.ioa;
+
+// Conflict: [left, foo():15] --> [right, bar():19]
+public class ClassFieldConflictSample2 {
+    private int x;
+
+    public static void main(String[] args) {
+        ClassFieldConflictSample2 m =
+                new ClassFieldConflictSample2();
+        m.foo(); // LEFT
+        m.bar(); // RIGHT
+    }
+
+    private void foo() {
+        x = 0;
+    }
+
+    private void bar() {
+        x = 1;
+    }
+
+}
diff --git a/...ieldNotConflictInterProceduralSample.java → ...ples/ioa/ClassFieldNotConflictSample.java b/...ieldNotConflictInterProceduralSample.java → ...ples/ioa/ClassFieldNotConflictSample.java
@@ -1,7 +1,7 @@
 package br.unb.cic.analysis.samples.ioa;
 
 // Not Conflict
-public class OverridingAssignmentClassFieldNotConflictInterProceduralSample {
+public class ClassFieldNotConflictSample {
     private int x;
 
     public void m() {

diff --git a/...eldNotConflictInterProceduralSample2.java → ...les/ioa/ClassFieldNotConflictSample2.java b/...eldNotConflictInterProceduralSample2.java → ...les/ioa/ClassFieldNotConflictSample2.java
@@ -1,7 +1,7 @@
 package br.unb.cic.analysis.samples.ioa;
 
 // Not Conflict
-public class OverridingAssignmentClassFieldNotConflictInterProceduralSample2 {
+public class ClassFieldNotConflictSample2 {
     private int x;
 
     public void m() {

diff --git a/...eterNotConflictInterProceduralSample.java → ...sFieldWithParameterNotConflictSample.java b/...eterNotConflictInterProceduralSample.java → ...sFieldWithParameterNotConflictSample.java
@@ -2,12 +2,12 @@
 
 // Not Conflict - Not implemented yet. You will need constant propagation.
 // Currently detected as conflict: [left, m():9] --> [right, foo():14]
-public class OverridingAssignmentClassFieldWithParameterNotConflictInterProceduralSample {
+public class ClassFieldWithParameterNotConflictSample {
     private int x;
 
     public static void main(String[] args) {
-        OverridingAssignmentClassFieldWithParameterNotConflictInterProceduralSample m =
-                new OverridingAssignmentClassFieldWithParameterNotConflictInterProceduralSample();
+        ClassFieldWithParameterNotConflictSample m =
+                new ClassFieldWithParameterNotConflictSample();
         m.x = 0; // LEFT
         m.foo(m.x); // RIGHT
     }

diff --git a/...MethodsConflictInterProceduralSample.java → ...ples/ioa/ConcatMethodsConflictSample.java b/...MethodsConflictInterProceduralSample.java → ...ples/ioa/ConcatMethodsConflictSample.java
@@ -1,11 +1,11 @@
 package br.unb.cic.analysis.samples.ioa;
 
-// Conflict: [left, m():7] --> [right, foo():8]
-public class OverridingAssignmentConcatMethodsConflictInterProceduralSample {
+// Conflict: [left, main():10] --> [right, main():11]
+public class ConcatMethodsConflictSample {
 
     public static void main(String[] args) {
-        OverridingAssignmentConcatMethodsConflictInterProceduralSample m =
-                new OverridingAssignmentConcatMethodsConflictInterProceduralSample();
+        ConcatMethodsConflictSample m =
+                new ConcatMethodsConflictSample();
 
         int x = m.foo() + m.bar(); // LEFT i3 = $i0 + $i1 - x = $stack2 + $stack3
         x = x + m.qux();         // RIGHT i4 = i3 + $i2 - x = x + $stack4

diff --git a/src/test/java/br/unb/cic/analysis/samples/ioa/ContainsInvokeExpConflictSample.java b/src/test/java/br/unb/cic/analysis/samples/ioa/ContainsInvokeExpConflictSample.java
@@ -4,10 +4,12 @@
 public class ContainsInvokeExpConflictSample {
     private int x, y;
 
-    public void m() {
-        x = 0; // LEFT
-        y = 0;
-        x = foo(); // RIGHT
+    public static void main() {
+        ContainsInvokeExpConflictSample m = new ContainsInvokeExpConflictSample();
+
+        m.x = 0; // LEFT
+        m.y = 0;
+        m.x = m.foo(); // RIGHT
     }
 
     private int foo() {

diff --git a/...lassNotConflictInterProceduralSample.java → ...uteOnIdenticalClassNotConflictSample.java b/...lassNotConflictInterProceduralSample.java → ...uteOnIdenticalClassNotConflictSample.java
@@ -1,10 +1,10 @@
 package br.unb.cic.analysis.samples.ioa;
 
 // Not Conflict
-public class OverridingAssignmentDifferentAttributeOnIdenticalClassNotConflictInterProceduralSample {
+public class DifferentAttributeOnIdenticalClassNotConflictSample {
     private ObjectSample objectSample1, objectSample2;
 
-    public OverridingAssignmentDifferentAttributeOnIdenticalClassNotConflictInterProceduralSample() {
+    public DifferentAttributeOnIdenticalClassNotConflictSample() {
         objectSample1 = new ObjectSample();
         objectSample2 = new ObjectSample();
     }

diff --git a/...buteNotConflictInterProceduralSample.java → ...ssWithSameAttributeNotConflictSample.java b/...buteNotConflictInterProceduralSample.java → ...ssWithSameAttributeNotConflictSample.java
@@ -1,11 +1,11 @@
 package br.unb.cic.analysis.samples.ioa;
 
 // Not Conflict
-public class OverridingAssignmentDifferentClassWithSameAttributeNotConflictInterProceduralSample {
+public class DifferentClassWithSameAttributeNotConflictSample {
     private ObjectExample objectExample;
     private ObjectExample2 objectExample2;
 
-    public OverridingAssignmentDifferentClassWithSameAttributeNotConflictInterProceduralSample() {
+    public DifferentClassWithSameAttributeNotConflictSample() {
         objectExample = new ObjectExample();
         objectExample2 = new ObjectExample2();
     }

diff --git a/...alClassConflictInterProceduralSample.java → ...MethodOnIdenticalClassConflictSample.java b/...alClassConflictInterProceduralSample.java → ...MethodOnIdenticalClassConflictSample.java
@@ -1,12 +1,12 @@
 package br.unb.cic.analysis.samples.ioa;
 
 // Conflict: [left, IdenticalClassSample.setFoo():25] --> [right, IdenticalClassSample.setBar():21]
-public class OverridingAssignmentDifferentMethodOnIdenticalClassConflictInterProceduralSample {
+public class DifferentMethodOnIdenticalClassConflictSample {
     private IdenticalClassSample identicalClassSample;
 
     public static void main(String[] args) {
-        OverridingAssignmentDifferentMethodOnIdenticalClassConflictInterProceduralSample m =
-                new OverridingAssignmentDifferentMethodOnIdenticalClassConflictInterProceduralSample();
+        DifferentMethodOnIdenticalClassConflictSample m =
+                new DifferentMethodOnIdenticalClassConflictSample();
 
         m.identicalClassSample = new IdenticalClassSample();
         m.identicalClassSample.setFoo(1); // LEFT

diff --git a/...HashmapConflictInterProceduralSample.java → ...is/samples/ioa/HashmapConflictSample.java b/...HashmapConflictInterProceduralSample.java → ...is/samples/ioa/HashmapConflictSample.java
@@ -4,7 +4,7 @@
 import java.util.Map;
 
 // Conflict: [left, m():13] --> [right, m():14]
-public class OverridingAssignmentHashmapConflictInterProceduralSample {
+public class HashmapConflictSample {
 
 
     public void m() {

diff --git a/...fBranchConflictInterProceduralSample.java → ...s/samples/ioa/IfBranchConflictSample.java b/...fBranchConflictInterProceduralSample.java → ...s/samples/ioa/IfBranchConflictSample.java
@@ -1,12 +1,12 @@
 package br.unb.cic.analysis.samples.ioa;
 
-// Conflict: [left, m():8] --> [right, foo():14]
-public class OverridingAssignmentIfBranchConflictInterProceduralSample {
+// Conflict: [left, main():10] --> [right, foo():16]
+public class IfBranchConflictSample {
     private int x;
 
     public static void main() {
-        OverridingAssignmentIfBranchConflictInterProceduralSample m =
-                new OverridingAssignmentIfBranchConflictInterProceduralSample();
+        IfBranchConflictSample m =
+                new IfBranchConflictSample();
         m.x = 0; // LEFT
         m.foo(); // RIGHT
     }

diff --git a/src/test/java/br/unb/cic/analysis/samples/ioa/IfWithInvokeConflictSample.java b/src/test/java/br/unb/cic/analysis/samples/ioa/IfWithInvokeConflictSample.java
@@ -1,11 +1,12 @@
 package br.unb.cic.analysis.samples.ioa;
 
-// Conflict: [left, m():8] --> [right, foo():16]
+// Conflict: [left, main():10] --> [right, foo():18]
 public class IfWithInvokeConflictSample {
     private int x, y;
 
     public static void main(String[] args) {
         IfWithInvokeConflictSample m = new IfWithInvokeConflictSample();
+
         m.x = 0; // LEFT
         m.y = 0;
         if (m.foo()) { // RIGHT
@@ -17,6 +18,4 @@ private boolean foo() {
         x = 1;
         return true;
     }
-
-
 }
diff --git a/...rrayNotConflictInterProceduralSample.java → ...ples/ioa/LocalArrayNotConflictSample.java b/...rrayNotConflictInterProceduralSample.java → ...ples/ioa/LocalArrayNotConflictSample.java
@@ -1,7 +1,7 @@
 package br.unb.cic.analysis.samples.ioa;
 
 // Not Conflict
-public class OverridingAssignmentLocalArrayNotConflictInterProceduralSample {
+public class LocalArrayNotConflictSample {
     public void m() {
         foo(); // LEFT
         bar(); // RIGHT

diff --git a/...siveNotConflictInterProceduralSample.java → ...LocalArrayRecursiveNotConflictSample.java b/...siveNotConflictInterProceduralSample.java → ...LocalArrayRecursiveNotConflictSample.java
@@ -1,7 +1,7 @@
 package br.unb.cic.analysis.samples.ioa;
 
 // Not Conflict
-public class OverridingAssignmentLocalArrayRecursiveNotConflictInterProceduralSample {
+public class LocalArrayRecursiveNotConflictSample {
     public void m() {
         foo(); // LEFT
         bar(); // RIGHT

diff --git a/...blesNotConflictInterProceduralSample.java → .../ioa/LocalVariablesNotConflictSample.java b/...blesNotConflictInterProceduralSample.java → .../ioa/LocalVariablesNotConflictSample.java
@@ -1,7 +1,7 @@
 package br.unb.cic.analysis.samples.ioa;
 
 // Not Conflict
-public class OverridingAssignmentLocalVariablesNotConflictInterProceduralSample {
+public class LocalVariablesNotConflictSample {
     public void m() {
         foo(); // LEFT
         bar(); // RIGHT

diff --git a/...lesNotConflictInterProceduralSample2.java → ...ioa/LocalVariablesNotConflictSample2.java b/...lesNotConflictInterProceduralSample2.java → ...ioa/LocalVariablesNotConflictSample2.java
@@ -1,9 +1,9 @@
 package br.unb.cic.analysis.samples.ioa;
 
 // Not Conflict
-public class OverridingAssignmentLocalVariablesNotConflictInterProceduralSample2 {
+public class LocalVariablesNotConflictSample2 {
     public void m() {
-        int x = 0; // LEFT
+        int x = 0;  // LEFT
         foo(x);     // RIGHT
 
     }

diff --git a/...eterNotConflictInterProceduralSample.java → ...iablesWithParameterNotConflictSample.java b/...eterNotConflictInterProceduralSample.java → ...iablesWithParameterNotConflictSample.java
@@ -1,7 +1,7 @@
 package br.unb.cic.analysis.samples.ioa;
 
 // Not Conflict
-public class OverridingAssignmentLocalVariablesWithParameterNotConflictInterProceduralSample {
+public class LocalVariablesWithParameterNotConflictSample {
     public void m() {
         foo(0); // LEFT
         bar(1); // RIGHT

diff --git a/...ctFieldConflictInterProceduralSample.java → ...amples/ioa/ObjectFieldConflictSample.java b/...ctFieldConflictInterProceduralSample.java → ...amples/ioa/ObjectFieldConflictSample.java
@@ -1,7 +1,7 @@
 package br.unb.cic.analysis.samples.ioa;
 
-// Conflict: [left, ObjectFieldConflict.m():17] --> [right, ObjectFieldConflict.bar():21]
-public class OverridingAssignmentObjectFieldConflictInterProceduralSample {
+// Conflict: [left, ObjectFieldConflict.foo():17] --> [right, ObjectFieldConflict.bar():21]
+public class ObjectFieldConflictSample {
     public void m() {
         ObjectFieldConflict c = new ObjectFieldConflict();
         c.foo(1); // left

diff --git a/...ieldNotConflictInterProceduralSample.java → ...les/ioa/ObjectFieldNotConflictSample.java b/...ieldNotConflictInterProceduralSample.java → ...les/ioa/ObjectFieldNotConflictSample.java
@@ -1,7 +1,7 @@
 package br.unb.cic.analysis.samples.ioa;
 
 // Not Conflict
-public class OverridingAssignmentObjectFieldNotConflictInterProceduralSample {
+public class ObjectFieldNotConflictSample {
     public void m() {
         ObjectFieldNotConflict objectFieldNotConflict = new ObjectFieldNotConflict();
         objectFieldNotConflict.foo(1); // left