0001: package soot.toolkits.exceptions;
0002:
0003: import java.util.ArrayList;
0004: import java.util.Arrays;
0005: import java.util.Collections;
0006: import java.util.List;
0007: import java.util.Set;
0008:
0009: import junit.framework.Test;
0010: import junit.framework.TestCase;
0011: import junit.framework.TestSuite;
0012: import soot.AnySubType;
0013: import soot.ArrayType;
0014: import soot.DoubleType;
0015: import soot.FloatType;
0016: import soot.IntType;
0017: import soot.Local;
0018: import soot.LongType;
0019: import soot.Modifier;
0020: import soot.RefType;
0021: import soot.Scene;
0022: import soot.SootClass;
0023: import soot.SootFieldRef;
0024: import soot.SootMethod;
0025: import soot.Type;
0026: import soot.Unit;
0027: import soot.Value;
0028: import soot.VoidType;
0029: import soot.grimp.Grimp;
0030: import soot.jimple.ArrayRef;
0031: import soot.jimple.DivExpr;
0032: import soot.jimple.DoubleConstant;
0033: import soot.jimple.FloatConstant;
0034: import soot.jimple.IfStmt;
0035: import soot.jimple.InstanceFieldRef;
0036: import soot.jimple.IntConstant;
0037: import soot.jimple.Jimple;
0038: import soot.jimple.LongConstant;
0039: import soot.jimple.RemExpr;
0040: import soot.jimple.StaticFieldRef;
0041: import soot.jimple.StaticInvokeExpr;
0042: import soot.jimple.Stmt;
0043: import soot.jimple.StringConstant;
0044: import soot.jimple.ThrowStmt;
0045: import soot.jimple.VirtualInvokeExpr;
0046: import soot.toolkits.exceptions.ExceptionTestUtility.ExceptionHashSet;
0047:
0048: public class UnitThrowAnalysisTest extends TestCase {
0049:
0050: static {
0051: Scene.v().loadBasicClasses();
0052: }
0053:
0054: class ImmaculateInvokeUnitThrowAnalysis extends UnitThrowAnalysis {
0055: // A variant of UnitThrowAnalysis which assumes that invoked
0056: // methods will never throw any exceptions, rather than that
0057: // they might throw anything Throwable. This allows us to
0058: // test that individual arguments to invocations are being
0059: // examined.
0060:
0061: ThrowableSet mightThrow(SootMethod m) {
0062: return ThrowableSet.Manager.v().EMPTY;
0063: }
0064: }
0065:
0066: UnitThrowAnalysis unitAnalysis;
0067: UnitThrowAnalysis immaculateAnalysis;
0068:
0069: // A collection of Grimp values and expressions used in various tests:
0070: protected StaticFieldRef floatStaticFieldRef;
0071: protected Local floatLocal;
0072: protected FloatConstant floatConstant;
0073: protected Local floatConstantLocal;
0074: protected InstanceFieldRef floatInstanceFieldRef;
0075: protected ArrayRef floatArrayRef;
0076: protected VirtualInvokeExpr floatVirtualInvoke;
0077: protected StaticInvokeExpr floatStaticInvoke;
0078:
0079: private static String jdkLocation // Can be changed by main().
0080: = "/usr/localcc/pkgs/jdk1.4/jre/lib/rt.jar";
0081:
0082: private ExceptionTestUtility utility;
0083:
0084: public UnitThrowAnalysisTest(String name) {
0085: super (name);
0086: unitAnalysis = new UnitThrowAnalysis();
0087: immaculateAnalysis = new ImmaculateInvokeUnitThrowAnalysis();
0088: }
0089:
0090: protected void setUp() {
0091: // Ensure the Exception classes we need are represented in Soot:
0092: utility = new ExceptionTestUtility(jdkLocation);
0093:
0094: List voidList = new ArrayList();
0095: SootClass bogusClass = new SootClass("BogusClass");
0096: bogusClass.addMethod(new SootMethod("floatFunction", voidList,
0097: FloatType.v()));
0098: bogusClass.addMethod(new SootMethod("floatFunction", Arrays
0099: .asList(new Type[] { FloatType.v(), FloatType.v(), }),
0100: FloatType.v(), Modifier.STATIC));
0101: SootFieldRef nanFieldRef = Scene.v().makeFieldRef(
0102: Scene.v().getSootClass("java.lang.Float"), "NaN",
0103: FloatType.v(), true);
0104: floatStaticFieldRef = Grimp.v().newStaticFieldRef(nanFieldRef);
0105: floatLocal = Grimp.v().newLocal("local", FloatType.v());
0106: floatConstant = FloatConstant.v(33.42f);
0107: floatConstantLocal = Grimp.v().newLocal("local",
0108: RefType.v("soot.jimple.FloatConstant"));
0109: SootFieldRef valueFieldRef = Scene.v().makeFieldRef(bogusClass,
0110: "value", FloatType.v(), false);
0111: floatInstanceFieldRef = Grimp.v().newInstanceFieldRef(
0112: floatConstantLocal, valueFieldRef);
0113: floatArrayRef = Grimp.v().newArrayRef(
0114: Jimple.v().newLocal("local1", FloatType.v()),
0115: IntConstant.v(0));
0116: floatVirtualInvoke = Grimp.v().newVirtualInvokeExpr(
0117: floatConstantLocal,
0118: Scene.v().makeMethodRef(bogusClass, "floatFunction",
0119: voidList, FloatType.v(), false), voidList);
0120: floatStaticInvoke = Grimp.v()
0121: .newStaticInvokeExpr(
0122: Scene.v().makeMethodRef(
0123: bogusClass,
0124: "floatFunction",
0125: Arrays
0126: .asList(new Type[] {
0127: FloatType.v(),
0128: FloatType.v(), }),
0129: FloatType.v(), true),
0130: Arrays.asList(new Value[] {
0131: floatStaticFieldRef, floatArrayRef, }));
0132: }
0133:
0134: public void testJBreakpointStmt() {
0135: Stmt s = Grimp.v().newBreakpointStmt();
0136: assertTrue(ExceptionTestUtility.sameMembers(utility.VM_ERRORS,
0137: Collections.EMPTY_SET, unitAnalysis.mightThrow(s)));
0138: assertEquals(utility.VM_ERRORS_PLUS_SUPERTYPES, utility
0139: .catchableSubset(unitAnalysis.mightThrow(s)));
0140: }
0141:
0142: public void testGBreakpointStmt() {
0143: Stmt s = Grimp.v().newBreakpointStmt();
0144: assertTrue(ExceptionTestUtility.sameMembers(utility.VM_ERRORS,
0145: Collections.EMPTY_SET, unitAnalysis.mightThrow(s)));
0146: assertEquals(utility.VM_ERRORS_PLUS_SUPERTYPES, utility
0147: .catchableSubset(unitAnalysis.mightThrow(s)));
0148: }
0149:
0150: public void testJInvokeStmt() {
0151: List voidList = new ArrayList();
0152: Stmt s = Jimple.v().newInvokeStmt(
0153: Jimple.v().newVirtualInvokeExpr(
0154: Jimple.v().newLocal("local1",
0155: RefType.v("java.lang.Object")),
0156: Scene.v().makeMethodRef(
0157: Scene.v().getSootClass(
0158: "java.lang.Object"), "wait",
0159: voidList, VoidType.v(), false),
0160: voidList));
0161: ExceptionHashSet expectedRep = new ExceptionHashSet(
0162: utility.VM_AND_RESOLVE_METHOD_ERRORS_REP);
0163: expectedRep.add(utility.NULL_POINTER_EXCEPTION);
0164: ExceptionHashSet expectedCatch = new ExceptionHashSet(
0165: utility.VM_AND_RESOLVE_METHOD_ERRORS_PLUS_SUPERTYPES);
0166: expectedCatch.add(utility.NULL_POINTER_EXCEPTION);
0167: expectedCatch.add(utility.RUNTIME_EXCEPTION);
0168: expectedCatch.add(utility.EXCEPTION);
0169: assertTrue(ExceptionTestUtility
0170: .sameMembers(expectedRep, Collections.EMPTY_SET,
0171: immaculateAnalysis.mightThrow(s)));
0172: assertEquals(expectedCatch, utility
0173: .catchableSubset(immaculateAnalysis.mightThrow(s)));
0174: assertTrue(ExceptionTestUtility.sameMembers(
0175: utility.ALL_THROWABLES_REP, Collections.EMPTY_SET,
0176: unitAnalysis.mightThrow(s)));
0177: assertEquals(utility.ALL_TEST_THROWABLES, utility
0178: .catchableSubset(unitAnalysis.mightThrow(s)));
0179:
0180: SootClass bogusClass = new SootClass("BogusClass");
0181: bogusClass.addMethod(new SootMethod("emptyMethod", voidList,
0182: VoidType.v(), Modifier.STATIC));
0183: s = Jimple.v().newInvokeStmt(
0184: Jimple.v().newStaticInvokeExpr(
0185: Scene.v().makeMethodRef(bogusClass,
0186: "emptyMethod", voidList, VoidType.v(),
0187: true), voidList));
0188: assertTrue(ExceptionTestUtility.sameMembers(
0189: utility.ALL_ERRORS_REP, Collections.EMPTY_SET,
0190: immaculateAnalysis.mightThrow(s)));
0191: assertEquals(utility.ALL_TEST_ERRORS_PLUS_SUPERTYPES, utility
0192: .catchableSubset(immaculateAnalysis.mightThrow(s)));
0193: assertTrue(ExceptionTestUtility.sameMembers(
0194: utility.ALL_THROWABLES_REP, Collections.EMPTY_SET,
0195: unitAnalysis.mightThrow(s)));
0196: assertEquals(utility.ALL_TEST_THROWABLES, utility
0197: .catchableSubset(unitAnalysis.mightThrow(s)));
0198: }
0199:
0200: public void testGInvokeStmt() {
0201: List voidList = new ArrayList();
0202: Stmt s = Grimp.v().newInvokeStmt(
0203: Grimp.v().newVirtualInvokeExpr(
0204: Grimp.v().newLocal("local1",
0205: RefType.v("java.lang.Object")),
0206: Scene.v().makeMethodRef(
0207: Scene.v().getSootClass(
0208: "java.lang.Object"), "wait",
0209: voidList, VoidType.v(), false),
0210: voidList));
0211: ExceptionHashSet expectedRep = new ExceptionHashSet(
0212: utility.VM_AND_RESOLVE_METHOD_ERRORS_REP);
0213: expectedRep.add(utility.NULL_POINTER_EXCEPTION);
0214: ExceptionHashSet expectedCatch = new ExceptionHashSet(
0215: utility.VM_AND_RESOLVE_METHOD_ERRORS_PLUS_SUPERTYPES);
0216: expectedCatch.add(utility.NULL_POINTER_EXCEPTION);
0217: expectedCatch.add(utility.RUNTIME_EXCEPTION);
0218: expectedCatch.add(utility.EXCEPTION);
0219: assertTrue(ExceptionTestUtility
0220: .sameMembers(expectedRep, Collections.EMPTY_SET,
0221: immaculateAnalysis.mightThrow(s)));
0222: assertEquals(expectedCatch, utility
0223: .catchableSubset(immaculateAnalysis.mightThrow(s)));
0224: assertTrue(ExceptionTestUtility.sameMembers(
0225: utility.ALL_THROWABLES_REP, Collections.EMPTY_SET,
0226: unitAnalysis.mightThrow(s)));
0227: assertEquals(utility.ALL_TEST_THROWABLES, utility
0228: .catchableSubset(unitAnalysis.mightThrow(s)));
0229:
0230: SootClass bogusClass = new SootClass("BogusClass");
0231: bogusClass.addMethod(new SootMethod("emptyMethod", voidList,
0232: VoidType.v(), Modifier.STATIC));
0233: s = Jimple.v().newInvokeStmt(
0234: Jimple.v().newStaticInvokeExpr(
0235: Scene.v().makeMethodRef(bogusClass,
0236: "emptyMethod", voidList, VoidType.v(),
0237: true), voidList));
0238: s = Grimp.v().newInvokeStmt(
0239: Grimp.v().newStaticInvokeExpr(
0240: Scene.v().makeMethodRef(bogusClass,
0241: "emptyMethod", voidList, VoidType.v(),
0242: true), voidList));
0243: assertTrue(ExceptionTestUtility.sameMembers(
0244: utility.ALL_ERRORS_REP, Collections.EMPTY_SET,
0245: immaculateAnalysis.mightThrow(s)));
0246: assertEquals(utility.ALL_TEST_ERRORS_PLUS_SUPERTYPES, utility
0247: .catchableSubset(immaculateAnalysis.mightThrow(s)));
0248: assertTrue(ExceptionTestUtility.sameMembers(
0249: utility.ALL_THROWABLES_REP, Collections.EMPTY_SET,
0250: unitAnalysis.mightThrow(s)));
0251: assertEquals(utility.ALL_TEST_THROWABLES, utility
0252: .catchableSubset(unitAnalysis.mightThrow(s)));
0253: }
0254:
0255: public void testJAssignStmt() {
0256:
0257: // local0 = 0
0258: Stmt s = Jimple.v().newAssignStmt(
0259: Jimple.v().newLocal("local0", IntType.v()),
0260: IntConstant.v(0));
0261: assertTrue(ExceptionTestUtility.sameMembers(utility.VM_ERRORS,
0262: Collections.EMPTY_SET, unitAnalysis.mightThrow(s)));
0263: assertEquals(utility.VM_ERRORS_PLUS_SUPERTYPES, utility
0264: .catchableSubset(unitAnalysis.mightThrow(s)));
0265:
0266: ArrayRef arrayRef = Jimple.v().newArrayRef(
0267: Jimple.v().newLocal("local1",
0268: ArrayType.v(RefType.v("java.lang.Object"), 1)),
0269: IntConstant.v(0));
0270: Local scalarRef = Jimple.v().newLocal("local2",
0271: RefType.v("java.lang.Object"));
0272:
0273: // local2 = local1[0]
0274: s = Jimple.v().newAssignStmt(scalarRef, arrayRef);
0275:
0276: Set expectedRep = new ExceptionHashSet(utility.VM_ERRORS);
0277: expectedRep.add(utility.NULL_POINTER_EXCEPTION);
0278: expectedRep.add(utility.ARRAY_INDEX_OUT_OF_BOUNDS_EXCEPTION);
0279: assertTrue(ExceptionTestUtility.sameMembers(expectedRep,
0280: Collections.EMPTY_SET, unitAnalysis.mightThrow(s)));
0281:
0282: Set expectedCatch = new ExceptionHashSet(
0283: utility.VM_ERRORS_PLUS_SUPERTYPES);
0284: expectedCatch.add(utility.NULL_POINTER_EXCEPTION);
0285: expectedCatch.add(utility.ARRAY_INDEX_OUT_OF_BOUNDS_EXCEPTION);
0286: expectedCatch.add(utility.INDEX_OUT_OF_BOUNDS_EXCEPTION);
0287: expectedCatch.add(utility.RUNTIME_EXCEPTION);
0288: expectedCatch.add(utility.EXCEPTION);
0289: assertEquals(expectedCatch, utility
0290: .catchableSubset(unitAnalysis.mightThrow(s)));
0291:
0292: // local1[0] = local2
0293: s = Jimple.v().newAssignStmt(arrayRef, scalarRef);
0294: expectedRep.add(utility.ARRAY_STORE_EXCEPTION);
0295: assertTrue(ExceptionTestUtility.sameMembers(expectedRep,
0296: Collections.EMPTY_SET, unitAnalysis.mightThrow(s)));
0297: expectedCatch.add(utility.ARRAY_STORE_EXCEPTION);
0298: assertEquals(expectedCatch, utility
0299: .catchableSubset(unitAnalysis.mightThrow(s)));
0300: }
0301:
0302: public void testGAssignStmt() {
0303:
0304: // local0 = 0
0305: Stmt s = Grimp.v().newAssignStmt(
0306: Grimp.v().newLocal("local0", IntType.v()),
0307: IntConstant.v(0));
0308: assertTrue(ExceptionTestUtility.sameMembers(utility.VM_ERRORS,
0309: Collections.EMPTY_SET, unitAnalysis.mightThrow(s)));
0310: assertEquals(utility.VM_ERRORS_PLUS_SUPERTYPES, utility
0311: .catchableSubset(unitAnalysis.mightThrow(s)));
0312:
0313: ArrayRef arrayRef = Grimp.v().newArrayRef(
0314: Grimp.v().newLocal("local1",
0315: ArrayType.v(RefType.v("java.lang.Object"), 1)),
0316: IntConstant.v(0));
0317: Local scalarRef = Grimp.v().newLocal("local2",
0318: RefType.v("java.lang.Object"));
0319:
0320: // local2 = local1[0]
0321: s = Grimp.v().newAssignStmt(scalarRef, arrayRef);
0322:
0323: Set expectedRep = new ExceptionHashSet(utility.VM_ERRORS);
0324: expectedRep.add(utility.NULL_POINTER_EXCEPTION);
0325: expectedRep.add(utility.ARRAY_INDEX_OUT_OF_BOUNDS_EXCEPTION);
0326: assertTrue(ExceptionTestUtility.sameMembers(expectedRep,
0327: Collections.EMPTY_SET, unitAnalysis.mightThrow(s)));
0328: Set expectedCatch = new ExceptionHashSet(
0329: utility.VM_ERRORS_PLUS_SUPERTYPES);
0330: expectedCatch.add(utility.NULL_POINTER_EXCEPTION);
0331: expectedCatch.add(utility.ARRAY_INDEX_OUT_OF_BOUNDS_EXCEPTION);
0332: expectedCatch.add(utility.INDEX_OUT_OF_BOUNDS_EXCEPTION);
0333: expectedCatch.add(utility.RUNTIME_EXCEPTION);
0334: expectedCatch.add(utility.EXCEPTION);
0335: assertEquals(expectedCatch, utility
0336: .catchableSubset(unitAnalysis.mightThrow(s)));
0337:
0338: // local1[0] = local2
0339: s = Grimp.v().newAssignStmt(arrayRef, scalarRef);
0340: expectedRep.add(utility.ARRAY_STORE_EXCEPTION);
0341: assertTrue(ExceptionTestUtility.sameMembers(expectedRep,
0342: Collections.EMPTY_SET, unitAnalysis.mightThrow(s)));
0343: expectedCatch.add(utility.ARRAY_STORE_EXCEPTION);
0344: assertEquals(expectedCatch, utility
0345: .catchableSubset(unitAnalysis.mightThrow(s)));
0346: }
0347:
0348: public void testJIdentityStmt() {
0349:
0350: Stmt s = Jimple.v().newIdentityStmt(
0351: Grimp.v().newLocal("local0", IntType.v()),
0352: Jimple.v().newCaughtExceptionRef());
0353: assertTrue(ExceptionTestUtility.sameMembers(utility.VM_ERRORS,
0354: Collections.EMPTY_SET, unitAnalysis.mightThrow(s)));
0355: assertEquals(utility.VM_ERRORS_PLUS_SUPERTYPES, utility
0356: .catchableSubset(unitAnalysis.mightThrow(s)));
0357:
0358: s = Jimple.v().newIdentityStmt(
0359: Grimp.v().newLocal("local0",
0360: RefType.v("java.lang.NullPointerException")),
0361: Jimple.v().newThisRef(
0362: RefType.v("java.lang.NullPointerException")));
0363: assertTrue(ExceptionTestUtility.sameMembers(utility.VM_ERRORS,
0364: Collections.EMPTY_SET, unitAnalysis.mightThrow(s)));
0365: assertEquals(utility.VM_ERRORS_PLUS_SUPERTYPES, utility
0366: .catchableSubset(unitAnalysis.mightThrow(s)));
0367:
0368: s = Jimple
0369: .v()
0370: .newIdentityStmt(
0371: Grimp
0372: .v()
0373: .newLocal(
0374: "local0",
0375: RefType
0376: .v("java.lang.NullPointerException")),
0377: Jimple
0378: .v()
0379: .newParameterRef(
0380: RefType
0381: .v("java.lang.NullPointerException"),
0382: 0));
0383: assertTrue(ExceptionTestUtility.sameMembers(utility.VM_ERRORS,
0384: Collections.EMPTY_SET, unitAnalysis.mightThrow(s)));
0385: assertEquals(utility.VM_ERRORS_PLUS_SUPERTYPES, utility
0386: .catchableSubset(unitAnalysis.mightThrow(s)));
0387: }
0388:
0389: public void testGIdentityStmt() {
0390:
0391: Stmt s = Grimp.v().newIdentityStmt(
0392: Grimp.v().newLocal("local0", IntType.v()),
0393: Grimp.v().newCaughtExceptionRef());
0394: assertTrue(ExceptionTestUtility.sameMembers(utility.VM_ERRORS,
0395: Collections.EMPTY_SET, unitAnalysis.mightThrow(s)));
0396: assertEquals(utility.VM_ERRORS_PLUS_SUPERTYPES, utility
0397: .catchableSubset(unitAnalysis.mightThrow(s)));
0398:
0399: s = Grimp.v().newIdentityStmt(
0400: Grimp.v().newLocal("local0",
0401: RefType.v("java.lang.NullPointerException")),
0402: Grimp.v().newThisRef(
0403: RefType.v("java.lang.NullPointerException")));
0404: assertTrue(ExceptionTestUtility.sameMembers(utility.VM_ERRORS,
0405: Collections.EMPTY_SET, unitAnalysis.mightThrow(s)));
0406: assertEquals(utility.VM_ERRORS_PLUS_SUPERTYPES, utility
0407: .catchableSubset(unitAnalysis.mightThrow(s)));
0408:
0409: s = Grimp
0410: .v()
0411: .newIdentityStmt(
0412: Grimp
0413: .v()
0414: .newLocal(
0415: "local0",
0416: RefType
0417: .v("java.lang.NullPointerException")),
0418: Grimp
0419: .v()
0420: .newParameterRef(
0421: RefType
0422: .v("java.lang.NullPointerException"),
0423: 0));
0424: assertTrue(ExceptionTestUtility.sameMembers(utility.VM_ERRORS,
0425: Collections.EMPTY_SET, unitAnalysis.mightThrow(s)));
0426: assertEquals(utility.VM_ERRORS_PLUS_SUPERTYPES, utility
0427: .catchableSubset(unitAnalysis.mightThrow(s)));
0428: }
0429:
0430: public void testJEnterMonitorStmt() {
0431: Stmt s = Jimple.v().newEnterMonitorStmt(
0432: StringConstant.v("test"));
0433:
0434: Set expectedRep = new ExceptionHashSet(utility.VM_ERRORS);
0435: Set expectedCatch = new ExceptionHashSet(
0436: utility.VM_ERRORS_PLUS_SUPERTYPES);
0437: expectedRep.add(utility.NULL_POINTER_EXCEPTION);
0438: assertTrue(ExceptionTestUtility.sameMembers(expectedRep,
0439: Collections.EMPTY_SET, unitAnalysis.mightThrow(s)));
0440:
0441: expectedCatch.add(utility.NULL_POINTER_EXCEPTION);
0442: expectedCatch.add(utility.RUNTIME_EXCEPTION);
0443: expectedCatch.add(utility.EXCEPTION);
0444: assertEquals(expectedCatch, utility
0445: .catchableSubset(unitAnalysis.mightThrow(s)));
0446: }
0447:
0448: public void testGEnterMonitorStmt() {
0449: Stmt s = Grimp.v()
0450: .newEnterMonitorStmt(StringConstant.v("test"));
0451:
0452: Set expectedRep = new ExceptionHashSet(utility.VM_ERRORS);
0453: Set expectedCatch = new ExceptionHashSet(
0454: utility.VM_ERRORS_PLUS_SUPERTYPES);
0455:
0456: expectedRep.add(utility.NULL_POINTER_EXCEPTION);
0457: assertTrue(ExceptionTestUtility.sameMembers(expectedRep,
0458: Collections.EMPTY_SET, unitAnalysis.mightThrow(s)));
0459:
0460: expectedCatch.add(utility.NULL_POINTER_EXCEPTION);
0461: expectedCatch.add(utility.RUNTIME_EXCEPTION);
0462: expectedCatch.add(utility.EXCEPTION);
0463: assertEquals(expectedCatch, utility
0464: .catchableSubset(unitAnalysis.mightThrow(s)));
0465: }
0466:
0467: public void testJExitMonitorStmt() {
0468: Stmt s = Jimple.v()
0469: .newExitMonitorStmt(StringConstant.v("test"));
0470:
0471: Set expectedRep = new ExceptionHashSet(utility.VM_ERRORS);
0472: expectedRep.add(utility.ILLEGAL_MONITOR_STATE_EXCEPTION);
0473: expectedRep.add(utility.NULL_POINTER_EXCEPTION);
0474: assertTrue(ExceptionTestUtility.sameMembers(expectedRep,
0475: Collections.EMPTY_SET, unitAnalysis.mightThrow(s)));
0476:
0477: Set expectedCatch = new ExceptionHashSet(
0478: utility.VM_ERRORS_PLUS_SUPERTYPES);
0479: expectedCatch.add(utility.ILLEGAL_MONITOR_STATE_EXCEPTION);
0480: expectedCatch.add(utility.NULL_POINTER_EXCEPTION);
0481: expectedCatch.add(utility.RUNTIME_EXCEPTION);
0482: expectedCatch.add(utility.EXCEPTION);
0483: assertEquals(expectedCatch, utility
0484: .catchableSubset(unitAnalysis.mightThrow(s)));
0485: }
0486:
0487: public void testGExitMonitorStmt() {
0488: Stmt s = Grimp.v().newExitMonitorStmt(StringConstant.v("test"));
0489:
0490: Set expectedRep = new ExceptionHashSet(utility.VM_ERRORS);
0491: expectedRep.add(utility.ILLEGAL_MONITOR_STATE_EXCEPTION);
0492: expectedRep.add(utility.NULL_POINTER_EXCEPTION);
0493: assertTrue(ExceptionTestUtility.sameMembers(expectedRep,
0494: Collections.EMPTY_SET, unitAnalysis.mightThrow(s)));
0495:
0496: Set expectedCatch = new ExceptionHashSet(
0497: utility.VM_ERRORS_PLUS_SUPERTYPES);
0498: expectedCatch.add(utility.ILLEGAL_MONITOR_STATE_EXCEPTION);
0499: expectedCatch.add(utility.NULL_POINTER_EXCEPTION);
0500: expectedCatch.add(utility.RUNTIME_EXCEPTION);
0501: expectedCatch.add(utility.EXCEPTION);
0502:
0503: assertEquals(expectedCatch, utility
0504: .catchableSubset(unitAnalysis.mightThrow(s)));
0505: }
0506:
0507: public void testJGotoStmt() {
0508: Stmt nop = Jimple.v().newNopStmt();
0509: Stmt s = Jimple.v().newGotoStmt(nop);
0510: assertTrue(ExceptionTestUtility.sameMembers(utility.VM_ERRORS,
0511: Collections.EMPTY_SET, unitAnalysis.mightThrow(s)));
0512: assertEquals(utility.VM_ERRORS_PLUS_SUPERTYPES, utility
0513: .catchableSubset(unitAnalysis.mightThrow(s)));
0514: }
0515:
0516: public void testGGotoStmt() {
0517: Stmt nop = Grimp.v().newNopStmt();
0518: Stmt s = Grimp.v().newGotoStmt(nop);
0519: assertTrue(ExceptionTestUtility.sameMembers(utility.VM_ERRORS,
0520: Collections.EMPTY_SET, unitAnalysis.mightThrow(s)));
0521: assertEquals(utility.VM_ERRORS_PLUS_SUPERTYPES, utility
0522: .catchableSubset(unitAnalysis.mightThrow(s)));
0523: }
0524:
0525: public void testJIfStmt() {
0526: IfStmt s = Jimple.v().newIfStmt(
0527: Jimple.v()
0528: .newEqExpr(IntConstant.v(1), IntConstant.v(1)),
0529: (Unit) null);
0530: s.setTarget(s); // A very tight infinite loop.
0531: assertTrue(ExceptionTestUtility.sameMembers(utility.VM_ERRORS,
0532: Collections.EMPTY_SET, unitAnalysis.mightThrow(s)));
0533: assertEquals(utility.VM_ERRORS_PLUS_SUPERTYPES, utility
0534: .catchableSubset(unitAnalysis.mightThrow(s)));
0535: }
0536:
0537: public void testGIfStmt() {
0538: IfStmt s = Grimp.v()
0539: .newIfStmt(
0540: Grimp.v().newEqExpr(IntConstant.v(1),
0541: IntConstant.v(1)), (Unit) null);
0542: s.setTarget(s); // A very tight infinite loop.
0543: assertTrue(ExceptionTestUtility.sameMembers(utility.VM_ERRORS,
0544: Collections.EMPTY_SET, unitAnalysis.mightThrow(s)));
0545: assertEquals(utility.VM_ERRORS_PLUS_SUPERTYPES, utility
0546: .catchableSubset(unitAnalysis.mightThrow(s)));
0547: }
0548:
0549: public void testJLookupSwitchStmt() {
0550: Stmt target = Jimple.v().newAssignStmt(
0551: Jimple.v().newLocal("local0", IntType.v()),
0552: IntConstant.v(0));
0553: Stmt s = Jimple.v().newLookupSwitchStmt(IntConstant.v(1),
0554: Arrays.asList(new Value[] { IntConstant.v(1) }),
0555: Arrays.asList(new Unit[] { target }), target);
0556: assertTrue(ExceptionTestUtility.sameMembers(utility.VM_ERRORS,
0557: Collections.EMPTY_SET, unitAnalysis.mightThrow(s)));
0558: assertEquals(utility.VM_ERRORS_PLUS_SUPERTYPES, utility
0559: .catchableSubset(unitAnalysis.mightThrow(s)));
0560: }
0561:
0562: public void testGLookupSwitchStmt() {
0563: Stmt target = Grimp.v().newAssignStmt(
0564: Grimp.v().newLocal("local0", IntType.v()),
0565: IntConstant.v(0));
0566: Stmt s = Grimp.v().newLookupSwitchStmt(IntConstant.v(1),
0567: Arrays.asList(new Value[] { IntConstant.v(1) }),
0568: Arrays.asList(new Unit[] { target }), target);
0569: assertTrue(ExceptionTestUtility.sameMembers(utility.VM_ERRORS,
0570: Collections.EMPTY_SET, unitAnalysis.mightThrow(s)));
0571: assertEquals(utility.VM_ERRORS_PLUS_SUPERTYPES, utility
0572: .catchableSubset(unitAnalysis.mightThrow(s)));
0573: }
0574:
0575: public void testJNopStmt() {
0576: Stmt s = Jimple.v().newNopStmt();
0577: Set expectedRep = new ExceptionHashSet(utility.VM_ERRORS);
0578: assertTrue(ExceptionTestUtility.sameMembers(expectedRep,
0579: Collections.EMPTY_SET, unitAnalysis.mightThrow(s)));
0580: }
0581:
0582: public void testGNopStmt() {
0583: Stmt s = Grimp.v().newNopStmt();
0584: Set expectedRep = new ExceptionHashSet(utility.VM_ERRORS);
0585: assertTrue(ExceptionTestUtility.sameMembers(expectedRep,
0586: Collections.EMPTY_SET, unitAnalysis.mightThrow(s)));
0587: }
0588:
0589: public void testJReturnStmt() {
0590: Stmt s = Jimple.v().newReturnStmt(IntConstant.v(1));
0591:
0592: Set expectedRep = new ExceptionHashSet(utility.VM_ERRORS);
0593: expectedRep.add(utility.ILLEGAL_MONITOR_STATE_EXCEPTION);
0594: assertTrue(ExceptionTestUtility.sameMembers(expectedRep,
0595: Collections.EMPTY_SET, unitAnalysis.mightThrow(s)));
0596:
0597: Set expectedCatch = new ExceptionHashSet(
0598: utility.VM_ERRORS_PLUS_SUPERTYPES);
0599: expectedCatch.add(utility.ILLEGAL_MONITOR_STATE_EXCEPTION);
0600: expectedCatch.add(utility.RUNTIME_EXCEPTION);
0601: expectedCatch.add(utility.EXCEPTION);
0602: assertEquals(expectedCatch, utility
0603: .catchableSubset(unitAnalysis.mightThrow(s)));
0604: }
0605:
0606: public void testGReturnStmt() {
0607: Stmt s = Grimp.v().newReturnStmt(IntConstant.v(1));
0608:
0609: Set expectedRep = new ExceptionHashSet(utility.VM_ERRORS);
0610: expectedRep.add(utility.ILLEGAL_MONITOR_STATE_EXCEPTION);
0611: assertTrue(ExceptionTestUtility.sameMembers(expectedRep,
0612: Collections.EMPTY_SET, unitAnalysis.mightThrow(s)));
0613:
0614: Set expectedCatch = new ExceptionHashSet(
0615: utility.VM_ERRORS_PLUS_SUPERTYPES);
0616: expectedCatch.add(utility.ILLEGAL_MONITOR_STATE_EXCEPTION);
0617: expectedCatch.add(utility.RUNTIME_EXCEPTION);
0618: expectedCatch.add(utility.EXCEPTION);
0619: assertEquals(expectedCatch, utility
0620: .catchableSubset(unitAnalysis.mightThrow(s)));
0621: }
0622:
0623: public void testJReturnVoidStmt() {
0624: Stmt s = Jimple.v().newReturnVoidStmt();
0625:
0626: Set expectedRep = new ExceptionHashSet(utility.VM_ERRORS);
0627: expectedRep.add(utility.ILLEGAL_MONITOR_STATE_EXCEPTION);
0628: assertTrue(ExceptionTestUtility.sameMembers(expectedRep,
0629: Collections.EMPTY_SET, unitAnalysis.mightThrow(s)));
0630:
0631: Set expectedCatch = new ExceptionHashSet(
0632: utility.VM_ERRORS_PLUS_SUPERTYPES);
0633: expectedCatch.add(utility.ILLEGAL_MONITOR_STATE_EXCEPTION);
0634: expectedCatch.add(utility.RUNTIME_EXCEPTION);
0635: expectedCatch.add(utility.EXCEPTION);
0636: assertEquals(expectedCatch, utility
0637: .catchableSubset(unitAnalysis.mightThrow(s)));
0638: }
0639:
0640: public void testGReturnVoidStmt() {
0641: Stmt s = Grimp.v().newReturnVoidStmt();
0642:
0643: Set expectedRep = new ExceptionHashSet(utility.VM_ERRORS);
0644: expectedRep.add(utility.ILLEGAL_MONITOR_STATE_EXCEPTION);
0645: assertTrue(ExceptionTestUtility.sameMembers(expectedRep,
0646: Collections.EMPTY_SET, unitAnalysis.mightThrow(s)));
0647:
0648: Set expectedCatch = new ExceptionHashSet(
0649: utility.VM_ERRORS_PLUS_SUPERTYPES);
0650: expectedCatch.add(utility.ILLEGAL_MONITOR_STATE_EXCEPTION);
0651: expectedCatch.add(utility.RUNTIME_EXCEPTION);
0652: expectedCatch.add(utility.EXCEPTION);
0653: assertEquals(expectedCatch, utility
0654: .catchableSubset(unitAnalysis.mightThrow(s)));
0655: }
0656:
0657: public void testJTableSwitchStmt() {
0658: Stmt target = Jimple.v().newAssignStmt(
0659: Jimple.v().newLocal("local0", IntType.v()),
0660: IntConstant.v(0));
0661: Stmt s = Jimple.v().newTableSwitchStmt(IntConstant.v(1), 0, 1,
0662: Arrays.asList(new Unit[] { target }), target);
0663: assertTrue(ExceptionTestUtility.sameMembers(utility.VM_ERRORS,
0664: Collections.EMPTY_SET, unitAnalysis.mightThrow(s)));
0665: assertEquals(utility.VM_ERRORS_PLUS_SUPERTYPES, utility
0666: .catchableSubset(unitAnalysis.mightThrow(s)));
0667: }
0668:
0669: public void testGTableSwitchStmt() {
0670: Stmt target = Grimp.v().newAssignStmt(
0671: Grimp.v().newLocal("local0", IntType.v()),
0672: IntConstant.v(0));
0673: Stmt s = Grimp.v().newTableSwitchStmt(IntConstant.v(1), 0, 1,
0674: Arrays.asList(new Unit[] { target }), target);
0675: assertTrue(ExceptionTestUtility.sameMembers(utility.VM_ERRORS,
0676: Collections.EMPTY_SET, unitAnalysis.mightThrow(s)));
0677: assertEquals(utility.VM_ERRORS_PLUS_SUPERTYPES, utility
0678: .catchableSubset(unitAnalysis.mightThrow(s)));
0679: }
0680:
0681: public void testJThrowStmt() {
0682:
0683: // First test with an argument that is included in
0684: // PERENNIAL_THROW_EXCEPTIONS.
0685: ThrowStmt s = Jimple.v().newThrowStmt(
0686: Jimple.v().newLocal("local0",
0687: RefType.v("java.lang.NullPointerException")));
0688: Set expectedRep = new ExceptionHashSet(
0689: utility.PERENNIAL_THROW_EXCEPTIONS);
0690: expectedRep.remove(utility.NULL_POINTER_EXCEPTION);
0691: expectedRep.add(AnySubType.v(utility.NULL_POINTER_EXCEPTION));
0692: assertTrue(ExceptionTestUtility.sameMembers(expectedRep,
0693: Collections.EMPTY_SET, unitAnalysis.mightThrow(s)));
0694: assertEquals(
0695: utility.PERENNIAL_THROW_EXCEPTIONS_PLUS_SUPERTYPES,
0696: utility.catchableSubset(unitAnalysis.mightThrow(s)));
0697:
0698: // Throw a local of type IncompatibleClassChangeError.
0699: Local local = Jimple.v().newLocal("local1",
0700: utility.INCOMPATIBLE_CLASS_CHANGE_ERROR);
0701: s.setOp(local);
0702: expectedRep = new ExceptionHashSet(
0703: utility.THROW_PLUS_INCOMPATIBLE_CLASS_CHANGE);
0704: expectedRep.remove(utility.INCOMPATIBLE_CLASS_CHANGE_ERROR);
0705: expectedRep.add(AnySubType
0706: .v(utility.INCOMPATIBLE_CLASS_CHANGE_ERROR));
0707: assertTrue(ExceptionTestUtility.sameMembers(expectedRep,
0708: Collections.EMPTY_SET, unitAnalysis.mightThrow(s)));
0709: assertEquals(
0710: utility.THROW_PLUS_INCOMPATIBLE_CLASS_CHANGE_PLUS_SUBTYPES_PLUS_SUPERTYPES,
0711: utility.catchableSubset(unitAnalysis.mightThrow(s)));
0712:
0713: // Throw a local of unknown type.
0714: local = Jimple.v().newLocal("local1", soot.UnknownType.v());
0715: s.setOp(local);
0716: assertTrue(ExceptionTestUtility.sameMembers(
0717: utility.ALL_THROWABLES_REP, Collections.EMPTY_SET,
0718: unitAnalysis.mightThrow(s)));
0719: assertEquals(utility.ALL_TEST_THROWABLES, utility
0720: .catchableSubset(unitAnalysis.mightThrow(s)));
0721: }
0722:
0723: public void testGThrowStmt() {
0724: ThrowStmt s = Grimp.v().newThrowStmt(
0725: Grimp.v().newLocal("local0",
0726: RefType.v("java.util.zip.ZipException")));
0727:
0728: Set expectedRep = new ExceptionHashSet(
0729: utility.PERENNIAL_THROW_EXCEPTIONS);
0730: expectedRep.add(AnySubType.v(Scene.v().getRefType(
0731: "java.util.zip.ZipException")));
0732: assertTrue(ExceptionTestUtility.sameMembers(expectedRep,
0733: Collections.EMPTY_SET, unitAnalysis.mightThrow(s)));
0734:
0735: Set expectedCatch = new ExceptionHashSet(
0736: utility.PERENNIAL_THROW_EXCEPTIONS_PLUS_SUPERTYPES);
0737: // We don't need to add java.util.zip.ZipException, since it is not
0738: // in the universe of test Throwables.
0739: assertEquals(expectedCatch, utility
0740: .catchableSubset(unitAnalysis.mightThrow(s)));
0741:
0742: // Now throw a new IncompatibleClassChangeError.
0743: s = Grimp.v().newThrowStmt(
0744: Grimp.v().newNewInvokeExpr(
0745: utility.INCOMPATIBLE_CLASS_CHANGE_ERROR,
0746: Scene.v().makeMethodRef(
0747: utility.INCOMPATIBLE_CLASS_CHANGE_ERROR
0748: .getSootClass(), "void <init>",
0749: Collections.EMPTY_LIST, VoidType.v(),
0750: false), new ArrayList()));
0751: assertTrue(ExceptionTestUtility.sameMembers(
0752: utility.THROW_PLUS_INCOMPATIBLE_CLASS_CHANGE,
0753: Collections.EMPTY_SET, unitAnalysis.mightThrow(s)));
0754: assertEquals(
0755: utility.THROW_PLUS_INCOMPATIBLE_CLASS_CHANGE_PLUS_SUPERTYPES,
0756: utility.catchableSubset(unitAnalysis.mightThrow(s)));
0757:
0758: // Throw a local of type IncompatibleClassChangeError.
0759: Local local = Grimp.v().newLocal("local1",
0760: utility.INCOMPATIBLE_CLASS_CHANGE_ERROR);
0761: s.setOp(local);
0762: expectedRep = new ExceptionHashSet(
0763: utility.PERENNIAL_THROW_EXCEPTIONS);
0764: expectedRep.remove(utility.INCOMPATIBLE_CLASS_CHANGE_ERROR);
0765: expectedRep.add(AnySubType
0766: .v(utility.INCOMPATIBLE_CLASS_CHANGE_ERROR));
0767: assertTrue(ExceptionTestUtility.sameMembers(expectedRep,
0768: Collections.EMPTY_SET, unitAnalysis.mightThrow(s)));
0769: assertEquals(
0770: utility.THROW_PLUS_INCOMPATIBLE_CLASS_CHANGE_PLUS_SUBTYPES_PLUS_SUPERTYPES,
0771: utility.catchableSubset(unitAnalysis.mightThrow(s)));
0772:
0773: // Throw a local of unknown type.
0774: local = Jimple.v().newLocal("local1", soot.UnknownType.v());
0775: s.setOp(local);
0776: assertTrue(ExceptionTestUtility.sameMembers(
0777: utility.ALL_THROWABLES_REP, Collections.EMPTY_SET,
0778: unitAnalysis.mightThrow(s)));
0779: assertEquals(utility.ALL_TEST_THROWABLES, utility
0780: .catchableSubset(unitAnalysis.mightThrow(s)));
0781: }
0782:
0783: public void testJArrayRef() {
0784: ArrayRef arrayRef = Jimple.v().newArrayRef(
0785: Jimple.v().newLocal("local1",
0786: ArrayType.v(RefType.v("java.lang.Object"), 1)),
0787: IntConstant.v(0));
0788:
0789: Set expectedRep = new ExceptionHashSet(utility.VM_ERRORS);
0790: expectedRep.add(utility.NULL_POINTER_EXCEPTION);
0791: expectedRep.add(utility.ARRAY_INDEX_OUT_OF_BOUNDS_EXCEPTION);
0792: assertTrue(ExceptionTestUtility.sameMembers(expectedRep,
0793: Collections.EMPTY_SET, unitAnalysis
0794: .mightThrow(arrayRef)));
0795:
0796: Set expectedCatch = new ExceptionHashSet(
0797: utility.VM_ERRORS_PLUS_SUPERTYPES);
0798: expectedCatch.add(utility.NULL_POINTER_EXCEPTION);
0799: expectedCatch.add(utility.ARRAY_INDEX_OUT_OF_BOUNDS_EXCEPTION);
0800: expectedCatch.add(utility.INDEX_OUT_OF_BOUNDS_EXCEPTION);
0801: expectedCatch.add(utility.RUNTIME_EXCEPTION);
0802: expectedCatch.add(utility.EXCEPTION);
0803: assertEquals(expectedCatch, utility
0804: .catchableSubset(unitAnalysis.mightThrow(arrayRef)));
0805: }
0806:
0807: public void testGArrayRef() {
0808: ArrayRef arrayRef = Grimp.v().newArrayRef(
0809: Grimp.v().newLocal("local1",
0810: ArrayType.v(RefType.v("java.lang.Object"), 1)),
0811: IntConstant.v(0));
0812:
0813: Set expectedRep = new ExceptionHashSet(utility.VM_ERRORS);
0814: expectedRep.add(utility.NULL_POINTER_EXCEPTION);
0815: expectedRep.add(utility.ARRAY_INDEX_OUT_OF_BOUNDS_EXCEPTION);
0816: assertTrue(ExceptionTestUtility.sameMembers(expectedRep,
0817: Collections.EMPTY_SET, unitAnalysis
0818: .mightThrow(arrayRef)));
0819:
0820: Set expectedCatch = new ExceptionHashSet(
0821: utility.VM_ERRORS_PLUS_SUPERTYPES);
0822: expectedCatch.add(utility.NULL_POINTER_EXCEPTION);
0823: expectedCatch.add(utility.ARRAY_INDEX_OUT_OF_BOUNDS_EXCEPTION);
0824: expectedCatch.add(utility.INDEX_OUT_OF_BOUNDS_EXCEPTION);
0825: expectedCatch.add(utility.RUNTIME_EXCEPTION);
0826: expectedCatch.add(utility.EXCEPTION);
0827: assertEquals(expectedCatch, utility
0828: .catchableSubset(unitAnalysis.mightThrow(arrayRef)));
0829: }
0830:
0831: public void testJDivExpr() {
0832: Set vmAndArithmetic = new ExceptionHashSet(utility.VM_ERRORS);
0833: vmAndArithmetic.add(utility.ARITHMETIC_EXCEPTION);
0834: Set vmAndArithmeticAndSupertypes = new ExceptionHashSet(
0835: utility.VM_ERRORS_PLUS_SUPERTYPES);
0836: vmAndArithmeticAndSupertypes.add(utility.ARITHMETIC_EXCEPTION);
0837: vmAndArithmeticAndSupertypes.add(utility.RUNTIME_EXCEPTION);
0838: vmAndArithmeticAndSupertypes.add(utility.EXCEPTION);
0839:
0840: Local intLocal = Jimple.v().newLocal("intLocal", IntType.v());
0841: Local longLocal = Jimple.v()
0842: .newLocal("longLocal", LongType.v());
0843: Local floatLocal = Jimple.v().newLocal("floatLocal",
0844: FloatType.v());
0845: Local doubleLocal = Jimple.v().newLocal("doubleLocal",
0846: DoubleType.v());
0847:
0848: DivExpr v = Jimple.v().newDivExpr(intLocal, IntConstant.v(0));
0849: assertTrue(ExceptionTestUtility.sameMembers(vmAndArithmetic,
0850: Collections.EMPTY_SET, unitAnalysis.mightThrow(v)));
0851: assertEquals(vmAndArithmeticAndSupertypes, utility
0852: .catchableSubset(unitAnalysis.mightThrow(v)));
0853:
0854: v = Jimple.v().newDivExpr(intLocal, IntConstant.v(2));
0855: assertTrue(ExceptionTestUtility.sameMembers(utility.VM_ERRORS,
0856: Collections.EMPTY_SET, unitAnalysis.mightThrow(v)));
0857: assertEquals(utility.VM_ERRORS_PLUS_SUPERTYPES, utility
0858: .catchableSubset(unitAnalysis.mightThrow(v)));
0859:
0860: v = Jimple.v().newDivExpr(IntConstant.v(0), IntConstant.v(2));
0861: assertTrue(ExceptionTestUtility.sameMembers(utility.VM_ERRORS,
0862: Collections.EMPTY_SET, unitAnalysis.mightThrow(v)));
0863: assertEquals(utility.VM_ERRORS_PLUS_SUPERTYPES, utility
0864: .catchableSubset(unitAnalysis.mightThrow(v)));
0865:
0866: v = Jimple.v().newDivExpr(intLocal, intLocal);
0867: assertTrue(ExceptionTestUtility.sameMembers(vmAndArithmetic,
0868: Collections.EMPTY_SET, unitAnalysis.mightThrow(v)));
0869: assertEquals(vmAndArithmeticAndSupertypes, utility
0870: .catchableSubset(unitAnalysis.mightThrow(v)));
0871:
0872: v = Jimple.v().newDivExpr(longLocal, LongConstant.v(0));
0873: assertTrue(ExceptionTestUtility.sameMembers(vmAndArithmetic,
0874: Collections.EMPTY_SET, unitAnalysis.mightThrow(v)));
0875: assertEquals(vmAndArithmeticAndSupertypes, utility
0876: .catchableSubset(unitAnalysis.mightThrow(v)));
0877:
0878: v = Jimple.v().newDivExpr(longLocal, LongConstant.v(2));
0879: assertTrue(ExceptionTestUtility.sameMembers(utility.VM_ERRORS,
0880: Collections.EMPTY_SET, unitAnalysis.mightThrow(v)));
0881: assertEquals(utility.VM_ERRORS_PLUS_SUPERTYPES, utility
0882: .catchableSubset(unitAnalysis.mightThrow(v)));
0883:
0884: v = Jimple.v().newDivExpr(LongConstant.v(0), LongConstant.v(2));
0885: assertTrue(ExceptionTestUtility.sameMembers(utility.VM_ERRORS,
0886: Collections.EMPTY_SET, unitAnalysis.mightThrow(v)));
0887: assertEquals(utility.VM_ERRORS_PLUS_SUPERTYPES, utility
0888: .catchableSubset(unitAnalysis.mightThrow(v)));
0889:
0890: v = Jimple.v().newDivExpr(longLocal, longLocal);
0891: assertTrue(ExceptionTestUtility.sameMembers(vmAndArithmetic,
0892: Collections.EMPTY_SET, unitAnalysis.mightThrow(v)));
0893: assertEquals(vmAndArithmeticAndSupertypes, utility
0894: .catchableSubset(unitAnalysis.mightThrow(v)));
0895:
0896: v = Jimple.v().newDivExpr(floatLocal, FloatConstant.v(0.0f));
0897: assertTrue(ExceptionTestUtility.sameMembers(utility.VM_ERRORS,
0898: Collections.EMPTY_SET, unitAnalysis.mightThrow(v)));
0899: assertEquals(utility.VM_ERRORS_PLUS_SUPERTYPES, utility
0900: .catchableSubset(unitAnalysis.mightThrow(v)));
0901:
0902: v = Jimple.v().newDivExpr(floatLocal, FloatConstant.v(2.0f));
0903: assertTrue(ExceptionTestUtility.sameMembers(utility.VM_ERRORS,
0904: Collections.EMPTY_SET, unitAnalysis.mightThrow(v)));
0905: assertEquals(utility.VM_ERRORS_PLUS_SUPERTYPES, utility
0906: .catchableSubset(unitAnalysis.mightThrow(v)));
0907:
0908: v = Jimple.v().newDivExpr(FloatConstant.v(0),
0909: FloatConstant.v(2.0f));
0910: assertTrue(ExceptionTestUtility.sameMembers(utility.VM_ERRORS,
0911: Collections.EMPTY_SET, unitAnalysis.mightThrow(v)));
0912: assertEquals(utility.VM_ERRORS_PLUS_SUPERTYPES, utility
0913: .catchableSubset(unitAnalysis.mightThrow(v)));
0914:
0915: v = Jimple.v().newDivExpr(floatLocal, floatLocal);
0916: assertTrue(ExceptionTestUtility.sameMembers(utility.VM_ERRORS,
0917: Collections.EMPTY_SET, unitAnalysis.mightThrow(v)));
0918: assertEquals(utility.VM_ERRORS_PLUS_SUPERTYPES, utility
0919: .catchableSubset(unitAnalysis.mightThrow(v)));
0920:
0921: v = Jimple.v().newDivExpr(doubleLocal, DoubleConstant.v(0.0));
0922: assertTrue(ExceptionTestUtility.sameMembers(utility.VM_ERRORS,
0923: Collections.EMPTY_SET, unitAnalysis.mightThrow(v)));
0924: assertEquals(utility.VM_ERRORS_PLUS_SUPERTYPES, utility
0925: .catchableSubset(unitAnalysis.mightThrow(v)));
0926:
0927: v = Jimple.v().newDivExpr(doubleLocal, DoubleConstant.v(2.0));
0928: assertTrue(ExceptionTestUtility.sameMembers(utility.VM_ERRORS,
0929: Collections.EMPTY_SET, unitAnalysis.mightThrow(v)));
0930: assertEquals(utility.VM_ERRORS_PLUS_SUPERTYPES, utility
0931: .catchableSubset(unitAnalysis.mightThrow(v)));
0932:
0933: v = Jimple.v().newDivExpr(DoubleConstant.v(0),
0934: DoubleConstant.v(2.0));
0935: assertTrue(ExceptionTestUtility.sameMembers(utility.VM_ERRORS,
0936: Collections.EMPTY_SET, unitAnalysis.mightThrow(v)));
0937: assertEquals(utility.VM_ERRORS_PLUS_SUPERTYPES, utility
0938: .catchableSubset(unitAnalysis.mightThrow(v)));
0939:
0940: v = Jimple.v().newDivExpr(doubleLocal, doubleLocal);
0941: assertTrue(ExceptionTestUtility.sameMembers(utility.VM_ERRORS,
0942: Collections.EMPTY_SET, unitAnalysis.mightThrow(v)));
0943: assertEquals(utility.VM_ERRORS_PLUS_SUPERTYPES, utility
0944: .catchableSubset(unitAnalysis.mightThrow(v)));
0945: }
0946:
0947: public void testGDivExpr() {
0948: Set vmAndArithmetic = new ExceptionHashSet(utility.VM_ERRORS);
0949: vmAndArithmetic.add(utility.ARITHMETIC_EXCEPTION);
0950: Set vmAndArithmeticAndSupertypes = new ExceptionHashSet(
0951: utility.VM_ERRORS_PLUS_SUPERTYPES);
0952: vmAndArithmeticAndSupertypes.add(utility.ARITHMETIC_EXCEPTION);
0953: vmAndArithmeticAndSupertypes.add(utility.RUNTIME_EXCEPTION);
0954: vmAndArithmeticAndSupertypes.add(utility.EXCEPTION);
0955:
0956: Local intLocal = Grimp.v().newLocal("intLocal", IntType.v());
0957: Local longLocal = Grimp.v().newLocal("longLocal", LongType.v());
0958: Local floatLocal = Grimp.v().newLocal("floatLocal",
0959: FloatType.v());
0960: Local doubleLocal = Grimp.v().newLocal("doubleLocal",
0961: DoubleType.v());
0962:
0963: DivExpr v = Grimp.v().newDivExpr(intLocal, IntConstant.v(0));
0964: assertTrue(ExceptionTestUtility.sameMembers(vmAndArithmetic,
0965: Collections.EMPTY_SET, unitAnalysis.mightThrow(v)));
0966: assertEquals(vmAndArithmeticAndSupertypes, utility
0967: .catchableSubset(unitAnalysis.mightThrow(v)));
0968:
0969: v = Grimp.v().newDivExpr(intLocal, IntConstant.v(2));
0970: assertTrue(ExceptionTestUtility.sameMembers(utility.VM_ERRORS,
0971: Collections.EMPTY_SET, unitAnalysis.mightThrow(v)));
0972: assertEquals(utility.VM_ERRORS_PLUS_SUPERTYPES, utility
0973: .catchableSubset(unitAnalysis.mightThrow(v)));
0974:
0975: v = Grimp.v().newDivExpr(IntConstant.v(0), IntConstant.v(2));
0976: assertTrue(ExceptionTestUtility.sameMembers(utility.VM_ERRORS,
0977: Collections.EMPTY_SET, unitAnalysis.mightThrow(v)));
0978: assertEquals(utility.VM_ERRORS_PLUS_SUPERTYPES, utility
0979: .catchableSubset(unitAnalysis.mightThrow(v)));
0980:
0981: v = Grimp.v().newDivExpr(intLocal, intLocal);
0982: assertTrue(ExceptionTestUtility.sameMembers(vmAndArithmetic,
0983: Collections.EMPTY_SET, unitAnalysis.mightThrow(v)));
0984: assertEquals(vmAndArithmeticAndSupertypes, utility
0985: .catchableSubset(unitAnalysis.mightThrow(v)));
0986:
0987: v = Grimp.v().newDivExpr(
0988: Grimp.v().newAddExpr(intLocal, intLocal),
0989: Grimp.v().newMulExpr(intLocal, intLocal));
0990: assertTrue(ExceptionTestUtility.sameMembers(vmAndArithmetic,
0991: Collections.EMPTY_SET, unitAnalysis.mightThrow(v)));
0992: assertEquals(vmAndArithmeticAndSupertypes, utility
0993: .catchableSubset(unitAnalysis.mightThrow(v)));
0994:
0995: v = Grimp.v().newDivExpr(longLocal, LongConstant.v(0));
0996: assertTrue(ExceptionTestUtility.sameMembers(vmAndArithmetic,
0997: Collections.EMPTY_SET, unitAnalysis.mightThrow(v)));
0998: assertEquals(vmAndArithmeticAndSupertypes, utility
0999: .catchableSubset(unitAnalysis.mightThrow(v)));
1000:
1001: v = Grimp.v().newDivExpr(longLocal, LongConstant.v(2));
1002: assertTrue(ExceptionTestUtility.sameMembers(utility.VM_ERRORS,
1003: Collections.EMPTY_SET, unitAnalysis.mightThrow(v)));
1004: assertEquals(utility.VM_ERRORS_PLUS_SUPERTYPES, utility
1005: .catchableSubset(unitAnalysis.mightThrow(v)));
1006:
1007: v = Grimp.v().newDivExpr(LongConstant.v(0), LongConstant.v(2));
1008: assertTrue(ExceptionTestUtility.sameMembers(utility.VM_ERRORS,
1009: Collections.EMPTY_SET, unitAnalysis.mightThrow(v)));
1010: assertEquals(utility.VM_ERRORS_PLUS_SUPERTYPES, utility
1011: .catchableSubset(unitAnalysis.mightThrow(v)));
1012:
1013: v = Grimp.v().newDivExpr(longLocal, longLocal);
1014: assertTrue(ExceptionTestUtility.sameMembers(vmAndArithmetic,
1015: Collections.EMPTY_SET, unitAnalysis.mightThrow(v)));
1016: assertEquals(vmAndArithmeticAndSupertypes, utility
1017: .catchableSubset(unitAnalysis.mightThrow(v)));
1018:
1019: v = Grimp.v().newDivExpr(
1020: Grimp.v().newAddExpr(longLocal, longLocal),
1021: Grimp.v().newMulExpr(longLocal, longLocal));
1022: assertTrue(ExceptionTestUtility.sameMembers(vmAndArithmetic,
1023: Collections.EMPTY_SET, unitAnalysis.mightThrow(v)));
1024: assertEquals(vmAndArithmeticAndSupertypes, utility
1025: .catchableSubset(unitAnalysis.mightThrow(v)));
1026:
1027: v = Grimp.v().newDivExpr(floatLocal, FloatConstant.v(0.0f));
1028: assertTrue(ExceptionTestUtility.sameMembers(utility.VM_ERRORS,
1029: Collections.EMPTY_SET, unitAnalysis.mightThrow(v)));
1030: assertEquals(utility.VM_ERRORS_PLUS_SUPERTYPES, utility
1031: .catchableSubset(unitAnalysis.mightThrow(v)));
1032:
1033: v = Grimp.v().newDivExpr(floatLocal, FloatConstant.v(2.0f));
1034: assertTrue(ExceptionTestUtility.sameMembers(utility.VM_ERRORS,
1035: Collections.EMPTY_SET, unitAnalysis.mightThrow(v)));
1036: assertEquals(utility.VM_ERRORS_PLUS_SUPERTYPES, utility
1037: .catchableSubset(unitAnalysis.mightThrow(v)));
1038:
1039: v = Grimp.v().newDivExpr(FloatConstant.v(0),
1040: FloatConstant.v(2.0f));
1041: assertTrue(ExceptionTestUtility.sameMembers(utility.VM_ERRORS,
1042: Collections.EMPTY_SET, unitAnalysis.mightThrow(v)));
1043: assertEquals(utility.VM_ERRORS_PLUS_SUPERTYPES, utility
1044: .catchableSubset(unitAnalysis.mightThrow(v)));
1045:
1046: v = Grimp.v().newDivExpr(floatLocal, floatLocal);
1047: assertTrue(ExceptionTestUtility.sameMembers(utility.VM_ERRORS,
1048: Collections.EMPTY_SET, unitAnalysis.mightThrow(v)));
1049: assertEquals(utility.VM_ERRORS_PLUS_SUPERTYPES, utility
1050: .catchableSubset(unitAnalysis.mightThrow(v)));
1051:
1052: v = Grimp.v().newDivExpr(doubleLocal, DoubleConstant.v(0.0));
1053: assertTrue(ExceptionTestUtility.sameMembers(utility.VM_ERRORS,
1054: Collections.EMPTY_SET, unitAnalysis.mightThrow(v)));
1055: assertEquals(utility.VM_ERRORS_PLUS_SUPERTYPES, utility
1056: .catchableSubset(unitAnalysis.mightThrow(v)));
1057:
1058: v = Grimp.v().newDivExpr(doubleLocal, DoubleConstant.v(2.0));
1059: assertTrue(ExceptionTestUtility.sameMembers(utility.VM_ERRORS,
1060: Collections.EMPTY_SET, unitAnalysis.mightThrow(v)));
1061: assertEquals(utility.VM_ERRORS_PLUS_SUPERTYPES, utility
1062: .catchableSubset(unitAnalysis.mightThrow(v)));
1063:
1064: v = Grimp.v().newDivExpr(DoubleConstant.v(0),
1065: DoubleConstant.v(2.0));
1066: assertTrue(ExceptionTestUtility.sameMembers(utility.VM_ERRORS,
1067: Collections.EMPTY_SET, unitAnalysis.mightThrow(v)));
1068: assertEquals(utility.VM_ERRORS_PLUS_SUPERTYPES, utility
1069: .catchableSubset(unitAnalysis.mightThrow(v)));
1070:
1071: v = Grimp.v().newDivExpr(doubleLocal, doubleLocal);
1072: assertTrue(ExceptionTestUtility.sameMembers(utility.VM_ERRORS,
1073: Collections.EMPTY_SET, unitAnalysis.mightThrow(v)));
1074: assertEquals(utility.VM_ERRORS_PLUS_SUPERTYPES, utility
1075: .catchableSubset(unitAnalysis.mightThrow(v)));
1076: }
1077:
1078: public void testJRemExpr() {
1079: Set vmAndArithmetic = new ExceptionHashSet(utility.VM_ERRORS);
1080: vmAndArithmetic.add(utility.ARITHMETIC_EXCEPTION);
1081: Set vmAndArithmeticAndSupertypes = new ExceptionHashSet(
1082: utility.VM_ERRORS_PLUS_SUPERTYPES);
1083: vmAndArithmeticAndSupertypes.add(utility.ARITHMETIC_EXCEPTION);
1084: vmAndArithmeticAndSupertypes.add(utility.RUNTIME_EXCEPTION);
1085: vmAndArithmeticAndSupertypes.add(utility.EXCEPTION);
1086:
1087: Local intLocal = Jimple.v().newLocal("intLocal", IntType.v());
1088: Local longLocal = Jimple.v()
1089: .newLocal("longLocal", LongType.v());
1090: Local floatLocal = Jimple.v().newLocal("floatLocal",
1091: FloatType.v());
1092: Local doubleLocal = Jimple.v().newLocal("doubleLocal",
1093: DoubleType.v());
1094:
1095: RemExpr v = Jimple.v().newRemExpr(intLocal, IntConstant.v(0));
1096: assertTrue(ExceptionTestUtility.sameMembers(vmAndArithmetic,
1097: Collections.EMPTY_SET, unitAnalysis.mightThrow(v)));
1098: assertEquals(vmAndArithmeticAndSupertypes, utility
1099: .catchableSubset(unitAnalysis.mightThrow(v)));
1100:
1101: v = Jimple.v().newRemExpr(intLocal, IntConstant.v(2));
1102: assertTrue(ExceptionTestUtility.sameMembers(utility.VM_ERRORS,
1103: Collections.EMPTY_SET, unitAnalysis.mightThrow(v)));
1104: assertEquals(utility.VM_ERRORS_PLUS_SUPERTYPES, utility
1105: .catchableSubset(unitAnalysis.mightThrow(v)));
1106:
1107: v = Jimple.v().newRemExpr(IntConstant.v(0), IntConstant.v(2));
1108: assertTrue(ExceptionTestUtility.sameMembers(utility.VM_ERRORS,
1109: Collections.EMPTY_SET, unitAnalysis.mightThrow(v)));
1110: assertEquals(utility.VM_ERRORS_PLUS_SUPERTYPES, utility
1111: .catchableSubset(unitAnalysis.mightThrow(v)));
1112:
1113: v = Jimple.v().newRemExpr(intLocal, intLocal);
1114: assertTrue(ExceptionTestUtility.sameMembers(vmAndArithmetic,
1115: Collections.EMPTY_SET, unitAnalysis.mightThrow(v)));
1116: assertEquals(vmAndArithmeticAndSupertypes, utility
1117: .catchableSubset(unitAnalysis.mightThrow(v)));
1118:
1119: v = Jimple.v().newRemExpr(longLocal, LongConstant.v(0));
1120: assertTrue(ExceptionTestUtility.sameMembers(vmAndArithmetic,
1121: Collections.EMPTY_SET, unitAnalysis.mightThrow(v)));
1122: assertEquals(vmAndArithmeticAndSupertypes, utility
1123: .catchableSubset(unitAnalysis.mightThrow(v)));
1124:
1125: v = Jimple.v().newRemExpr(longLocal, LongConstant.v(2));
1126: assertTrue(ExceptionTestUtility.sameMembers(utility.VM_ERRORS,
1127: Collections.EMPTY_SET, unitAnalysis.mightThrow(v)));
1128: assertEquals(utility.VM_ERRORS_PLUS_SUPERTYPES, utility
1129: .catchableSubset(unitAnalysis.mightThrow(v)));
1130:
1131: v = Jimple.v().newRemExpr(LongConstant.v(0), LongConstant.v(2));
1132: assertTrue(ExceptionTestUtility.sameMembers(utility.VM_ERRORS,
1133: Collections.EMPTY_SET, unitAnalysis.mightThrow(v)));
1134: assertEquals(utility.VM_ERRORS_PLUS_SUPERTYPES, utility
1135: .catchableSubset(unitAnalysis.mightThrow(v)));
1136:
1137: v = Jimple.v().newRemExpr(longLocal, longLocal);
1138: assertTrue(ExceptionTestUtility.sameMembers(vmAndArithmetic,
1139: Collections.EMPTY_SET, unitAnalysis.mightThrow(v)));
1140: assertEquals(vmAndArithmeticAndSupertypes, utility
1141: .catchableSubset(unitAnalysis.mightThrow(v)));
1142:
1143: v = Jimple.v().newRemExpr(floatLocal, FloatConstant.v(0.0f));
1144: assertTrue(ExceptionTestUtility.sameMembers(utility.VM_ERRORS,
1145: Collections.EMPTY_SET, unitAnalysis.mightThrow(v)));
1146: assertEquals(utility.VM_ERRORS_PLUS_SUPERTYPES, utility
1147: .catchableSubset(unitAnalysis.mightThrow(v)));
1148:
1149: v = Jimple.v().newRemExpr(floatLocal, FloatConstant.v(2.0f));
1150: assertTrue(ExceptionTestUtility.sameMembers(utility.VM_ERRORS,
1151: Collections.EMPTY_SET, unitAnalysis.mightThrow(v)));
1152: assertEquals(utility.VM_ERRORS_PLUS_SUPERTYPES, utility
1153: .catchableSubset(unitAnalysis.mightThrow(v)));
1154:
1155: v = Jimple.v().newRemExpr(FloatConstant.v(0),
1156: FloatConstant.v(2.0f));
1157: assertTrue(ExceptionTestUtility.sameMembers(utility.VM_ERRORS,
1158: Collections.EMPTY_SET, unitAnalysis.mightThrow(v)));
1159: assertEquals(utility.VM_ERRORS_PLUS_SUPERTYPES, utility
1160: .catchableSubset(unitAnalysis.mightThrow(v)));
1161:
1162: v = Jimple.v().newRemExpr(floatLocal, floatLocal);
1163: assertTrue(ExceptionTestUtility.sameMembers(utility.VM_ERRORS,
1164: Collections.EMPTY_SET, unitAnalysis.mightThrow(v)));
1165: assertEquals(utility.VM_ERRORS_PLUS_SUPERTYPES, utility
1166: .catchableSubset(unitAnalysis.mightThrow(v)));
1167:
1168: v = Jimple.v().newRemExpr(doubleLocal, DoubleConstant.v(0.0));
1169: assertTrue(ExceptionTestUtility.sameMembers(utility.VM_ERRORS,
1170: Collections.EMPTY_SET, unitAnalysis.mightThrow(v)));
1171: assertEquals(utility.VM_ERRORS_PLUS_SUPERTYPES, utility
1172: .catchableSubset(unitAnalysis.mightThrow(v)));
1173:
1174: v = Jimple.v().newRemExpr(doubleLocal, DoubleConstant.v(2.0));
1175: assertTrue(ExceptionTestUtility.sameMembers(utility.VM_ERRORS,
1176: Collections.EMPTY_SET, unitAnalysis.mightThrow(v)));
1177: assertEquals(utility.VM_ERRORS_PLUS_SUPERTYPES, utility
1178: .catchableSubset(unitAnalysis.mightThrow(v)));
1179:
1180: v = Jimple.v().newRemExpr(DoubleConstant.v(0),
1181: DoubleConstant.v(2.0));
1182: assertTrue(ExceptionTestUtility.sameMembers(utility.VM_ERRORS,
1183: Collections.EMPTY_SET, unitAnalysis.mightThrow(v)));
1184: assertEquals(utility.VM_ERRORS_PLUS_SUPERTYPES, utility
1185: .catchableSubset(unitAnalysis.mightThrow(v)));
1186:
1187: v = Jimple.v().newRemExpr(doubleLocal, doubleLocal);
1188: assertTrue(ExceptionTestUtility.sameMembers(utility.VM_ERRORS,
1189: Collections.EMPTY_SET, unitAnalysis.mightThrow(v)));
1190: assertEquals(utility.VM_ERRORS_PLUS_SUPERTYPES, utility
1191: .catchableSubset(unitAnalysis.mightThrow(v)));
1192: }
1193:
1194: public void testGRemExpr() {
1195: Set vmAndArithmetic = new ExceptionHashSet(utility.VM_ERRORS);
1196: vmAndArithmetic.add(utility.ARITHMETIC_EXCEPTION);
1197: Set vmAndArithmeticAndSupertypes = new ExceptionHashSet(
1198: utility.VM_ERRORS_PLUS_SUPERTYPES);
1199: vmAndArithmeticAndSupertypes.add(utility.ARITHMETIC_EXCEPTION);
1200: vmAndArithmeticAndSupertypes.add(utility.RUNTIME_EXCEPTION);
1201: vmAndArithmeticAndSupertypes.add(utility.EXCEPTION);
1202:
1203: Local intLocal = Grimp.v().newLocal("intLocal", IntType.v());
1204: Local longLocal = Grimp.v().newLocal("longLocal", LongType.v());
1205: Local floatLocal = Grimp.v().newLocal("floatLocal",
1206: FloatType.v());
1207: Local doubleLocal = Grimp.v().newLocal("doubleLocal",
1208: DoubleType.v());
1209:
1210: RemExpr v = Grimp.v().newRemExpr(intLocal, IntConstant.v(0));
1211: assertTrue(ExceptionTestUtility.sameMembers(vmAndArithmetic,
1212: Collections.EMPTY_SET, unitAnalysis.mightThrow(v)));
1213: assertEquals(vmAndArithmeticAndSupertypes, utility
1214: .catchableSubset(unitAnalysis.mightThrow(v)));
1215:
1216: v = Grimp.v().newRemExpr(intLocal, IntConstant.v(2));
1217: assertTrue(ExceptionTestUtility.sameMembers(utility.VM_ERRORS,
1218: Collections.EMPTY_SET, unitAnalysis.mightThrow(v)));
1219: assertEquals(utility.VM_ERRORS_PLUS_SUPERTYPES, utility
1220: .catchableSubset(unitAnalysis.mightThrow(v)));
1221:
1222: v = Grimp.v().newRemExpr(IntConstant.v(0), IntConstant.v(2));
1223: assertTrue(ExceptionTestUtility.sameMembers(utility.VM_ERRORS,
1224: Collections.EMPTY_SET, unitAnalysis.mightThrow(v)));
1225: assertEquals(utility.VM_ERRORS_PLUS_SUPERTYPES, utility
1226: .catchableSubset(unitAnalysis.mightThrow(v)));
1227:
1228: v = Grimp.v().newRemExpr(intLocal, intLocal);
1229: assertTrue(ExceptionTestUtility.sameMembers(vmAndArithmetic,
1230: Collections.EMPTY_SET, unitAnalysis.mightThrow(v)));
1231: assertEquals(vmAndArithmeticAndSupertypes, utility
1232: .catchableSubset(unitAnalysis.mightThrow(v)));
1233:
1234: v = Grimp.v().newRemExpr(
1235: Grimp.v().newAddExpr(intLocal, intLocal),
1236: Grimp.v().newMulExpr(intLocal, intLocal));
1237: assertTrue(ExceptionTestUtility.sameMembers(vmAndArithmetic,
1238: Collections.EMPTY_SET, unitAnalysis.mightThrow(v)));
1239: assertEquals(vmAndArithmeticAndSupertypes, utility
1240: .catchableSubset(unitAnalysis.mightThrow(v)));
1241:
1242: v = Grimp.v().newRemExpr(longLocal, LongConstant.v(0));
1243: assertTrue(ExceptionTestUtility.sameMembers(vmAndArithmetic,
1244: Collections.EMPTY_SET, unitAnalysis.mightThrow(v)));
1245: assertEquals(vmAndArithmeticAndSupertypes, utility
1246: .catchableSubset(unitAnalysis.mightThrow(v)));
1247:
1248: v = Grimp.v().newRemExpr(longLocal, LongConstant.v(2));
1249: assertTrue(ExceptionTestUtility.sameMembers(utility.VM_ERRORS,
1250: Collections.EMPTY_SET, unitAnalysis.mightThrow(v)));
1251: assertEquals(utility.VM_ERRORS_PLUS_SUPERTYPES, utility
1252: .catchableSubset(unitAnalysis.mightThrow(v)));
1253:
1254: v = Grimp.v().newRemExpr(LongConstant.v(0), LongConstant.v(2));
1255: assertTrue(ExceptionTestUtility.sameMembers(utility.VM_ERRORS,
1256: Collections.EMPTY_SET, unitAnalysis.mightThrow(v)));
1257: assertEquals(utility.VM_ERRORS_PLUS_SUPERTYPES, utility
1258: .catchableSubset(unitAnalysis.mightThrow(v)));
1259:
1260: v = Grimp.v().newRemExpr(longLocal, longLocal);
1261: assertTrue(ExceptionTestUtility.sameMembers(vmAndArithmetic,
1262: Collections.EMPTY_SET, unitAnalysis.mightThrow(v)));
1263: assertEquals(vmAndArithmeticAndSupertypes, utility
1264: .catchableSubset(unitAnalysis.mightThrow(v)));
1265:
1266: v = Grimp.v().newRemExpr(
1267: Grimp.v().newAddExpr(longLocal, longLocal),
1268: Grimp.v().newMulExpr(longLocal, longLocal));
1269: assertTrue(ExceptionTestUtility.sameMembers(vmAndArithmetic,
1270: Collections.EMPTY_SET, unitAnalysis.mightThrow(v)));
1271: assertEquals(vmAndArithmeticAndSupertypes, utility
1272: .catchableSubset(unitAnalysis.mightThrow(v)));
1273:
1274: v = Grimp.v().newRemExpr(floatLocal, FloatConstant.v(0.0f));
1275: assertTrue(ExceptionTestUtility.sameMembers(utility.VM_ERRORS,
1276: Collections.EMPTY_SET, unitAnalysis.mightThrow(v)));
1277: assertEquals(utility.VM_ERRORS_PLUS_SUPERTYPES, utility
1278: .catchableSubset(unitAnalysis.mightThrow(v)));
1279:
1280: v = Grimp.v().newRemExpr(floatLocal, FloatConstant.v(2.0f));
1281: assertTrue(ExceptionTestUtility.sameMembers(utility.VM_ERRORS,
1282: Collections.EMPTY_SET, unitAnalysis.mightThrow(v)));
1283: assertEquals(utility.VM_ERRORS_PLUS_SUPERTYPES, utility
1284: .catchableSubset(unitAnalysis.mightThrow(v)));
1285:
1286: v = Grimp.v().newRemExpr(FloatConstant.v(0),
1287: FloatConstant.v(2.0f));
1288: assertTrue(ExceptionTestUtility.sameMembers(utility.VM_ERRORS,
1289: Collections.EMPTY_SET, unitAnalysis.mightThrow(v)));
1290: assertEquals(utility.VM_ERRORS_PLUS_SUPERTYPES, utility
1291: .catchableSubset(unitAnalysis.mightThrow(v)));
1292:
1293: v = Grimp.v().newRemExpr(floatLocal, floatLocal);
1294: assertTrue(ExceptionTestUtility.sameMembers(utility.VM_ERRORS,
1295: Collections.EMPTY_SET, unitAnalysis.mightThrow(v)));
1296: assertEquals(utility.VM_ERRORS_PLUS_SUPERTYPES, utility
1297: .catchableSubset(unitAnalysis.mightThrow(v)));
1298:
1299: v = Grimp.v().newRemExpr(doubleLocal, DoubleConstant.v(0.0));
1300: assertTrue(ExceptionTestUtility.sameMembers(utility.VM_ERRORS,
1301: Collections.EMPTY_SET, unitAnalysis.mightThrow(v)));
1302: assertEquals(utility.VM_ERRORS_PLUS_SUPERTYPES, utility
1303: .catchableSubset(unitAnalysis.mightThrow(v)));
1304:
1305: v = Grimp.v().newRemExpr(doubleLocal, DoubleConstant.v(2.0));
1306: assertTrue(ExceptionTestUtility.sameMembers(utility.VM_ERRORS,
1307: Collections.EMPTY_SET, unitAnalysis.mightThrow(v)));
1308: assertEquals(utility.VM_ERRORS_PLUS_SUPERTYPES, utility
1309: .catchableSubset(unitAnalysis.mightThrow(v)));
1310:
1311: v = Grimp.v().newRemExpr(DoubleConstant.v(0),
1312: DoubleConstant.v(2.0));
1313: assertTrue(ExceptionTestUtility.sameMembers(utility.VM_ERRORS,
1314: Collections.EMPTY_SET, unitAnalysis.mightThrow(v)));
1315: assertEquals(utility.VM_ERRORS_PLUS_SUPERTYPES, utility
1316: .catchableSubset(unitAnalysis.mightThrow(v)));
1317:
1318: v = Grimp.v().newRemExpr(doubleLocal, doubleLocal);
1319: assertTrue(ExceptionTestUtility.sameMembers(utility.VM_ERRORS,
1320: Collections.EMPTY_SET, unitAnalysis.mightThrow(v)));
1321: assertEquals(utility.VM_ERRORS_PLUS_SUPERTYPES, utility
1322: .catchableSubset(unitAnalysis.mightThrow(v)));
1323: }
1324:
1325: public void testJBinOpExp() {
1326: Value v = Jimple.v().newAddExpr(IntConstant.v(456),
1327: Jimple.v().newLocal("local", IntType.v()));
1328: assertTrue(ExceptionTestUtility.sameMembers(utility.VM_ERRORS,
1329: Collections.EMPTY_SET, unitAnalysis.mightThrow(v)));
1330: assertEquals(utility.VM_ERRORS_PLUS_SUPERTYPES, utility
1331: .catchableSubset(unitAnalysis.mightThrow(v)));
1332:
1333: v = Jimple.v().newOrExpr(
1334: Jimple.v().newLocal("local", LongType.v()),
1335: LongConstant.v(33));
1336: assertTrue(ExceptionTestUtility.sameMembers(utility.VM_ERRORS,
1337: Collections.EMPTY_SET, unitAnalysis.mightThrow(v)));
1338: assertEquals(utility.VM_ERRORS_PLUS_SUPERTYPES, utility
1339: .catchableSubset(unitAnalysis.mightThrow(v)));
1340:
1341: v = Jimple.v().newLeExpr(
1342: Jimple.v().newLocal("local", FloatType.v()),
1343: FloatConstant.v(33.42f));
1344: assertTrue(ExceptionTestUtility.sameMembers(utility.VM_ERRORS,
1345: Collections.EMPTY_SET, unitAnalysis.mightThrow(v)));
1346: assertEquals(utility.VM_ERRORS_PLUS_SUPERTYPES, utility
1347: .catchableSubset(unitAnalysis.mightThrow(v)));
1348:
1349: v = Jimple.v().newEqExpr(DoubleConstant.v(-33.45e-3),
1350: Jimple.v().newLocal("local", DoubleType.v()));
1351: assertTrue(ExceptionTestUtility.sameMembers(utility.VM_ERRORS,
1352: Collections.EMPTY_SET, unitAnalysis.mightThrow(v)));
1353: assertEquals(utility.VM_ERRORS_PLUS_SUPERTYPES, utility
1354: .catchableSubset(unitAnalysis.mightThrow(v)));
1355: }
1356:
1357: public void testGBinOpExp() {
1358: Value v = Grimp.v().newAddExpr(floatStaticFieldRef,
1359: floatConstant);
1360: assertTrue(ExceptionTestUtility.sameMembers(
1361: utility.ALL_ERRORS_REP, Collections.EMPTY_SET,
1362: unitAnalysis.mightThrow(v)));
1363: assertEquals(utility.ALL_TEST_ERRORS_PLUS_SUPERTYPES, utility
1364: .catchableSubset(unitAnalysis.mightThrow(v)));
1365:
1366: v = Grimp.v().newOrExpr(v, floatConstant);
1367: assertTrue(ExceptionTestUtility.sameMembers(
1368: utility.ALL_ERRORS_REP, Collections.EMPTY_SET,
1369: unitAnalysis.mightThrow(v)));
1370: assertEquals(utility.ALL_TEST_ERRORS_PLUS_SUPERTYPES, utility
1371: .catchableSubset(unitAnalysis.mightThrow(v)));
1372:
1373: Set expectedRep = new ExceptionHashSet(utility.ALL_ERRORS_REP);
1374: expectedRep.add(utility.NULL_POINTER_EXCEPTION);
1375:
1376: Set expectedCatch = new ExceptionHashSet(
1377: utility.ALL_TEST_ERRORS_PLUS_SUPERTYPES);
1378: expectedCatch.add(utility.NULL_POINTER_EXCEPTION);
1379: expectedCatch.add(utility.RUNTIME_EXCEPTION);
1380: expectedCatch.add(utility.EXCEPTION);
1381:
1382: v = Grimp.v().newLeExpr(floatInstanceFieldRef, v);
1383: assertTrue(ExceptionTestUtility.sameMembers(expectedRep,
1384: Collections.EMPTY_SET, unitAnalysis.mightThrow(v)));
1385: assertEquals(expectedCatch, utility
1386: .catchableSubset(unitAnalysis.mightThrow(v)));
1387:
1388: v = Grimp.v().newEqExpr(v, floatVirtualInvoke);
1389: assertTrue(ExceptionTestUtility
1390: .sameMembers(expectedRep, Collections.EMPTY_SET,
1391: immaculateAnalysis.mightThrow(v)));
1392: assertEquals(expectedCatch, utility
1393: .catchableSubset(immaculateAnalysis.mightThrow(v)));
1394: assertTrue(ExceptionTestUtility.sameMembers(
1395: utility.ALL_THROWABLES_REP, Collections.EMPTY_SET,
1396: unitAnalysis.mightThrow(v)));
1397: assertEquals(utility.ALL_TEST_THROWABLES, utility
1398: .catchableSubset(unitAnalysis.mightThrow(v)));
1399:
1400: expectedRep.add(utility.ARRAY_INDEX_OUT_OF_BOUNDS_EXCEPTION);
1401: expectedCatch.add(utility.ARRAY_INDEX_OUT_OF_BOUNDS_EXCEPTION);
1402: expectedCatch.add(utility.INDEX_OUT_OF_BOUNDS_EXCEPTION);
1403:
1404: v = Grimp.v().newNeExpr(v, floatStaticInvoke);
1405: assertEquals(expectedCatch, utility
1406: .catchableSubset(immaculateAnalysis.mightThrow(v)));
1407: assertEquals(expectedCatch, utility
1408: .catchableSubset(immaculateAnalysis.mightThrow(v)));
1409: assertTrue(ExceptionTestUtility.sameMembers(
1410: utility.ALL_THROWABLES_REP, Collections.EMPTY_SET,
1411: unitAnalysis.mightThrow(v)));
1412: assertEquals(utility.ALL_TEST_THROWABLES, utility
1413: .catchableSubset(unitAnalysis.mightThrow(v)));
1414: }
1415:
1416: public void testJCastExpr() {
1417: // First an upcast that can be statically proved safe.
1418: Value v = Jimple.v().newCastExpr(
1419: Jimple.v().newLocal("local",
1420: utility.INCOMPATIBLE_CLASS_CHANGE_ERROR),
1421: utility.LINKAGE_ERROR);
1422: Set expectedRep = new ExceptionHashSet(
1423: utility.VM_AND_RESOLVE_CLASS_ERRORS_REP);
1424: Set expectedCatch = new ExceptionHashSet(
1425: utility.VM_AND_RESOLVE_CLASS_ERRORS_PLUS_SUPERTYPES);
1426: assertTrue(ExceptionTestUtility.sameMembers(expectedRep,
1427: Collections.EMPTY_SET, unitAnalysis.mightThrow(v)));
1428: assertEquals(expectedCatch, utility
1429: .catchableSubset(unitAnalysis.mightThrow(v)));
1430:
1431: // Then a vacuous cast which can be statically proved safe.
1432: v = Jimple.v().newCastExpr(
1433: Jimple.v().newLocal("local", utility.LINKAGE_ERROR),
1434: utility.LINKAGE_ERROR);
1435: assertTrue(ExceptionTestUtility.sameMembers(expectedRep,
1436: Collections.EMPTY_SET, unitAnalysis.mightThrow(v)));
1437: assertEquals(expectedCatch, utility
1438: .catchableSubset(unitAnalysis.mightThrow(v)));
1439:
1440: // Finally a downcast which is not necessarily safe:
1441: v = Jimple.v().newCastExpr(
1442: Jimple.v().newLocal("local", utility.LINKAGE_ERROR),
1443: utility.INCOMPATIBLE_CLASS_CHANGE_ERROR);
1444:
1445: expectedRep.add(utility.CLASS_CAST_EXCEPTION);
1446: assertTrue(ExceptionTestUtility.sameMembers(expectedRep,
1447: Collections.EMPTY_SET, unitAnalysis.mightThrow(v)));
1448:
1449: expectedCatch.add(utility.CLASS_CAST_EXCEPTION);
1450: expectedCatch.add(utility.RUNTIME_EXCEPTION);
1451: expectedCatch.add(utility.EXCEPTION);
1452:
1453: assertEquals(expectedCatch, utility
1454: .catchableSubset(unitAnalysis.mightThrow(v)));
1455: }
1456:
1457: public void testGCastExpr() {
1458: // First an upcast that can be statically proved safe.
1459: Value v = Grimp.v().newCastExpr(
1460: Jimple.v().newLocal("local",
1461: utility.INCOMPATIBLE_CLASS_CHANGE_ERROR),
1462: utility.LINKAGE_ERROR);
1463: Set expectedRep = new ExceptionHashSet(
1464: utility.VM_AND_RESOLVE_CLASS_ERRORS_REP);
1465: Set expectedCatch = new ExceptionHashSet(
1466: utility.VM_AND_RESOLVE_CLASS_ERRORS_PLUS_SUPERTYPES);
1467: assertTrue(ExceptionTestUtility.sameMembers(expectedRep,
1468: Collections.EMPTY_SET, unitAnalysis.mightThrow(v)));
1469: assertEquals(expectedCatch, utility
1470: .catchableSubset(unitAnalysis.mightThrow(v)));
1471:
1472: // Then a vacuous cast which can be statically proved safe.
1473: v = Jimple.v().newCastExpr(
1474: Jimple.v().newLocal("local", utility.LINKAGE_ERROR),
1475: utility.LINKAGE_ERROR);
1476: assertTrue(ExceptionTestUtility.sameMembers(expectedRep,
1477: Collections.EMPTY_SET, unitAnalysis.mightThrow(v)));
1478: assertEquals(expectedCatch, utility
1479: .catchableSubset(unitAnalysis.mightThrow(v)));
1480:
1481: // Finally a downcast which is not necessarily safe:
1482: v = Jimple.v().newCastExpr(
1483: Jimple.v().newLocal("local", utility.LINKAGE_ERROR),
1484: utility.INCOMPATIBLE_CLASS_CHANGE_ERROR);
1485:
1486: expectedRep.add(utility.CLASS_CAST_EXCEPTION);
1487: assertTrue(ExceptionTestUtility.sameMembers(expectedRep,
1488: Collections.EMPTY_SET, unitAnalysis.mightThrow(v)));
1489:
1490: expectedCatch.add(utility.CLASS_CAST_EXCEPTION);
1491: expectedCatch.add(utility.RUNTIME_EXCEPTION);
1492: expectedCatch.add(utility.EXCEPTION);
1493:
1494: assertEquals(expectedCatch, utility
1495: .catchableSubset(unitAnalysis.mightThrow(v)));
1496: }
1497:
1498: public void testGInstanceFieldRef() {
1499: Local local = Grimp.v().newLocal("local",
1500: utility.INCOMPATIBLE_CLASS_CHANGE_ERROR);
1501:
1502: Set expectedRep = new ExceptionHashSet(
1503: utility.VM_AND_RESOLVE_FIELD_ERRORS_REP);
1504: expectedRep.add(utility.NULL_POINTER_EXCEPTION);
1505:
1506: Set expectedCatch = new ExceptionHashSet(
1507: utility.VM_AND_RESOLVE_FIELD_ERRORS_PLUS_SUPERTYPES);
1508: expectedCatch.add(utility.NULL_POINTER_EXCEPTION);
1509: expectedCatch.add(utility.RUNTIME_EXCEPTION);
1510: expectedCatch.add(utility.EXCEPTION);
1511:
1512: Value v = Grimp.v().newInstanceFieldRef(
1513: local,
1514: Scene.v().makeFieldRef(
1515: utility.THROWABLE.getSootClass(),
1516: "detailMessage", RefType.v("java.lang.String"),
1517: false));
1518: assertTrue(ExceptionTestUtility.sameMembers(expectedRep,
1519: Collections.EMPTY_SET, unitAnalysis.mightThrow(v)));
1520: assertEquals(expectedCatch, utility
1521: .catchableSubset(unitAnalysis.mightThrow(v)));
1522: }
1523:
1524: public void testStringConstant() {
1525: Value v = StringConstant.v("test");
1526: assertTrue(ExceptionTestUtility.sameMembers(utility.VM_ERRORS,
1527: Collections.EMPTY_SET, unitAnalysis.mightThrow(v)));
1528: assertEquals(utility.VM_ERRORS_PLUS_SUPERTYPES, utility
1529: .catchableSubset(unitAnalysis.mightThrow(v)));
1530: }
1531:
1532: public void testJLocal() {
1533: Local local = Jimple.v().newLocal("local1",
1534: utility.INCOMPATIBLE_CLASS_CHANGE_ERROR);
1535: assertTrue(ExceptionTestUtility.sameMembers(utility.VM_ERRORS,
1536: Collections.EMPTY_SET, unitAnalysis.mightThrow(local)));
1537: assertEquals(utility.VM_ERRORS_PLUS_SUPERTYPES, utility
1538: .catchableSubset(unitAnalysis.mightThrow(local)));
1539: }
1540:
1541: public void testGLocal() {
1542: Local local = Grimp.v().newLocal("local1",
1543: utility.INCOMPATIBLE_CLASS_CHANGE_ERROR);
1544: assertTrue(ExceptionTestUtility.sameMembers(utility.VM_ERRORS,
1545: Collections.EMPTY_SET, unitAnalysis.mightThrow(local)));
1546: assertEquals(utility.VM_ERRORS_PLUS_SUPERTYPES, utility
1547: .catchableSubset(unitAnalysis.mightThrow(local)));
1548: }
1549:
1550: public void testBAddInst() {
1551: soot.baf.AddInst i = soot.baf.Baf.v().newAddInst(IntType.v());
1552: assertTrue(ExceptionTestUtility.sameMembers(utility.VM_ERRORS,
1553: Collections.EMPTY_SET, unitAnalysis.mightThrow(i)));
1554: assertEquals(utility.VM_ERRORS_PLUS_SUPERTYPES, utility
1555: .catchableSubset(unitAnalysis.mightThrow(i)));
1556: }
1557:
1558: public void testBAndInst() {
1559: soot.baf.AndInst i = soot.baf.Baf.v().newAndInst(IntType.v());
1560: assertTrue(ExceptionTestUtility.sameMembers(utility.VM_ERRORS,
1561: Collections.EMPTY_SET, unitAnalysis.mightThrow(i)));
1562: assertEquals(utility.VM_ERRORS_PLUS_SUPERTYPES, utility
1563: .catchableSubset(unitAnalysis.mightThrow(i)));
1564: }
1565:
1566: public void testBArrayLengthInst() {
1567: soot.baf.ArrayLengthInst i = soot.baf.Baf.v()
1568: .newArrayLengthInst();
1569: Set expectedRep = new ExceptionHashSet(utility.VM_ERRORS);
1570: expectedRep.add(utility.NULL_POINTER_EXCEPTION);
1571: assertTrue(ExceptionTestUtility.sameMembers(expectedRep,
1572: Collections.EMPTY_SET, unitAnalysis.mightThrow(i)));
1573: Set expectedCatch = new ExceptionHashSet(
1574: utility.VM_ERRORS_PLUS_SUPERTYPES);
1575: expectedCatch.add(utility.NULL_POINTER_EXCEPTION);
1576: expectedCatch.add(utility.RUNTIME_EXCEPTION);
1577: expectedCatch.add(utility.EXCEPTION);
1578: assertEquals(expectedCatch, utility
1579: .catchableSubset(unitAnalysis.mightThrow(i)));
1580: }
1581:
1582: public static Test suite() {
1583: return new TestSuite(UnitThrowAnalysisTest.class);
1584: }
1585:
1586: public static void main(String arg[]) {
1587: if (arg.length > 0) {
1588: jdkLocation = arg[0];
1589: }
1590: junit.textui.TestRunner.run(suite());
1591: }
1592: }
|