1 package org.softevo.jdynpur.eval;
2
3
4 import java.io.File;
5 import java.io.IOException;
6 import java.util.HashMap;
7 import java.util.HashSet;
8
9
10 import org.objectweb.asm.Type;
11 import org.xml.sax.SAXException;
12
13 public class MutabilityResultsComparer {
14
15 public static int INDEX_numberOfMethodsExamined = 0;
16 public static int INDEX_numberOfMethodsClassifiedPureButImpure = 1;
17 public static int INDEX_numberOfMethodsClassifiedImpureButPure = 2;
18 public static int INDEX_numberOfParametersClassifiedMutableButImmutable = 3;
19 public static int INDEX_numberOfClassifiedParameters = 4;
20 public static int INDEX_numberOfKitMethods = 5;
21 public static int INDEX_numberOfKitParameters = 6;
22 public static int INDEX_numberOfParametersClassifiedImmutableButMutable = 7;
23 public static int INDEX_numberOfPureMethods = 8;
24 public static int INDEX_numberOfImpureMethods = 9;
25 public static int INDEX_numberOfKitPureMethods = 10;
26 public static int INDEX_numberOfKitImpureMethods = 11;
27 public static int INDEX_numberOfCorrectlyPureMethods = 12;
28 public static int INDEX_numberOfCorrectlyImpureMethods = 13;
29 public static int INDEX_numberOfKitImmutableParamters = 14;
30 public static int INDEX_numberOfKitMutableParameters = 15;
31 public static int INDEX_numberOfCorrectlyImmutableParameters = 16;
32 public static int INDEX_numberOfCorrectlyMutableParameters = 17;
33 public static int INDEX_numberOfAllKitImutableParameters = 18;
34 public static int INDEX_numberOfAllKitMutableParameters = 19;
35
36
37 public static void main(String[] args) throws IOException, SAXException {
38 File purityKitFile = new File(args[0]);
39 File jdynpurFile = new File(args[1]);
40 HashMap<String, HashMap<ExtendedMethodIdentifier,ExtendedMethodIdentifier>> kitResults = PurityKitResultFileParser.parseResultFile(purityKitFile);
41 HashMap<String, HashMap<ExtendedMethodIdentifier,ExtendedMethodIdentifier>> dynpurResults = JDynpurResultsFileParser.parse(jdynpurFile);
42 compareMutabilityResults(dynpurResults, kitResults);
43 }
44
45 public static boolean isClassifiableParameter(int parameterId, ExtendedMethodIdentifier identifier) {
46 String type;
47 if (identifier.isStatic()) {
48 Type[] types = Type.getArgumentTypes(identifier.getSignature());
49 type = types[parameterId].getClassName();
50 } else {
51 type = identifier.getClassName();
52 }
53 return !(type.startsWith("java/util/") ||
54 type.startsWith("java/io/"));
55 }
56
57 public static int[] compareMutabilityResults(HashMap<String, HashMap<ExtendedMethodIdentifier,ExtendedMethodIdentifier>> dynpurResults,
58 HashMap<String, HashMap<ExtendedMethodIdentifier,ExtendedMethodIdentifier>> kitResults) {
59 int numberOfMethodsExamined = 0;
60 int numberOfMethodsClassifiedPureButImpure = 0;
61 int numberOfMethodsClassifiedImpureButPure = 0;
62 int numberOfParametersClassifiedImmutableButMutable = 0;
63 int numberOfParametersClassifiedMutableButImmutable = 0;
64 int numberOfClassifiedParameters = 0;
65 int numberOfKitMethods = 0;
66 int numberOfKitParameters = 0;
67 int numberOfPureMethods = 0;
68 int numberOfKitPureMethods = 0;
69 int numberOfKitImpureMethods = 0;
70 int numberOfCorrectlyPureMethods = 0;
71 int numberOfCorrectlyImpureMethods = 0;
72 int numberOfImpureMethods = 0;
73 int numberOfKitImmutableParameters = 0;
74 int numberOfKitMutableParameters = 0;
75 int numberOfAllKitImmutableParameters = 0;
76 int numberOfAllKitMutableParameters = 0;
77 int numberOfCorrectlyImmutableParameters = 0;
78 int numberOfCorrectlyMutableParameters = 0;
79 for (String className : dynpurResults.keySet()) {
80 if (kitResults.containsKey(className)) {
81 HashMap<ExtendedMethodIdentifier, ExtendedMethodIdentifier> dynpurIds = dynpurResults.get(className);
82 HashMap<ExtendedMethodIdentifier, ExtendedMethodIdentifier> kitIds = kitResults.get(className);
83 for (ExtendedMethodIdentifier dynpurIdentifier : dynpurIds.keySet()) {
84 numberOfClassifiedParameters += dynpurIdentifier.getMutableParameters().size();
85 numberOfClassifiedParameters += dynpurIdentifier.getImmutableParameters().size();
86
87 if (kitIds.containsKey(dynpurIdentifier)) {
88 ExtendedMethodIdentifier kitIdentifier = kitIds.get(dynpurIdentifier);
89 if (dynpurIdentifier.isPure()) {
90 numberOfPureMethods++;
91 } else {
92 numberOfImpureMethods++;
93 }
94 if (kitIdentifier.isPure()) {
95 numberOfKitPureMethods++;
96 if (dynpurIdentifier.isPure()) {
97 numberOfCorrectlyPureMethods++;
98 }
99 } else {
100 numberOfKitImpureMethods++;
101 if (!dynpurIdentifier.isPure()) {
102 numberOfCorrectlyImpureMethods++;
103 }
104 }
105
106 numberOfMethodsExamined++;
107 if (kitIdentifier.isPure() && !dynpurIdentifier.isPure()) {
108
109 numberOfMethodsClassifiedImpureButPure++;
110 }
111 if (!kitIdentifier.isPure() && dynpurIdentifier.isPure()) {
112 numberOfMethodsClassifiedPureButImpure++;
113 }
114 for (int mutableParameterId : kitIdentifier.getMutableParameters()) {
115 if (isClassifiableParameter(mutableParameterId, kitIdentifier)) {
116 numberOfKitMutableParameters++;
117 if (dynpurIdentifier.getMutableParameters().contains(mutableParameterId)) {
118 numberOfCorrectlyMutableParameters++;
119 } else if (dynpurIdentifier.getImmutableParameters().contains(mutableParameterId)) {
120 numberOfParametersClassifiedImmutableButMutable++;
121 } else {
122 System.out.println("Parameter " + mutableParameterId + " in method " + kitIdentifier.toString() + " not classified.");
123 }
124 }
125 }
126 for (int immutableParameterId : kitIdentifier.getImmutableParameters()) {
127 if (isClassifiableParameter(immutableParameterId, kitIdentifier)) {
128 numberOfKitImmutableParameters++;
129 if (dynpurIdentifier.getImmutableParameters().contains(immutableParameterId)) {
130 numberOfCorrectlyImmutableParameters++;
131 } else if (kitIdentifier.getMethodName().equals("<init>") && immutableParameterId == 0 && dynpurIdentifier.getMutableParameters().contains(immutableParameterId)) {
132
133 numberOfCorrectlyImmutableParameters++;
134 } else if (dynpurIdentifier.getMutableParameters().contains(immutableParameterId)) {
135 numberOfParametersClassifiedMutableButImmutable++;
136 } else {
137 System.out.println("Parameter " + immutableParameterId + " in method " + kitIdentifier.toString() + " not classified.");
138 }
139 }
140 }
141 } else {
142
143 }
144 }
145 } else {
146
147 }
148 }
149 int numberOfAllKitPureMethods = 0;
150 for (String className : kitResults.keySet()) {
151 HashMap<ExtendedMethodIdentifier, ExtendedMethodIdentifier> map = kitResults.get(className);
152 numberOfKitMethods += map.size();
153 for (ExtendedMethodIdentifier identifier : map.keySet()) {
154 if (identifier.isPure()) {
155 numberOfAllKitPureMethods++;
156 }
157 HashSet<Integer> immutableParameters = identifier.getImmutableParameters();
158 numberOfAllKitImmutableParameters += immutableParameters.size();
159 numberOfKitParameters += immutableParameters.size();
160 HashSet<Integer> mutableParameters = identifier.getMutableParameters();
161 numberOfAllKitMutableParameters += mutableParameters.size();
162 numberOfKitParameters += mutableParameters.size();
163 }
164 }
165 System.out.println("Number of all kit pure methods: " + numberOfAllKitPureMethods);
166 System.out.println("Number of classified immutable parameters: " + numberOfKitImmutableParameters);
167 System.out.println("Number of correctly classified immutable parameters: " + numberOfCorrectlyImmutableParameters);
168 System.out.println("Number of immutable parameters classified mutable: " + numberOfParametersClassifiedMutableButImmutable);
169 System.out.println("Number of classified mutable parameters: " + numberOfKitMutableParameters);
170 System.out.println("Number of correctly classified mutable parameters: " + numberOfCorrectlyMutableParameters);
171 System.out.println("Number of mutable parameters classified immutable: " + numberOfParametersClassifiedImmutableButMutable);
172 int[] result = new int[20];
173 result[INDEX_numberOfKitMethods] = numberOfKitMethods;
174 result[INDEX_numberOfMethodsExamined] = numberOfMethodsExamined;
175 result[INDEX_numberOfMethodsClassifiedImpureButPure] = numberOfMethodsClassifiedImpureButPure;
176 result[INDEX_numberOfMethodsClassifiedPureButImpure] = numberOfMethodsClassifiedPureButImpure;
177 result[INDEX_numberOfKitParameters] = numberOfKitParameters;
178 result[INDEX_numberOfClassifiedParameters] = numberOfClassifiedParameters;
179 result[INDEX_numberOfParametersClassifiedImmutableButMutable] = numberOfParametersClassifiedImmutableButMutable;
180 result[INDEX_numberOfParametersClassifiedMutableButImmutable] = numberOfParametersClassifiedMutableButImmutable;
181 result[INDEX_numberOfPureMethods] = numberOfPureMethods;
182 result[INDEX_numberOfImpureMethods] = numberOfImpureMethods;
183 result[INDEX_numberOfKitPureMethods] = numberOfKitPureMethods;
184 result[INDEX_numberOfKitImpureMethods] = numberOfKitImpureMethods;
185 result[INDEX_numberOfCorrectlyImpureMethods] = numberOfCorrectlyImpureMethods;
186 result[INDEX_numberOfCorrectlyPureMethods] = numberOfCorrectlyPureMethods;
187 result[INDEX_numberOfKitImmutableParamters] = numberOfKitImmutableParameters;
188 result[INDEX_numberOfKitMutableParameters] = numberOfKitMutableParameters;
189 result[INDEX_numberOfCorrectlyImmutableParameters] = numberOfCorrectlyImmutableParameters;
190 result[INDEX_numberOfCorrectlyMutableParameters] = numberOfCorrectlyMutableParameters;
191 result[INDEX_numberOfAllKitImutableParameters] = numberOfAllKitImmutableParameters;
192 result[INDEX_numberOfAllKitMutableParameters] = numberOfAllKitMutableParameters;
193 return result;
194 }
195 }