Exemple #1
0
        //Variable does not need parsing
        public void TestInspectionParser11()
        {
            string variable = "variable";

            parser = new InspectionParser(variable);
            List <string> parsedResult = parser.GetParsedCommands();

            Assert.IsTrue(parser.NeedsParsing() == false);
        }
Exemple #2
0
        //Invalid variable sent for parsing
        public void TestInspectionParser09()
        {
            string variable = ".variable.check";

            parser = new InspectionParser(variable);
            List <string> parsedResult = parser.GetParsedCommands();

            Assert.IsTrue(parser.IsValid == false);
            Assert.IsTrue(parser.NeedsParsing() == true);
        }
        public void TestInspectionParser03()
        {
            string variable = "class.property";
            parser = new InspectionParser(variable);
            List<string> parsedResult = parser.GetParsedCommands();

            Assert.AreEqual(parsedResult[0], "class");
            Assert.AreEqual(parsedResult[1], ".property");
            Assert.IsTrue(parser.IsValid == true);
            Assert.IsTrue(parser.NeedsParsing() == true);
        }
Exemple #4
0
        //Class property
        public void TestInspectionParser03()
        {
            string variable = "class.property";

            parser = new InspectionParser(variable);
            List <string> parsedResult = parser.GetParsedCommands();

            Assert.AreEqual(parsedResult[0], "class");
            Assert.AreEqual(parsedResult[1], ".property");
            Assert.IsTrue(parser.IsValid == true);
            Assert.IsTrue(parser.NeedsParsing() == true);
        }
        public void TestInspectionParser02()
        {
            string variable = "array[0][1][2]";
            parser = new InspectionParser(variable);
            List<string> parsedResult = parser.GetParsedCommands();

            Assert.AreEqual(parsedResult[0], "array");
            Assert.AreEqual(parsedResult[1], "[0]");
            Assert.AreEqual(parsedResult[2], "[1]");
            Assert.AreEqual(parsedResult[3], "[2]");
            Assert.IsTrue(parser.IsValid == true);
            Assert.IsTrue(parser.NeedsParsing() == true);
        }
Exemple #6
0
        //Multidimensional arrays
        public void TestInspectionParser02()
        {
            string variable = "array[0][1][2]";

            parser = new InspectionParser(variable);
            List <string> parsedResult = parser.GetParsedCommands();

            Assert.AreEqual(parsedResult[0], "array");
            Assert.AreEqual(parsedResult[1], "[0]");
            Assert.AreEqual(parsedResult[2], "[1]");
            Assert.AreEqual(parsedResult[3], "[2]");
            Assert.IsTrue(parser.IsValid == true);
            Assert.IsTrue(parser.NeedsParsing() == true);
        }
