public override bool Execute(out ResultTuple ret, ResultTuple[] results, Plan.ParameterChooser[] parameterMap, TextWriter executionLog, TextWriter debugLog, out Exception exceptionThrown, out bool contractViolated, bool forbidNull) { contractViolated = false; Util.Assert(parameterMap.Length == 2); object receiver = results[parameterMap[0].planIndex].tuple[parameterMap[0].resultIndex]; object val = results[parameterMap[1].planIndex].tuple[parameterMap[1].resultIndex]; if (!this.coverageInfo.IsStatic) { Util.Assert(receiver != null); } if (forbidNull) { Util.Assert(val != null); } CodeExecutor.CodeToExecute call = delegate() { ffield.SetValue(receiver, val); }; executionLog.WriteLine("set field " + ffield.Name); executionLog.Flush(); if (!CodeExecutor.ExecuteReflectionCall(call, debugLog, out exceptionThrown)) { ret = null; return(false); } ret = new ResultTuple(ffield, receiver); return(true); }
public override bool Execute(out ResultTuple ret, ResultTuple[] results, Plan.ParameterChooser[] parameterMap, TextWriter executionLog, TextWriter debugLog, out Exception exceptionThrown, out bool contractViolated, bool forbidNull) { contractViolated = false; this.timesExecuted++; long startTime = 0; Timer.QueryPerformanceCounter(ref startTime); object[] objects = new object[fconstructor.GetParameters().Length]; // Get the actual objects from the results using parameterIndices; for (int i = 0; i < fconstructor.GetParameters().Length; i++) { Plan.ParameterChooser pair = parameterMap[i]; objects[i] = results[pair.planIndex].tuple[pair.resultIndex]; } if (forbidNull) { foreach (object o in objects) { Util.Assert(o != null); } } object newObject = null; CodeExecutor.CodeToExecute call = delegate() { newObject = fconstructor.Invoke(objects); }; executionLog.WriteLine("execute constructor " + this.fconstructor.DeclaringType); executionLog.Flush(); bool retval = true; if (!CodeExecutor.ExecuteReflectionCall(call, debugLog, out exceptionThrown)) { ret = null; if (exceptionThrown is AccessViolationException) { //Console.WriteLine("SECOND CHANCE AV!" + this.ToString()); //Logging.LogLine(Logging.GENERAL, "SECOND CHANCE AV!" + this.ToString()); } //for exns we can ony add the class to faulty classes when its a guideline violation if (Util.GuidelineViolation(exceptionThrown.GetType())) { PlanManager.numDistinctContractViolPlans++; KeyValuePair <MethodBase, Type> k = new KeyValuePair <MethodBase, Type>(this.fconstructor, exceptionThrown.GetType()); if (!exnViolatingMethods.ContainsKey(k)) { PlanManager.numContractViolatingPlans++; exnViolatingMethods[k] = true; } //add this class to the faulty classes contractExnViolatingClasses[fconstructor.GetType()] = true; contractExnViolatingMethods[fconstructor] = true; } return(false); } else { ret = new ResultTuple(fconstructor, newObject, objects); } //check if the objects in the output tuple violated basic contracts if (ret != null) { foreach (object o in ret.tuple) { if (o == null) { continue; } bool toStrViol, hashCodeViol, equalsViol; int count; if (Util.ViolatesContracts(o, out count, out toStrViol, out hashCodeViol, out equalsViol)) { contractViolated = true; contractExnViolatingMethods[fconstructor] = true; bool newcontractViolation = false; PlanManager.numDistinctContractViolPlans++; if (toStrViol) { if (!toStrViolatingMethods.ContainsKey(fconstructor)) { newcontractViolation = true; } toStrViolatingMethods[fconstructor] = true; } if (hashCodeViol) { if (!hashCodeViolatingMethods.ContainsKey(fconstructor)) { newcontractViolation = true; } hashCodeViolatingMethods[fconstructor] = true; } if (equalsViol) { if (!equalsViolatingMethods.ContainsKey(fconstructor)) { newcontractViolation = true; } equalsViolatingMethods[fconstructor] = true; } if (newcontractViolation) { PlanManager.numContractViolatingPlans++; } //add this class to the faulty classes contractExnViolatingClasses[fconstructor.DeclaringType] = true; retval = false; } } } long endTime = 0; Timer.QueryPerformanceCounter(ref endTime); executionTimeAccum += ((double)(endTime - startTime)) / ((double)(Timer.PerfTimerFrequency)); return(retval); }
public override bool Execute(out ResultTuple ret, ResultTuple[] parameters, Plan.ParameterChooser[] parameterMap, TextWriter executionLog, TextWriter debugLog, out bool preconditionViolated, out Exception exceptionThrown, out bool contractViolated, bool forbidNull, bool useRandoopContracts, out ContractState contractStates) { long startTime = 0; Timer.QueryPerformanceCounter(ref startTime); object[] objects = new object[method.GetParameters().Length]; // Get the actual objects from the results using parameterIndices; object receiver = parameters[parameterMap[0].planIndex].tuple[parameterMap[0].resultIndex]; for (int i = 0; i < method.GetParameters().Length; i++) { Plan.ParameterChooser pair = parameterMap[i + 1]; objects[i] = parameters[pair.planIndex].tuple[pair.resultIndex]; } contractStates = new ContractState(); preconditionViolated = false; if (useRandoopContracts) { try { preconditionViolated = new RandoopContractsManager().PreconditionViolated(method, objects); } catch (InvalidRandoopContractException) { } //precondition is invalid, ignore it and proceed with execution if (preconditionViolated) { ret = null; exceptionThrown = null; contractViolated = false; return(false); } } if (forbidNull) { foreach (object o in objects) { Util.Assert(o != null); } } CodeExecutor.CodeToExecute call; object returnValue = null; contractViolated = false; //default value of contract violation call = delegate() { returnValue = method.Invoke(receiver, objects); }; bool retval = true; executionLog.WriteLine("execute method " + method.Name + "[" + (timesExecuted - 1).ToString() + "]"); //[email protected] changes Logger.Debug("execute method " + method.Name //[email protected] adds + "[" + (timesExecuted - 1).ToString() + "]"); executionLog.Flush(); //if (timesExecuted != ReturnValue.Count + 1) //[email protected] adds for debug //{ // Logger.Debug("timeExecute = " + timesExecuted.ToString() + // " but ReturnValue is " + ReturnValue.Count.ToString()); //} timesExecuted++; if (!CodeExecutor.ExecuteReflectionCall(call, debugLog, out exceptionThrown)) { //for exns we can ony add the class to faulty classes when its a guideline violation if (Util.GuidelineViolation(exceptionThrown.GetType())) { PlanManager.numDistinctContractViolPlans++; KeyValuePair <MethodBase, Type> k = new KeyValuePair <MethodBase, Type>(method, exceptionThrown.GetType()); if (!exnViolatingMethods.ContainsKey(k)) { PlanManager.numContractViolatingPlans++; exnViolatingMethods[k] = true; } //add this class to the faulty classes contractExnViolatingClasses[method.DeclaringType] = true; contractExnViolatingMethods[method] = true; } ret = null; executionLog.WriteLine("return value [" + (timesExecuted - 1).ToString() + "]: invocationOk is false.");//[email protected] adds //string temp = "RANDOOPFAIL"; //[email protected] adds for capture current status ReturnValue.Add(null); //[email protected] adds for capture current status return(false); } else { ret = new ResultTuple(method, receiver, returnValue, objects); #region caputre latest execution return value ////[email protected] adds to capture return value -- start//// if (returnValue != null) { if ((returnValue.GetType() == typeof(string)) || (returnValue.GetType() == typeof(bool)) || (returnValue.GetType() == typeof(byte)) || (returnValue.GetType() == typeof(short)) || (returnValue.GetType() == typeof(int)) || (returnValue.GetType() == typeof(long)) || (returnValue.GetType() == typeof(float)) || (returnValue.GetType() == typeof(double)) || (returnValue.GetType() == typeof(char))) { executionLog.WriteLine("return value [" + (timesExecuted - 1).ToString() + "]: " + returnValue.ToString().Replace("\n", "\\n").Replace("\r", "\\r")); } else { executionLog.WriteLine("return value [" + (timesExecuted - 1).ToString() + "]: not string or primitive"); } //doulbe check to make sure there is no non-deterministic exeuction -- we don't want to regression assertion with that //This is not a sufficient approach because the difference may be inherited from previous constructors or method calls //What was done in Randoop(java): after generating an "entire" test suite, Randoop runs it before outputting it. //If any test fails, Randoop disables each failing assertions. //let the VS plug-in do this functionality if (Execute2(returnValue, objects, receiver, executionLog, debugLog)) { ReturnValue.Add(returnValue); } else { ReturnValue.Add(null); } } else { executionLog.WriteLine("return value [" + (timesExecuted - 1).ToString() + "]: no return value"); ReturnValue.Add(null); } ////[email protected] adds to capture return value -- end//// #endregion caputre latest execution return value } //check if the objects in the output tuple violated basic contracts if (ret != null) { CheckContracts(ret, ref contractViolated, ref retval); contractStates = new RandoopContractsManager().ValidateAssertionContracts(method, receiver, returnValue); } if (contractViolated) //[email protected] adds { executionLog.WriteLine("contract violation."); //[email protected] adds } long endTime = 0; Timer.QueryPerformanceCounter(ref endTime); executionTimeAccum += endTime - startTime / (double)Timer.PerfTimerFrequency; return(retval); }
public bool Execute2(object retValOldRun, object[] objectsOld, object receiverOld, TextWriter executionLog, TextWriter debugLog) { //object[] objects = new object[method.GetParameters().Length]; //// Get the actual objects from the results using parameterIndices; //object receiver = parameters[parameterMap[0].planIndex].tuple[parameterMap[0].resultIndex]; //for (int i = 0; i < method.GetParameters().Length; i++) //{ // Plan.ParameterChooser pair = parameterMap[i + 1]; // objects[i] = parameters[pair.planIndex].tuple[pair.resultIndex]; //} //if (forbidNull) // foreach (object o in objects) // Util.Assert(o != null); object[] objects = objectsOld; object receiver = receiverOld; ResultTuple ret; Exception exceptionThrown = new Exception(); CodeExecutor.CodeToExecute call; object returnValue = null; call = delegate() { returnValue = method.Invoke(receiver, objects); }; //bool retval = true; executionLog.WriteLine("execute method " + method.Name + "[" + (timesExecuted - 1).ToString() + "] the second time"); Logger.Debug("execute method " + method.Name + "[" + (timesExecuted - 1).ToString() + "] the second time"); executionLog.Flush(); if (!CodeExecutor.ExecuteReflectionCall(call, debugLog, out exceptionThrown)) { //for exns we can ony add the class to faulty classes when its a guideline violation //if (Util.GuidelineViolation(exceptionThrown.GetType())) //{ // PlanManager.numDistinctContractViolPlans++; // KeyValuePair<MethodBase, Type> k = new KeyValuePair<MethodBase, Type>(method, exceptionThrown.GetType()); // if (!exnViolatingMethods.ContainsKey(k)) // { // PlanManager.numContractViolatingPlans++; // exnViolatingMethods[k] = true; // } // //add this class to the faulty classes // contractExnViolatingClasses[method.DeclaringType] = true; // contractExnViolatingMethods[method] = true; //} ret = null; executionLog.WriteLine("return value [" + (timesExecuted - 1).ToString() + "]: invocationOk is false the sceond time --- shouldn't happen?"); //ReturnValue.Add(null); return(false); } else { ret = new ResultTuple(method, receiver, returnValue, objects); ////[email protected] adds to capture return value -- start//// if (returnValue != null) { if ((returnValue.GetType() == typeof(System.String)) || (returnValue.GetType() == typeof(System.Boolean)) || (returnValue.GetType() == typeof(byte)) || (returnValue.GetType() == typeof(short)) || (returnValue.GetType() == typeof(int)) || (returnValue.GetType() == typeof(long)) || (returnValue.GetType() == typeof(float)) || (returnValue.GetType() == typeof(double)) || (returnValue.GetType() == typeof(char))) { executionLog.WriteLine("return value [" + (timesExecuted - 1).ToString() + "] the second time: " + returnValue.ToString().Replace("\n", "\\n").Replace("\r", "\\r")); } else { executionLog.WriteLine("return value [" + (timesExecuted - 1).ToString() + "] the second time: not primitive or string"); } //ReturnValue.Add(returnValue); Type typeOfReturnVal = returnValue.GetType(); if (typeOfReturnVal == typeof(bool) || typeOfReturnVal == typeof(byte) || typeOfReturnVal == typeof(short) || typeOfReturnVal == typeof(int) || typeOfReturnVal == typeof(long) || typeOfReturnVal == typeof(float) || typeOfReturnVal == typeof(double) || typeOfReturnVal == typeof(char) || typeOfReturnVal == typeof(string)) { if (returnValue.Equals(retValOldRun)) { return(true); } else { return(false); } } return(true); //other types just assert NOTNULL -- should be ok } else { executionLog.WriteLine("return value [" + (timesExecuted - 1).ToString() + "]: no return value the second time -- shouldn't happen?"); //ReturnValue.Add(null); return(false); } ////[email protected] adds to capture return value -- end//// } //check if the objects in the output tuple violated basic contracts //if (ret != null) //{ // foreach (object o in ret.tuple) // { // if (o == null) continue; // bool toStrViol, hashCodeViol, equalsViol; // int count; // if (Util.ViolatesContracts(o, out count, out toStrViol, out hashCodeViol, out equalsViol)) // { // contractViolated = true; // contractExnViolatingMethods[method] = true; // PlanManager.numDistinctContractViolPlans++; // bool newcontractViolation = false; // if (toStrViol) // { // if (!toStrViolatingMethods.ContainsKey(method)) // newcontractViolation = true; // toStrViolatingMethods[method] = true; // } // if (hashCodeViol) // { // if (!hashCodeViolatingMethods.ContainsKey(method)) // newcontractViolation = true; // hashCodeViolatingMethods[method] = true; // } // if (equalsViol) // { // if (!equalsViolatingMethods.ContainsKey(method)) // newcontractViolation = true; // equalsViolatingMethods[method] = true; // } // if (newcontractViolation) // PlanManager.numContractViolatingPlans++; // //add this class to the faulty classes // contractExnViolatingClasses[method.DeclaringType] = true; // retval = false; // } // } //} //if (contractViolated) // executionLog.WriteLine("contract violation."); //return retval; }
public override bool Execute(out ResultTuple ret, ResultTuple[] parameters, Plan.ParameterChooser[] parameterMap, TextWriter executionLog, TextWriter debugLog, out Exception exceptionThrown, out bool contractViolated, bool forbidNull) { this.timesExecuted++; long startTime = 0; Timer.QueryPerformanceCounter(ref startTime); object[] objects = new object[method.GetParameters().Length]; // Get the actual objects from the results using parameterIndices; object receiver = parameters[parameterMap[0].planIndex].tuple[parameterMap[0].resultIndex]; for (int i = 0; i < method.GetParameters().Length; i++) { Plan.ParameterChooser pair = parameterMap[i + 1]; objects[i] = parameters[pair.planIndex].tuple[pair.resultIndex]; } // FIXME This should be true! It currently isn't. //if (!this.coverageInfo.methodInfo.IsStatic) // Util.Assert(receiver != null); if (forbidNull) { foreach (object o in objects) { Util.Assert(o != null); } } CodeExecutor.CodeToExecute call; object returnValue = null; contractViolated = false; //default value of contract violation call = delegate() { returnValue = method.Invoke(receiver, objects); }; bool retval = true; executionLog.WriteLine("execute method " + this.method.Name); executionLog.Flush(); if (!CodeExecutor.ExecuteReflectionCall(call, debugLog, out exceptionThrown)) { //for exns we can ony add the class to faulty classes when its a guideline violation if (Util.GuidelineViolation(exceptionThrown.GetType())) { PlanManager.numDistinctContractViolPlans++; KeyValuePair <MethodBase, Type> k = new KeyValuePair <MethodBase, Type>(this.method, exceptionThrown.GetType()); if (!exnViolatingMethods.ContainsKey(k)) { PlanManager.numContractViolatingPlans++; exnViolatingMethods[k] = true; } //add this class to the faulty classes contractExnViolatingClasses[method.DeclaringType] = true; contractExnViolatingMethods[method] = true; } ret = null; return(false); } else { ret = new ResultTuple(method, receiver, returnValue, objects); } //check if the objects in the output tuple violated basic contracts if (ret != null) { foreach (object o in ret.tuple) { if (o == null) { continue; } bool toStrViol, hashCodeViol, equalsViol; int count; if (Util.ViolatesContracts(o, out count, out toStrViol, out hashCodeViol, out equalsViol)) { contractViolated = true; contractExnViolatingMethods[method] = true; PlanManager.numDistinctContractViolPlans++; bool newcontractViolation = false; if (toStrViol) { if (!toStrViolatingMethods.ContainsKey(method)) { newcontractViolation = true; } toStrViolatingMethods[method] = true; } if (hashCodeViol) { if (!hashCodeViolatingMethods.ContainsKey(method)) { newcontractViolation = true; } hashCodeViolatingMethods[method] = true; } if (equalsViol) { if (!equalsViolatingMethods.ContainsKey(method)) { newcontractViolation = true; } equalsViolatingMethods[method] = true; } if (newcontractViolation) { PlanManager.numContractViolatingPlans++; } //add this class to the faulty classes contractExnViolatingClasses[method.DeclaringType] = true; retval = false; } } } long endTime = 0; Timer.QueryPerformanceCounter(ref endTime); executionTimeAccum += ((double)(endTime - startTime)) / ((double)(Timer.PerfTimerFrequency)); return(retval); }