示例#1
0
        public void Dump()
        {
            var termManager = this.ExplorationServices.TermManager;

            SafeStringBuilder sb = new SafeStringBuilder();

            foreach (var kvp in this.FieldAccessInfoObj.Results)
            {
                var method        = kvp.Key;
                var methodResults = kvp.Value;
                sb.AppendLine();
                sb.AppendLine("method:" + method /*.FullName*/);
                foreach (var kvp2 in methodResults)
                {
                    var field        = kvp2.Key;
                    var fieldResults = kvp2.Value;
                    sb.AppendLine("  modifies field:" + field /*.FullName*/);
                    sb.AppendLine("    with new values:");
                    foreach (var newFieldValueTerm in fieldResults)
                    {
                        var swriter = new TermSExpWriter(termManager, new SafeStringWriter(sb), true, false);
                        swriter.Write(newFieldValueTerm);
                        sb.AppendLine();
                    }
                }
            }

            this.Log.Dump("fields", "field changes", sb.ToString());
            //database.DumpFieldAccessInfoIntoToFile();
        }
示例#2
0
        internal void AddResult(Method method, Field f, Term[] indices, Term fieldValue)
        {
            /* SafeDictionary<Field, SafeSet<Term>> methodResults;
             * if (!this.FieldAccessInfoContainer.Results.TryGetValue(method, out methodResults))
             *  this.FieldAccessInfoContainer.Results[method] = methodResults = new SafeDictionary<Field, SafeSet<Term>>();
             * SafeSet<Term> fieldResults;
             * if (!methodResults.TryGetValue(f, out fieldResults))
             *  methodResults[f] = fieldResults = new SafeSet<Term>();
             */
            //TODO why do we need it?

            /*
             * if (database == null)
             * {
             *  database = new SeqexDatabase();
             *  FieldAccessInfoObj = database.FieldAccessInfoObj;
             * }
             */
            string arrayIndex = "";

            using (SomeRewriter someRewriter = new SomeRewriter(this.termManager))
            {
                fieldValue = someRewriter.VisitTerm(default(TVoid), fieldValue);
                //update the field value to accomodate array-type field
                //if (indices.Length == 0)//not an array-type field
                if (indices.Length == 1) //is an array-type field
                {
                    arrayIndex = " at index of " + indices[0].UniqueIndex.ToString();
                }
            }

            System.Collections.Generic.Dictionary <string, HashSet <string> > methodResults;
            if (!this.FieldAccessInfoObj.Results.TryGetValue(method.FullName, out methodResults))
            {
                this.FieldAccessInfoObj.Results[method.FullName] =
                    methodResults = new System.Collections.Generic.Dictionary <string, HashSet <string> >();
            }
            HashSet <string> fieldResults;

            if (!methodResults.TryGetValue(f.FullName, out fieldResults))
            {
                methodResults[f.FullName] = fieldResults = new HashSet <string>();
            }

            var sb      = new SafeStringBuilder();
            var swriter = new TermSExpWriter(this.ExplorationServices.TermManager, new SafeStringWriter(sb), true, false);

            swriter.Write(fieldValue);
            sb.Append(arrayIndex);

            int value;

            if (termManager.TryGetI4Constant(fieldValue, out value))
            {
                sb.Append("  constant value: " + value);
            }
            else if (termManager.IsDefaultValue(fieldValue))
            {
                sb.Append("  null reference");
            }
            else
            {
                sb.Append("  not-null reference");
            }

            fieldResults.Add(sb.ToString());
        }
