/** Goes through all methods and adds an implicit cost for those beginning with "set" (assuming * to test the {@code baseMethod}'s class, you need to be able to call the setters for initialization. */ private void addSetterInjection(MethodInfo baseMethod, TestabilityVisitor.CostRecordingFrame frame) { foreach (MethodInfo setter in baseMethod.GetSiblingSetters()) { frame.applyImplicitCost(setter, Reason.IMPLICIT_SETTER); } }
public void SetUp() { localField = new LocalField(instance, field); localFinalField = new LocalField(instance, finalField); localStaticFinalField = new LocalField(null, finalStaticField); method = new MethodInfo(classInfo, "method", 0, "()V", null, null, null, Visibility.NULL, cost1, null, false); visitor = new TestabilityVisitor(repo, globalVariables, null, new RegExpWhiteList()); frame = visitor.createFrame(method, 1); parentFrame = frame.getParentFrame(); }
/** * Computing the MethodCost for a MethodInfo involves tallying up: * <ul><li>The cost in any static initialization blocks of the class which holds the method.</li> * <li>The cost of constructing the object.</li> * <li>Recognizing injectability through setter methods. This in most cases improves the score * unless you have lots of code in your setter.</li> * <li>The field costs</li> * <li>Lastly the costs are added up for all of the lines in this method. This includes the * transitive non-mockable/interceptable closure of all the costs of the methods that are called.</li> * <li></li></ul> * * @param method to compute the cost for. * @return MethodCost for this method, including the accumulated costs the methods it calls. This * MethodCost is guaranteed to have already been linked (sealed for adding additional costs). */ public MethodCost compute(MethodInfo method) { var visitor = new TestabilityVisitor(classRepository, new VariableState(), err, whitelist); TestabilityVisitor.CostRecordingFrame frame = visitor.createFrame(method, recordingDepth); addStaticInitializationCost(method, frame); if (!method.IsStatic() && !method.IsConstructor()) { addConstructorCost(method, frame); addSetterInjection(method, frame); } addFieldCost(method, frame); return frame.applyMethodOperations(); }
public override void Visit(TestabilityVisitor.Frame visitor) { visitor.SetReturnValue(value); }
public override void Visit(TestabilityVisitor.Frame visitor) { visitor.assignField(fieldInstance, field, value, LineNumber); }
public override void Visit(TestabilityVisitor.Frame visistor) { visistor.assignArray(array, index, value, LineNumber); }
/** Doesn't really add the field costs (there are none), but marks non-private fields as injectable. */ private void addFieldCost(MethodInfo method, TestabilityVisitor.Frame frame) { foreach (FieldInfo field in method.ClassInfo.GetFields()) { if (!field.IsPrivate()) { frame.GetGlobalVariables().SetInjectable(field); } } }
/** Adds an implicit cost to all non-static methods for calling the constructor. (Because to test * any instance method, you must be able to instantiate the class.) Also marks parameters * injectable for the constructor with the most non-primitive parameters. */ private void addConstructorCost(MethodInfo method, TestabilityVisitor.CostRecordingFrame frame) { MethodInfo constructor = method.ClassInfo.GetConstructorWithMostNonPrimitiveParameters(); if (constructor != null) { frame.applyImplicitCost(constructor, Reason.IMPLICIT_CONSTRUCTOR); } }
/** Includes the cost of all static initialization blocks, as well as static field assignments. */ private void addStaticInitializationCost(MethodInfo baseMethod, TestabilityVisitor.CostRecordingFrame frame) { if (baseMethod.IsStaticConstructor()) { return; } foreach (var method in baseMethod.ClassInfo.GetMethods()) { //if (method.Name.StartsWith("<clinit>")) if (method.Name.StartsWith(".cctor")) { // TODO, different way to represent constructor method, by sunlw frame.applyImplicitCost(method, Reason.IMPLICIT_STATIC_INIT); } } }
public abstract void Visit(TestabilityVisitor.Frame visitor);
public override void Visit(TestabilityVisitor.Frame visitor) { visitor.assignLocal(LineNumber, variable, value); }
public override void Visit(TestabilityVisitor.Frame visitor) { visitor.recordMethodCall(clazzName, LineNumber, name + signature, methodThis, parameters, returnVariable); }