Binary operator expression.
Наследование: IConditionExpression
        public void EvaluateAndTest()
        {
            IConditionExpression nameExpression = new BinaryOperatorExpression(
                BinaryExpressionOperator.Equal,
                new ElementAttributeExpression(ElementAttributeType.Name),
                new StringExpression("Test"));

            IConditionExpression attributeExpression = new BinaryOperatorExpression(
                BinaryExpressionOperator.Equal,
                new ElementAttributeExpression(ElementAttributeType.Access),
                new StringExpression("Protected"));

            IConditionExpression expression = new BinaryOperatorExpression(
                BinaryExpressionOperator.And, nameExpression, attributeExpression);

            FieldElement element = new FieldElement();
            element.Name = "Test";
            element.Access = CodeAccess.Protected;

            bool result = ConditionExpressionEvaluator.Instance.Evaluate(
                expression, element);
            Assert.IsTrue(result, "Unexpected expression evaluation result.");

            element.Name = "Foo";
            result = ConditionExpressionEvaluator.Instance.Evaluate(
                expression, element);
            Assert.IsFalse(result, "Unexpected expression evaluation result.");

            element.Name = "Test";
            element.Access = CodeAccess.Private;
            result = ConditionExpressionEvaluator.Instance.Evaluate(
                expression, element);
            Assert.IsFalse(result, "Unexpected expression evaluation result.");
        }
        public void ToStringInvalidOperatorTest()
        {
            ElementAttributeExpression attributeExpression = new ElementAttributeExpression(ElementAttributeType.Name);
            StringExpression stringExpression = new StringExpression("Test");
            BinaryOperatorExpression operatorExpression = new BinaryOperatorExpression(
                (BinaryExpressionOperator) int.MinValue,
                attributeExpression,
                stringExpression);

            Assert.AreEqual(string.Format("($(Element.Name) {0} 'Test')", int.MinValue), operatorExpression.ToString());
        }
        public void ToStringTest()
        {
            ElementAttributeExpression attributeExpression = new ElementAttributeExpression(
                ElementAttributeType.Name);
            StringExpression stringExpression = new StringExpression("Test");
            BinaryOperatorExpression operatorExpression = new BinaryOperatorExpression(
                BinaryExpressionOperator.Equal,
                attributeExpression,
                stringExpression);

            Assert.AreEqual("($(Element.Name) == 'Test')", operatorExpression.ToString());
        }
        public void EvaluateElementNameContainsTest()
        {
            IConditionExpression expression = new BinaryOperatorExpression(
                BinaryExpressionOperator.Contains,
                new ElementAttributeExpression(ElementAttributeType.Name),
                new StringExpression("Test"));

            FieldElement element = new FieldElement();
            element.Name = "Test";

            bool result = ConditionExpressionEvaluator.Instance.Evaluate(
                expression, element);
            Assert.IsTrue(result, "Unexpected expression evaluation result.");

            element.Name = "OnTest1";
            result = ConditionExpressionEvaluator.Instance.Evaluate(
                expression, element);
            Assert.IsTrue(result, "Unexpected expression evaluation result.");

            element.Name = "Foo";
            result = ConditionExpressionEvaluator.Instance.Evaluate(
                expression, element);
            Assert.IsFalse(result, "Unexpected expression evaluation result.");
        }
        /// <summary>
        /// Takes in a list of expressions and operator expression placeholders and
        /// builds an expression tree node.
        /// </summary>
        /// <param name="originalNodes">Original nodes.</param>
        /// <param name="originalExpression">Original expression.</param>
        /// <returns>A condition expression.</returns>
        private static IConditionExpression AssembleExpressionTree(
            ReadOnlyCollection<IConditionExpression> originalNodes, string originalExpression)
        {
            IConditionExpression conditionExpression = null;

            List<IConditionExpression> nodes = new List<IConditionExpression>(originalNodes);

            //
            // Build a queue that represents the binary operator precedence
            //
            Queue<BinaryExpressionOperator> operatorPrecedence = new Queue<BinaryExpressionOperator>();
            operatorPrecedence.Enqueue(BinaryExpressionOperator.Equal);
            operatorPrecedence.Enqueue(BinaryExpressionOperator.NotEqual);
            operatorPrecedence.Enqueue(BinaryExpressionOperator.Contains);
            operatorPrecedence.Enqueue(BinaryExpressionOperator.Matches);
            operatorPrecedence.Enqueue(BinaryExpressionOperator.And);
            operatorPrecedence.Enqueue(BinaryExpressionOperator.Or);

            //
            // Loop through the nodes and merge them by operator precedence
            //
            BinaryExpressionOperator currentOperator = operatorPrecedence.Dequeue();
            while (nodes.Count > 1)
            {
                for (int nodeIndex = 1; nodeIndex < nodes.Count - 1; nodeIndex++)
                {
                    OperatorExpressionPlaceholder operatorExpressionPlaceHolder =
                        nodes[nodeIndex] as OperatorExpressionPlaceholder;

                    if (operatorExpressionPlaceHolder != null &&
                        operatorExpressionPlaceHolder.Operator == currentOperator)
                    {
                        IConditionExpression left = nodes[nodeIndex - 1];
                        IConditionExpression right = nodes[nodeIndex + 1];

                        if ((operatorExpressionPlaceHolder.Operator == BinaryExpressionOperator.Equal ||
                            operatorExpressionPlaceHolder.Operator == BinaryExpressionOperator.Contains) &&
                            !(left is LeafExpression && right is LeafExpression))
                        {
                            OnInvalidExpression(originalExpression);
                        }

                        BinaryOperatorExpression operatorExpression = new BinaryOperatorExpression(
                            operatorExpressionPlaceHolder.Operator, left, right);

                        nodes[nodeIndex] = operatorExpression;
                        nodes.Remove(left);
                        nodes.Remove(right);

                        //
                        // Restart processing of this level
                        //
                        nodeIndex = 0;
                    }
                }

                if (operatorPrecedence.Count > 0)
                {
                    currentOperator = operatorPrecedence.Dequeue();
                }
                else
                {
                    break;
                }
            }

            //
            // At the end of everything, we should have a single binary or unary
            // condition expression.  Anything else is invalid and a format exception
            // will be thrown.
            //
            if (nodes.Count == 1)
            {
                conditionExpression = nodes[0] as BinaryOperatorExpression;
                if (conditionExpression == null)
                {
                    conditionExpression = nodes[0] as UnaryOperatorExpression;
                }
            }

            if (conditionExpression == null)
            {
                OnInvalidExpression(originalExpression);
            }

            return conditionExpression;
        }
        public void EvaluateInvalidOperatorTest()
        {
            IConditionExpression expression = new BinaryOperatorExpression(
                (BinaryExpressionOperator) int.MinValue,
                new ElementAttributeExpression(ElementAttributeType.Name),
                new StringExpression("Test"));

            FieldElement element = new FieldElement();
            element.Name = "Test";

            bool result = ConditionExpressionEvaluator.Instance.Evaluate(
                expression, element);
        }
        public void EvaluateFilePathContainsTest()
        {
            string testFile1 = Path.GetTempFileName();
            string testFile2 = Path.GetTempFileName();
            try
            {
                IConditionExpression expression = new BinaryOperatorExpression(
                    BinaryExpressionOperator.Contains,
                    new FileAttributeExpression(FileAttributeType.Path),
                    new StringExpression(Path.Combine(Path.GetTempPath(), Path.GetFileNameWithoutExtension(testFile1))));

                FileInfo file = new FileInfo(testFile1);

                bool result = ConditionExpressionEvaluator.Instance.Evaluate(
                    expression, file);
                Assert.IsTrue(result, "Unexpected expression evaluation result.");

                file = new FileInfo(testFile2);
                result = ConditionExpressionEvaluator.Instance.Evaluate(
                    expression, file);
                Assert.IsFalse(result, "Unexpected expression evaluation result.");
            }
            finally
            {
                try
                {
                    File.Delete(testFile1);
                    File.Delete(testFile2);
                }
                catch
                {
                }
            }
        }
        public void EvaluateFileNullTest()
        {
            IConditionExpression expression = new BinaryOperatorExpression(
                BinaryExpressionOperator.Equal,
                new FileAttributeExpression(FileAttributeType.Name),
                new StringExpression("Test"));

            bool result = ConditionExpressionEvaluator.Instance.Evaluate(
                expression, null as FileInfo);
        }
        public void EvaluateFileNameContainsTest()
        {
            IConditionExpression expression = new BinaryOperatorExpression(
                BinaryExpressionOperator.Contains,
                new FileAttributeExpression(FileAttributeType.Name),
                new StringExpression("Test"));

            FileInfo file = new FileInfo("Test");

            bool result = ConditionExpressionEvaluator.Instance.Evaluate(
                expression, file);
            Assert.IsTrue(result, "Unexpected expression evaluation result.");

            file = new FileInfo("Blah");
            result = ConditionExpressionEvaluator.Instance.Evaluate(
                expression, file);
            Assert.IsFalse(result, "Unexpected expression evaluation result.");
        }
        public void EvaluateFileAttributesContainsTest()
        {
            string testFile = Path.GetTempFileName();
            try
            {
                IConditionExpression expression = new BinaryOperatorExpression(
                    BinaryExpressionOperator.Contains,
                    new FileAttributeExpression(FileAttributeType.Attributes),
                    new StringExpression("ReadOnly"));

                FileInfo file = new FileInfo(testFile);
                file.Attributes = FileAttributes.ReadOnly | FileAttributes.Hidden;

                bool result = ConditionExpressionEvaluator.Instance.Evaluate(
                    expression, file);
                Assert.IsTrue(result, "Unexpected expression evaluation result.");

                file.Attributes = FileAttributes.Normal;
                file = new FileInfo(testFile);
                result = ConditionExpressionEvaluator.Instance.Evaluate(
                    expression, file);
                Assert.IsFalse(result, "Unexpected expression evaluation result.");
            }
            finally
            {
                try
                {
                    File.Delete(testFile);
                }
                catch
                {
                }
            }
        }
        public void EvaluateElementParentAttributesContainsTest()
        {
            IConditionExpression expression = new BinaryOperatorExpression(
                BinaryExpressionOperator.Contains,
                new ElementAttributeExpression(ElementAttributeType.Attributes, ElementAttributeScope.Parent),
                new StringExpression("Attribute2"));

            FieldElement element = new FieldElement();
            element.Name = "Test";

            TypeElement typeElement = new TypeElement();
            typeElement.Type = TypeElementType.Structure;
            typeElement.Name = "TestType";
            typeElement.AddChild(element);

            typeElement.AddAttribute(new AttributeElement("Attribute1"));
            typeElement.AddAttribute(new AttributeElement("Attribute24"));

            bool result = ConditionExpressionEvaluator.Instance.Evaluate(
                expression, element);
            Assert.IsTrue(result, "Unexpected expression evaluation result.");

            typeElement.ClearAttributes();
            result = ConditionExpressionEvaluator.Instance.Evaluate(
                expression, element);
            Assert.IsFalse(result, "Unexpected expression evaluation result.");
        }
        public void EvaluateElementNullTest()
        {
            IConditionExpression expression = new BinaryOperatorExpression(
                BinaryExpressionOperator.Equal,
                new ElementAttributeExpression(ElementAttributeType.Name),
                new StringExpression("Test"));

            bool result = ConditionExpressionEvaluator.Instance.Evaluate(
                expression, null as ICodeElement);
        }
        public void EvaluateElementNameMatchesTest()
        {
            IConditionExpression expression = new BinaryOperatorExpression(
                BinaryExpressionOperator.Matches,
                new ElementAttributeExpression(ElementAttributeType.Name),
                new StringExpression("IDisposable\\..*"));

            MethodElement element = new MethodElement();
            element.Name = "IDisposable.Dispose";

            bool result = ConditionExpressionEvaluator.Instance.Evaluate(
                expression, element);
            Assert.IsTrue(result, "Unexpected expression evaluation result.");

            element.Name = "IDisposable.Test";
            result = ConditionExpressionEvaluator.Instance.Evaluate(
                expression, element);
            Assert.IsTrue(result, "Unexpected expression evaluation result.");

            element.Name = "IDisposable";
            result = ConditionExpressionEvaluator.Instance.Evaluate(
                expression, element);
            Assert.IsFalse(result, "Unexpected expression evaluation result.");
        }
