//Initialise various methods and arrays void Start() { fitnessMeasure = LearningModeScript.fitnessMeasure; Population = LearningModeScript.Population; Probability = LearningModeScript.Probability; nextChild.onClick.AddListener(NextChild); Rigidbody = GetComponent <Rigidbody>(); controller = new CarController(); saveLoad = new GeneticWeights(); Rigidbody.GetComponent <CarPhysics>().driver = Driver.AI; Fitness = new double[Population]; Outputs = new List <double>(); Position = transform.position; //Create cars of size population Cars = new GeneticNetwork[Population]; //Initiate list of weights of size pupulation for (int i = 0; i < Population; i++) { Cars[i] = new GeneticNetwork(); } }
/// <summary> /// Gets called when an un-explored branch is encountered during program execution /// </summary> /// <param name="executionNode"></param> /// <param name="explorableType"></param> public void HandleTargetBranch(CodeLocation location, Term condition, TermManager termManager, TypeEx explorableType) { var accessedFields = new SafeList <Field>(); if (PexMeConstants.IGNORE_UNCOV_BRANCH_IN_SYSTEM_LIB) { if (IsUncoveredLocationInSystemLib(location)) { this.host.Log.LogWarning(WikiTopics.MissingWikiTopic, "uncoveredlocation", "Ignoring the uncovered location " + location.ToString() + ", since it is in system library"); return; } } Term unnegatedCondition; bool bNegated = false; if (termManager.TryGetInnerLogicallyNegatedValue(condition, out unnegatedCondition)) { bNegated = true; } else { unnegatedCondition = condition; } var culpritFields = new SafeList <Field>(); Term left, right; BinaryOperator binOp; SafeStringBuilder sbTerm = new SafeStringBuilder(); this.ConvertTermToText(new SafeStringWriter(sbTerm), condition, termManager); //Handling only binary conditions. TODO: Needs to check what are the other conditions //The related code is in TermSolver function if (!termManager.TryGetBinary(unnegatedCondition, out binOp, out left, out right)) { this.host.Log.LogWarning(WikiTopics.MissingWikiTopic, PexMeLogCategories.Term, "Handling only binary operations in terms"); return; } if (PexMeConstants.USE_TERM_SOLVER) { //TODO: Temporarily ignoring the scenario where both the sides are symbolic values if (!termManager.IsValue(left) && !termManager.IsValue(right)) { this.host.Log.LogWarning(WikiTopics.MissingWikiTopic, PexMeLogCategories.Term, "Handling only binary operations where atleast one side of the condition is concrete. Current expression has both sides symbolic"); return; } SafeDictionary <Field, FieldValueHolder> expectedFieldValues; SafeDictionary <Field, FieldValueHolder> actualFieldValues; SafeList <Field> allFieldsInCondition; SafeList <TypeEx> allFieldTypes; TermSolver.SolveTerm(this.explorationComponent, condition, binOp, out actualFieldValues, out expectedFieldValues, out allFieldsInCondition, out allFieldTypes); //Compute an intersection to identify culprit fields List <Field> actualKeys = actualFieldValues.Keys.ToList(); List <Field> expectedKeys = expectedFieldValues.Keys.ToList(); AddToCulpritField(allFieldsInCondition, culpritFields); if (culpritFields.Count == 0) { this.host.Log.LogWarning(WikiTopics.MissingWikiTopic, PexMeLogCategories.Term, "Failed to retrieve culprit fields from the uncovered branch"); } else { foreach (Field field in culpritFields) { FieldModificationType fieldfmt; int fitnessval; FitnessMeasure.ComputeFitnessValue(field, actualFieldValues[field], expectedFieldValues[field], this.host, out fieldfmt, out fitnessval); if (fieldfmt == FieldModificationType.UNKNOWN) { continue; } this.pmd.AddFieldsOfUncoveredCodeLocations(location, allFieldsInCondition, fieldfmt, condition, sbTerm.ToString(), fitnessval, explorableType, allFieldTypes); } } } else { FieldModificationType fmt; if (!termManager.IsValue(left) && !termManager.IsValue(right)) { SafeDictionary <Field, FieldValueHolder> leftFieldValues; SafeList <TypeEx> leftFieldTypes; var leftAccessedFields = GetInvolvedFields(this.host, termManager, left, out leftFieldValues, out leftFieldTypes); if (leftAccessedFields.Count > 0) { AddToCulpritField(leftAccessedFields, culpritFields); } SafeDictionary <Field, FieldValueHolder> rightFieldValues; SafeList <TypeEx> rightFieldTypes; var rightAccessedFields = GetInvolvedFields(this.host, termManager, right, out rightFieldValues, out rightFieldTypes); if (rightAccessedFields.Count > 0) { AddToCulpritField(rightAccessedFields, culpritFields); } int fitnessval; this.handleNoConstantsInTerm(termManager, left, right, binOp, bNegated, culpritFields, unnegatedCondition, out fmt, out fitnessval); //TODO: fitnessval can be different from left and right handside terms. Needs to deal with this later this.pmd.AddFieldsOfUncoveredCodeLocations(location, leftAccessedFields, fmt, condition, sbTerm.ToString(), fitnessval, explorableType, leftFieldTypes); this.pmd.AddFieldsOfUncoveredCodeLocations(location, rightAccessedFields, fmt, condition, sbTerm.ToString(), fitnessval, explorableType, rightFieldTypes); } else { Term non_constant_term = null; if (termManager.IsValue(left)) { non_constant_term = right; } else if (termManager.IsValue(right)) { non_constant_term = left; } else { SafeDebug.AssumeNotNull(null, "Control should not come here!!!"); } //Get accessed fields in the uncovered branching condition SafeDictionary <Field, FieldValueHolder> fieldValues; SafeList <TypeEx> fieldTypes; accessedFields = GetInvolvedFields(this.host, termManager, non_constant_term, out fieldValues, out fieldTypes); if (accessedFields.Count != 0) { AddToCulpritField(accessedFields, culpritFields); } if (culpritFields.Count == 0) { this.host.Log.LogWarning(WikiTopics.MissingWikiTopic, PexMeLogCategories.Term, "Failed to retrieve culprit fields from the uncovered branch"); } else { int fitnessval; this.handleAConstantInTerm(termManager, left, right, binOp, bNegated, fieldValues, culpritFields[0], out fmt, out fitnessval); this.pmd.AddFieldsOfUncoveredCodeLocations(location, accessedFields, fmt, condition, sbTerm.ToString(), fitnessval, explorableType, fieldTypes); } } } }
/// <summary> /// OBSOLETE: Handles a scenario where there is a term in the condition /// </summary> /// <param name="left"></param> /// <param name="right"></param> /// <param name="binOp"></param> /// <param name="fmt"></param> private void handleAConstantInTerm(TermManager termManager, Term left, Term right, BinaryOperator binOp, bool bNegated, SafeDictionary <Field, FieldValueHolder> fieldValues, Field culpritField, out FieldModificationType fmt, out int fitnessval) { fitnessval = Int32.MaxValue; fmt = FieldModificationType.UNKNOWN; Term non_constant_term = null; Term constant_term = null; bool bleftRightMaintainted = true; if (termManager.IsValue(left)) { non_constant_term = right; constant_term = left; bleftRightMaintainted = true; } else if (termManager.IsValue(right)) { non_constant_term = left; constant_term = right; bleftRightMaintainted = false; } int value; if (termManager.TryGetI4Constant(constant_term, out value)) { fmt = FieldModificationType.INCREMENT; FieldValueHolder fvh; if (fieldValues.TryGetValue(culpritField, out fvh)) { int non_constant_field_value = fvh.intValue; //TODO: Assuming that the fieldType is Int32 if (bleftRightMaintainted) { fitnessval = FitnessMeasure.ComputeFitnessValue(this.host, binOp, value, non_constant_field_value, bNegated); } else { fitnessval = FitnessMeasure.ComputeFitnessValue(this.host, binOp, non_constant_field_value, value, bNegated); } } else { this.host.Log.LogWarning(WikiTopics.MissingWikiTopic, "fitness measure", "Failed to retrieve value for field " + culpritField.ToString()); } } else if (termManager.IsDefaultValue(constant_term)) { if (binOp == BinaryOperator.Ceq) { if (culpritField.Type.ToString() == "System.Boolean") { fmt = bNegated ? FieldModificationType.TRUE_SET : FieldModificationType.FALSE_SET; } else { fmt = bNegated ? FieldModificationType.NON_NULL_SET : FieldModificationType.NULL_SET; } } } Term objectValue; ObjectProperty objectProperty; if (termManager.TryGetObjectProperty(constant_term, out objectValue, out objectProperty)) { //TODO??? How to handle this scenario? } }
//When dropdown value is changed, also change the fitnessMeasure static var void DropdownValueChanged(Dropdown change) { fitnessMeasure = (FitnessMeasure)change.value; }