示例#3
0
        private void GatherDebuggingInfoFromInsufficiency(IExecutionNode executionNode, TermManager termManager,
                                                          Term condition, TypeEx explorableType)
        {
            var sb = new SafeStringBuilder();

            sb.AppendLine("condition:");
            sb.AppendLine();
            this.tba.ConvertTermToText(new SafeStringWriter(sb), condition, this.ExplorationServices.TermManager);
            sb.AppendLine();
            var swriter = new TermSExpWriter(termManager, new SafeStringWriter(sb), true, false);

            swriter.Write(condition);
            sb.AppendLine();
            sb.AppendLine("location:");
            sb.AppendLine();
            sb.AppendLine(executionNode.CodeLocation.ToString());
            sb.AppendLine();
            sb.AppendLine("properties:");

            Term unnegatedCondition;

            if (termManager.TryGetInnerLogicallyNegatedValue(condition, out unnegatedCondition))
            {
                sb.AppendLine("negated");
            }
            else
            {
                unnegatedCondition = condition;
            }

            var            targetFieldValues = new SafeDictionary <Field, object>();
            Term           left, right;
            BinaryOperator binOp;

            if (termManager.TryGetBinary(unnegatedCondition, out binOp, out left, out right))
            {
                sb.AppendFormat("binary relation: {0}", binOp);
                sb.AppendLine();

                if (!termManager.IsValue(left) && !termManager.IsValue(right))
                {
                    sb.AppendLine("No constant on either left side or right side.");
                    return;
                }

                Term non_constant_term = null;
                Term constant_term     = null;
                if (termManager.IsValue(left))
                {
                    non_constant_term = right;
                    constant_term     = left;
                }
                else if (termManager.IsValue(right))
                {
                    non_constant_term = left;
                    constant_term     = right;
                }

                sb.AppendLine("against constant");
                if (constant_term == null || termManager.IsDefaultValue(constant_term))
                {
                    sb.AppendLine("against default value ('null' for references)");
                }

                int value;
                if (constant_term != null && termManager.TryGetI4Constant(constant_term, out value))
                {
                    sb.AppendLine("against integer: " + value);
                }

                Term           objectValue;
                ObjectProperty objectProperty;
                if (constant_term != null && termManager.TryGetObjectProperty(constant_term, out objectValue, out objectProperty))
                {
                    sb.AppendLine("against object property: object=" + objectValue + ", property=" + objectProperty);
                }

                sb.AppendLine(" involving fields: ");
                SafeDictionary <Field, FieldValueHolder> innerFieldValues;
                SafeList <TypeEx> innerFieldTypes;
                SafeList <Field>  fs = TargetBranchAnalyzer.GetInvolvedFields(this, termManager,
                                                                              non_constant_term, out innerFieldValues, out innerFieldTypes);
                foreach (var f in fs)
                {
                    sb.AppendLine(f.FullName);
                }
            }

            sb.AppendLine("Executed method call sequence");
            if (this.pmd.LastExecutedFactoryMethodCallSequence != null)
            {
                foreach (var m in this.pmd.LastExecutedFactoryMethodCallSequence)
                {
                    sb.AppendLine("\t" + m);
                }
            }

            this.Log.Dump("foo", "insufficiency for " + (explorableType != null ? explorableType.FullName : "?"), sb.ToString());
            return;
        }