Пример #14
0
        /// <summary>
        /// Takes in a list of expressions and operator expression placeholders and
        /// builds an expression tree node.
        /// </summary>
        /// <param name="originalNodes">Original nodes.</param>
        /// <param name="originalExpression">Original expression.</param>
        /// <returns>A condition expression.</returns>
        private static IConditionExpression AssembleExpressionTree(
            ReadOnlyCollection <IConditionExpression> originalNodes, string originalExpression)
        {
            IConditionExpression conditionExpression = null;

            List <IConditionExpression> nodes = new List <IConditionExpression>(originalNodes);

            //
            // Build a queue that represents the binary operator precedence
            //
            Queue <BinaryExpressionOperator> operatorPrecedence = new Queue <BinaryExpressionOperator>();

            operatorPrecedence.Enqueue(BinaryExpressionOperator.Equal);
            operatorPrecedence.Enqueue(BinaryExpressionOperator.NotEqual);
            operatorPrecedence.Enqueue(BinaryExpressionOperator.Contains);
            operatorPrecedence.Enqueue(BinaryExpressionOperator.Matches);
            operatorPrecedence.Enqueue(BinaryExpressionOperator.And);
            operatorPrecedence.Enqueue(BinaryExpressionOperator.Or);

            //
            // Loop through the nodes and merge them by operator precedence
            //
            BinaryExpressionOperator currentOperator = operatorPrecedence.Dequeue();

            while (nodes.Count > 1)
            {
                for (int nodeIndex = 1; nodeIndex < nodes.Count - 1; nodeIndex++)
                {
                    OperatorExpressionPlaceholder operatorExpressionPlaceHolder =
                        nodes[nodeIndex] as OperatorExpressionPlaceholder;

                    if (operatorExpressionPlaceHolder != null &&
                        operatorExpressionPlaceHolder.Operator == currentOperator)
                    {
                        IConditionExpression left  = nodes[nodeIndex - 1];
                        IConditionExpression right = nodes[nodeIndex + 1];

                        if ((operatorExpressionPlaceHolder.Operator == BinaryExpressionOperator.Equal ||
                             operatorExpressionPlaceHolder.Operator == BinaryExpressionOperator.Contains) &&
                            !(left is LeafExpression && right is LeafExpression))
                        {
                            OnInvalidExpression(originalExpression);
                        }

                        BinaryOperatorExpression operatorExpression = new BinaryOperatorExpression(
                            operatorExpressionPlaceHolder.Operator, left, right);

                        nodes[nodeIndex] = operatorExpression;
                        nodes.Remove(left);
                        nodes.Remove(right);

                        //
                        // Restart processing of this level
                        //
                        nodeIndex = 0;
                    }
                }

                if (operatorPrecedence.Count > 0)
                {
                    currentOperator = operatorPrecedence.Dequeue();
                }
                else
                {
                    break;
                }
            }

            //
            // At the end of everything, we should have a single binary or unary
            // condition expression.  Anything else is invalid and a format exception
            // will be thrown.
            //
            if (nodes.Count == 1)
            {
                conditionExpression = nodes[0] as BinaryOperatorExpression;
                if (conditionExpression == null)
                {
                    conditionExpression = nodes[0] as UnaryOperatorExpression;
                }
            }

            if (conditionExpression == null)
            {
                OnInvalidExpression(originalExpression);
            }

            return(conditionExpression);
        }