Exemple #7
0
        //Class-class-array-class-multidimensional array-class-array
        public void TestInspectionParser08()
        {
            string variable = "classA.propertyA[3].propertyB[1][0].propertyC[1]";

            parser = new InspectionParser(variable);
            List <string> parsedResult = parser.GetParsedCommands();

            Assert.AreEqual(parsedResult[0], "classA");
            Assert.AreEqual(parsedResult[1], ".propertyA");
            Assert.AreEqual(parsedResult[2], "[3]");
            Assert.AreEqual(parsedResult[3], ".propertyB");
            Assert.AreEqual(parsedResult[4], "[1]");
            Assert.AreEqual(parsedResult[5], "[0]");
            Assert.AreEqual(parsedResult[6], ".propertyC");
            Assert.AreEqual(parsedResult[7], "[1]");
            Assert.IsTrue(parser.IsValid == true);
            Assert.IsTrue(parser.NeedsParsing() == true);
        }
        /// <summary>
        /// Method to add new inspection data to the Watch Window/ToolTip
        /// This method uses the CreateInspectionData method to populate the information
        /// </summary>
        /// <param name="variableName"> Name of the variable to be added </param>
        /// <returns>
        /// True - if successfully added
        /// False - if exception was thrown
        /// </returns>
        public bool AddInspectionData(string variableName, bool isToolTip)
        {
            inspectionToolTip = isToolTip;
            if (false != inspectionToolTip)
                dataCollection.Clear();

            if (string.IsNullOrWhiteSpace(variableName))
                return false;

            // Always leave last item as  blank data
            InspectionData data = new InspectionData(variableName);
            if (dataCollection.Count == 0)
                dataCollection.Add(data);
            else
                dataCollection.Insert(dataCollection.Count - 1, data);

            // Inspection tool tip requires immediate validation.
            if (false != inspectionToolTip)
                CreateDataRecursive(data, GetStackValue(variableName));

            return true;
            #if false

            if (isToolTip)
            {
                toolTips = true;
                dataCollection.Clear();
            }

            if (string.IsNullOrWhiteSpace(variableName))
                return false;

            ProtoCore.Lang.Obj stackValue = null;
            InspectionParser parser = new InspectionParser(variableName);
            variableName = variableName.Trim();
            bool limit = false;
            int limitValue = 0;
            if (parser.NeedsParsing())
            {
                List<string> parsedCommands = parser.GetParsedCommands();
                if (parser.IsValid == true)
                {
                    stackValue = GetParsedObject(parsedCommands, out limit);
                    if (limit)
                    {
                        string val = parsedCommands[parsedCommands.Count - 1].Replace(",", string.Empty);
                        limitValue = Convert.ToInt32(val);
                    }
                }
                else
                    stackValue = null;
            }
            else
            {
                stackValue = GetStackValue(variableName);
            }

            if (stackValue == null)
            {
                //Throw exceptions
                string n = variableName;
                string v = GetStackValuePayload(n);
                string t = GetStackValueType(n);

                // Always leave last item as  blank data
                if (dataCollection.Count != 0)
                    dataCollection.Insert(dataCollection.Count - 1, new InspectionData(n, v, t));
                else
                    dataCollection.Add(new InspectionData(n, v, t));

                return false;
            }
            else
            {
                //Get actual data
                InspectionData inspectedData;
                inspectedData = CreateInspectionData(stackValue, variableName);

                if (dataCollection.Count != 0)
                    dataCollection.Insert(dataCollection.Count - 1, inspectedData);
                else
                    dataCollection.Add(inspectedData);

                return true;
            }
            #endif
        }
        /// <summary>
        /// This method is hit on one condition: the variable CAN be expanded by pressing the [+] 
        /// symbol in the watch window. This means some sort of expansion should replace the silly old
        /// 'This is dummy' and populate it. This method goes about populating the selectedData.Derivations
        /// for arrays and classes (which are the only expandable variables in a watch window). 
        /// For arrays, this method also tests if the array is larger than a certain value, indicating to
        /// the user that it may take some time to expand.
        /// </summary>
        /// <param name="selectedData"> InspectionData object of the variable that is to be expanded</param>
        public void ExpandInspection(InspectionData selectedData)
        {
            selectedData.IsExpanded = true;
            string qualifiedName = selectedData.GetQualifiedName();
            ProtoCore.Lang.Obj stackValue = GetStackValue(qualifiedName);
            CreateDataRecursive(selectedData, stackValue);
            #if false
            ProtoCore.Lang.Obj dataObj = null;

            // Use Inspection Parser to parse the string to decipher what kind of expansion required
            InspectionParser parser = new InspectionParser(selectedData.Name);
            bool limit = false;
            int limitValue = 0;
            List<string> parsedCommands = null;

            // An inspection variable needs parsing when it contains:
            // [] (array) and/or
            // '.' (class properties) and/or
            // ',' (limit)
            if (parser.NeedsParsing())
            {
                parsedCommands = parser.GetParsedCommands();
                if (parser.IsValid == true)
                {
                    // Use GetParsedObject method to decipher Obj from parsed string
                    dataObj = GetParsedObject(parsedCommands, out limit);

                    // A limit is indicated by a comma (,)
                    if (limit)
                    {
                        // The limit should ALWAYS be the last item in parsed commands
                        string val = parsedCommands[parsedCommands.Count - 1].Replace(",", string.Empty);
                        limitValue = Convert.ToInt32(val);
                    }
                }
                else
                    dataObj = null;
            }
            else
            {
                dataObj = GetInnerInspectionObject(selectedData);
            }

            // If, from any level above the dataObj is null, throw an exception
            if (dataObj == null)
            {
                //Throw exceptions
                string n = selectedData.Name;
                string v = GetStackValuePayload(n);
                string t = GetStackValueType(n);

                // Replace the current data with the exceptions relevant for it
                RemoveInspectionData(selectedData);
                dataCollection.Insert(dataCollection.Count - 1, new InspectionData(n, v, t));
            }
            // Otherwise expand it by one more level yo!
            else
            {
                if (selectedData.Type == "array")
                    ExpandArrayInspectionData(selectedData, limit);
                else
                    ExpandClassInspectionData(selectedData);
            }

            #endif
        }
        public void TestInspectionParser11()
        {
            string variable = "variable";
            parser = new InspectionParser(variable);
            List<string> parsedResult = parser.GetParsedCommands();

            Assert.IsTrue(parser.NeedsParsing() == false);
        }
        public void TestInspectionParser09()
        {
            string variable = ".variable.check";
            parser = new InspectionParser(variable);
            List<string> parsedResult = parser.GetParsedCommands();

            Assert.IsTrue(parser.IsValid == false);
            Assert.IsTrue(parser.NeedsParsing() == true);
        }
        public void TestInspectionParser08()
        {
            string variable = "classA.propertyA[3].propertyB[1][0].propertyC[1]";
            parser = new InspectionParser(variable);
            List<string> parsedResult = parser.GetParsedCommands();

            Assert.AreEqual(parsedResult[0], "classA");
            Assert.AreEqual(parsedResult[1], ".propertyA");
            Assert.AreEqual(parsedResult[2], "[3]");
            Assert.AreEqual(parsedResult[3], ".propertyB");
            Assert.AreEqual(parsedResult[4], "[1]");
            Assert.AreEqual(parsedResult[5], "[0]");
            Assert.AreEqual(parsedResult[6], ".propertyC");
            Assert.AreEqual(parsedResult[7], "[1]");
            Assert.IsTrue(parser.IsValid == true);
            Assert.IsTrue(parser.NeedsParsing() == true);
        }