示例#4
0
        /// <summary>
        /// Adds a monitored field to the database. Updates two kinds of hashmaps
        /// a. Field to Method mapper, which gives what the methods modifying a given field
        /// b. Method to Field mapper, which gives what fields are modified by each method (later used to identify a minimized set of methods)
        /// </summary>
        /// <param name="tm"></param>
        /// <param name="method"></param>
        /// <param name="f"></param>
        /// <param name="indices"></param>
        /// <param name="fieldValue"></param>
        public void AddMonitoredField(TermManager tm, Method method, Field f, Term[] indices, Term fieldValue, Term initialValue)
        {
            string arrayIndex = "";

            using (PexMeTermRewriter pexmeRewriter = new PexMeTermRewriter(tm))
            {
                fieldValue = pexmeRewriter.VisitTerm(default(TVoid), fieldValue); //update the field value to accomodate array-type field
                //if (indices.Length == 0) //not an array-type field
                if (indices.Length == 1)                                          //is an array-type field
                {
                    arrayIndex = " at index of " + indices[0].UniqueIndex.ToString();
                }

                if (initialValue != null)
                {
                    initialValue = pexmeRewriter.VisitTerm(default(TVoid), initialValue);
                }
            }

            //Updating the method store
            MethodStore ms;

            if (!methodDic.TryGetValue(method, out ms))
            {
                ms                = new MethodStore();
                ms.methodName     = method;
                methodDic[method] = ms;
            }

            ms.WriteFields.Add(f);
            //TODO: Gather information of read fields

            //Updating the field store
            FieldStore fs;

            if (!fieldDic.TryGetValue(f, out fs))
            {
                fs           = new FieldStore();
                fs.FieldName = f;
                fieldDic[f]  = fs;
            }

            TypeEx declaringType;

            if (!method.TryGetDeclaringType(out declaringType))
            {
                this.Log.LogError(WikiTopics.MissingWikiTopic, "monitorfield",
                                  "Failed to get the declaring type for the method " + method.FullName);
                return;
            }

            SafeSet <Method> writeMethods;

            if (!fs.WriteMethods.TryGetValue(declaringType, out writeMethods))
            {
                writeMethods = new SafeSet <Method>();
                fs.WriteMethods[declaringType] = writeMethods;
            }
            writeMethods.Add(method);

            var sb      = new SafeStringBuilder();
            var swriter = new TermSExpWriter(tm, new SafeStringWriter(sb), true, false);

            swriter.Write(fieldValue);
            sb.Append(arrayIndex);

            int value;

            if (tm.TryGetI4Constant(fieldValue, out value))
            {
                int initialval;
                if (initialValue != null)
                {
                    tm.TryGetI4Constant(initialValue, out initialval);
                }
                else
                {
                    initialval = 0;
                }

                sb.Append("  constant value: " + value);

                if (f.Type.ToString() != "System.Boolean")
                {
                    if (value < initialval)
                    {
                        fs.ModificationTypeDictionary[method] = FieldModificationType.DECREMENT;
                    }
                    else if (value > initialval)
                    {
                        fs.ModificationTypeDictionary[method] = FieldModificationType.INCREMENT;

                        if (value == initialval + 1)
                        {
                            fs.PreciseModificationTypeDictionary[method] = FieldModificationType.INCREMENT_ONE;
                        }
                    }
                    else
                    {
                        fs.ModificationTypeDictionary[method] = FieldModificationType.UNKNOWN;
                    }
                }
                else
                {
                    if (value == 0)
                    {
                        fs.ModificationTypeDictionary[method] = FieldModificationType.FALSE_SET;
                    }
                    else
                    {
                        fs.ModificationTypeDictionary[method] = FieldModificationType.TRUE_SET;
                    }
                }
            }
            else if (tm.IsDefaultValue(fieldValue))
            {
                if (initialValue != null && !tm.IsDefaultValue(initialValue))
                {
                    fs.ModificationTypeDictionary[method] = FieldModificationType.NULL_SET;
                }
                else
                {
                    fs.ModificationTypeDictionary[method] = FieldModificationType.UNKNOWN;
                }

                sb.Append("  null reference ");
            }
            else
            {
                if (initialValue == null)
                {
                    fs.ModificationTypeDictionary[method] = FieldModificationType.NON_NULL_SET;
                }
                else
                {
                    fs.ModificationTypeDictionary[method] = FieldModificationType.UNKNOWN;
                }

                sb.Append("  not-null reference ");
            }

            fs.FieldValues.Add(sb.ToString());
        }
        /// <summary>
        /// Adds a monitored field to the database. Updates two kinds of hashmaps
        /// a. Field to Method mapper, which gives what the methods modifying a given field
        /// b. Method to Field mapper, which gives what fields are modified by each method (later used to identify a minimized set of methods)
        /// </summary>
        /// <param name="tm"></param>
        /// <param name="method"></param>
        /// <param name="f"></param>
        /// <param name="indices"></param>
        /// <param name="fieldValue"></param>
        public void AddMonitoredField(TermManager tm, Method method, Field f, Term[] indices, Term fieldValue, Term initialValue)
        {
            string arrayIndex = "";
            using (PexMeTermRewriter pexmeRewriter = new PexMeTermRewriter(tm))
            {
                fieldValue = pexmeRewriter.VisitTerm(default(TVoid), fieldValue); //update the field value to accomodate array-type field
                //if (indices.Length == 0) //not an array-type field
                if (indices.Length == 1) //is an array-type field
                {
                    arrayIndex = " at index of " + indices[0].UniqueIndex.ToString();
                }

                if(initialValue != null)
                    initialValue = pexmeRewriter.VisitTerm(default(TVoid), initialValue);
            }

            //Updating the method store
            MethodStore ms;
            if(!methodDic.TryGetValue(method, out ms))
            {
                ms = new MethodStore();
                ms.methodName = method;
                methodDic[method] = ms;
            }

            ms.WriteFields.Add(f);
            //TODO: Gather information of read fields

            //Updating the field store
            FieldStore fs;
            if (!fieldDic.TryGetValue(f, out fs))
            {
                fs = new FieldStore();
                fs.FieldName = f;
                fieldDic[f] = fs;
            }

            TypeEx declaringType;
            if (!method.TryGetDeclaringType(out declaringType))
            {
                this.Log.LogError(WikiTopics.MissingWikiTopic, "monitorfield",
                    "Failed to get the declaring type for the method " + method.FullName);
                return;
            }

            SafeSet<Method> writeMethods;
            if (!fs.WriteMethods.TryGetValue(declaringType, out writeMethods))
            {
                writeMethods = new SafeSet<Method>();
                fs.WriteMethods[declaringType] = writeMethods;
            }
            writeMethods.Add(method);

            var sb = new SafeStringBuilder();
            var swriter = new TermSExpWriter(tm, new SafeStringWriter(sb), true, false);
            swriter.Write(fieldValue);
            sb.Append(arrayIndex);

            int value;
            if (tm.TryGetI4Constant(fieldValue, out value))
            {
                int initialval;
                if (initialValue != null)
                    tm.TryGetI4Constant(initialValue, out initialval);
                else
                    initialval = 0;

                sb.Append("  constant value: " + value);

                if (f.Type.ToString() != "System.Boolean")
                {
                    if (value < initialval)
                        fs.ModificationTypeDictionary[method] = FieldModificationType.DECREMENT;
                    else if (value > initialval)
                    {
                        fs.ModificationTypeDictionary[method] = FieldModificationType.INCREMENT;

                        if (value == initialval + 1)
                            fs.PreciseModificationTypeDictionary[method] = FieldModificationType.INCREMENT_ONE;
                    }
                    else
                        fs.ModificationTypeDictionary[method] = FieldModificationType.UNKNOWN;
                }
                else
                {
                    if (value == 0)
                        fs.ModificationTypeDictionary[method] = FieldModificationType.FALSE_SET;
                    else
                        fs.ModificationTypeDictionary[method] = FieldModificationType.TRUE_SET;
                }
            }
            else if (tm.IsDefaultValue(fieldValue))
            {
                if (initialValue != null && !tm.IsDefaultValue(initialValue))
                    fs.ModificationTypeDictionary[method] = FieldModificationType.NULL_SET;
                else
                    fs.ModificationTypeDictionary[method] = FieldModificationType.UNKNOWN;

                sb.Append("  null reference ");
            }
            else
            {
                if (initialValue == null)
                    fs.ModificationTypeDictionary[method] = FieldModificationType.NON_NULL_SET;
                else
                    fs.ModificationTypeDictionary[method] = FieldModificationType.UNKNOWN;

                sb.Append("  not-null reference ");
            }

            fs.FieldValues.Add(sb.ToString());
        }
        public void LogExplorableInsufficiency(IExecutionNode executionNode, TypeEx explorableType)
        {
            var termManager    = this.ExplorationServices.TermManager;
            var accessedFields = new SafeSet <Field>();

            var condition        = executionNode.SuccessorLabelToExplore;
            SafeStringBuilder sb = new SafeStringBuilder();

            sb.AppendLine("condition:");
            sb.AppendLine();
            dumpHelper(new SafeStringWriter(sb), condition);
            sb.AppendLine();
            var swriter = new TermSExpWriter(termManager, new SafeStringWriter(sb), true, false);

            swriter.Write(condition);
            sb.AppendLine();
            sb.AppendLine("location:");
            sb.AppendLine();
            sb.AppendLine(executionNode.CodeLocation.ToString());
            sb.AppendLine();
            sb.AppendLine("properties:");
            Term unnegatedCondition;

            if (termManager.TryGetInnerLogicallyNegatedValue(condition, out unnegatedCondition))
            {
                sb.AppendLine("negated");
            }
            else
            {
                unnegatedCondition = condition;
            }
            Term           left, right;
            BinaryOperator binOp;

            if (termManager.TryGetBinary(unnegatedCondition, out binOp, out left, out right))
            {
                sb.AppendFormat("binary relation: {0}", binOp);
                sb.AppendLine();
                // binOp==BinaryOperator.Ceq  tests for equality
                bool isLeftValue = termManager.IsValue(left);

                if (termManager.IsValue(left) || termManager.IsValue(right))
                {
                    sb.AppendLine("against constant");
                    if (termManager.IsDefaultValue(left) || termManager.IsDefaultValue(right))
                    {
                        sb.AppendLine("against default value ('null' for references)");
                    }
                    int value;
                    if (termManager.TryGetI4Constant(left, out value) || termManager.TryGetI4Constant(right, out value))
                    {
                        sb.AppendLine("against integer: " + value);
                    }
                    Term           objectValue;
                    ObjectProperty objectProperty;
                    if (termManager.TryGetObjectProperty(left, out objectValue, out objectProperty) ||
                        termManager.TryGetObjectProperty(right, out objectValue, out objectProperty))
                    {
                        sb.AppendLine("against object property: object=" + objectValue + ", property=" + objectProperty);
                    }
                    //the following determins what fields are involved on the other side of the constraint
                    Term t;
                    if (isLeftValue)
                    {
                        t = right;
                    }
                    else
                    {
                        t = left;
                    }
                    sb.AppendLine(" involving fields: ");
                    SafeSet <Field> fs = this.GetInvolvedFields(termManager, t);
                    foreach (var f in fs)
                    {
                        sb.AppendLine("f.FullName:" + f.FullName);
                        sb.AppendLine("f.Definition.FullName" + f.Definition.FullName);
                        sb.AppendLine("f.InstanceFieldMapType:" + f.InstanceFieldMapType.FullName);
                        TypeEx type;
//                        type.
                        f.TryGetDeclaringType(out type);
                        sb.AppendLine("f.TryGetDeclaringType: " + type.FullName);
                    }
                }
            }

            sb.AppendLine();
            sb.AppendLine("fields:");
            sb.AppendLine();

            SafeSet <Field> fields = this.GetInvolvedFields(termManager, condition);

            foreach (var f in fields)
            {
                sb.AppendLine(f.FullName);
                accessedFields.Add(f);
            }

            this.Log.Dump("foo", "insufficiency for " + (explorableType != null ? explorableType.FullName : "?"),
                          sb.ToString());
            StringBuilder simpleLog = this.GetService <ProblemTrackDatabase>().SimpleLog;

            simpleLog.AppendLine("insufficiency for " + (explorableType != null ? explorableType.FullName : "?") + sb);
            //this.unsuccessfullyFlippedCodeLocations.Add(executionNode.CodeLocation);

            SafeSet <Field> existingAssessedFields;

            if (
                !this.database.FieldsForUnsuccessfullyFlippedCodeLocations.TryGetValue(executionNode.CodeLocation,
                                                                                       out existingAssessedFields))
            {
                database.FieldsForUnsuccessfullyFlippedCodeLocations.Add(executionNode.CodeLocation, accessedFields);
            }
            else
            {
                existingAssessedFields.AddRange(accessedFields);
            }

            SafeStringBuilder sbTerm = new SafeStringBuilder();

            dumpHelper(new SafeStringWriter(sbTerm), condition);

            SafeSet <string> terms;

            if (
                !this.database.TermsForUnsuccessfullyFlippedCodeLocations.TryGetValue(
                    executionNode.CodeLocation.ToString(), out terms))
            {
                terms = new SafeSet <string>();
                terms.Add(sbTerm.ToString());
                database.TermsForUnsuccessfullyFlippedCodeLocations.Add(executionNode.CodeLocation.ToString(), terms);
            }
            else
            {
                terms.Add(sbTerm.ToString());
            }
        }
        private void GatherDebuggingInfoFromInsufficiency(IExecutionNode executionNode, TermManager termManager, 
            Term condition, TypeEx explorableType)
        {
            var sb = new SafeStringBuilder();
            sb.AppendLine("condition:");
            sb.AppendLine();
            this.tba.ConvertTermToText(new SafeStringWriter(sb), condition, this.ExplorationServices.TermManager);
            sb.AppendLine();
            var swriter = new TermSExpWriter(termManager, new SafeStringWriter(sb), true, false);
            swriter.Write(condition);
            sb.AppendLine();
            sb.AppendLine("location:");
            sb.AppendLine();
            sb.AppendLine(executionNode.CodeLocation.ToString());
            sb.AppendLine();
            sb.AppendLine("properties:");

            Term unnegatedCondition;
            if (termManager.TryGetInnerLogicallyNegatedValue(condition, out unnegatedCondition))
                sb.AppendLine("negated");
            else
                unnegatedCondition = condition;

            var targetFieldValues = new SafeDictionary<Field, object>();
            Term left, right;
            BinaryOperator binOp;
            if (termManager.TryGetBinary(unnegatedCondition, out binOp, out left, out right))
            {
                sb.AppendFormat("binary relation: {0}", binOp);
                sb.AppendLine();

                if (!termManager.IsValue(left) && !termManager.IsValue(right))
                {
                    sb.AppendLine("No constant on either left side or right side.");
                    return;
                }

                Term non_constant_term = null;
                Term constant_term = null;
                if (termManager.IsValue(left))
                {
                    non_constant_term = right;
                    constant_term = left;
                }
                else if (termManager.IsValue(right))
                {
                    non_constant_term = left;
                    constant_term = right;
                }

                sb.AppendLine("against constant");
                if (constant_term == null || termManager.IsDefaultValue(constant_term))
                {
                    sb.AppendLine("against default value ('null' for references)");
                }

                int value;
                if (constant_term != null && termManager.TryGetI4Constant(constant_term, out value))
                {
                    sb.AppendLine("against integer: " + value);
                }

                Term objectValue;
                ObjectProperty objectProperty;
                if (constant_term != null && termManager.TryGetObjectProperty(constant_term, out objectValue, out objectProperty))
                {
                    sb.AppendLine("against object property: object=" + objectValue + ", property=" + objectProperty);
                }

                sb.AppendLine(" involving fields: ");
                SafeDictionary<Field, FieldValueHolder> innerFieldValues;
                SafeList<TypeEx> innerFieldTypes;
                SafeList<Field> fs = TargetBranchAnalyzer.GetInvolvedFields(this, termManager,
                    non_constant_term, out innerFieldValues, out innerFieldTypes);
                foreach (var f in fs)
                {
                    sb.AppendLine(f.FullName);
                }
            }

            sb.AppendLine("Executed method call sequence");
            if(this.pmd.LastExecutedFactoryMethodCallSequence != null)
                foreach (var m in this.pmd.LastExecutedFactoryMethodCallSequence)
                {
                    sb.AppendLine("\t" + m);
                }

            this.Log.Dump("foo", "insufficiency for " + (explorableType != null ? explorableType.FullName : "?"), sb.ToString());
            return;
        }