public void ParameterExpressionHelper_GenerateRandom16CharWord()
        {
            // Arrange and Act
            string result = ParameterExpressionHelper.GenerateRandomWord();

            // Assert
            Check.That(result).Matches(@"[a-z]{16}");
        }
        public void ParameterExpressionHelper_IsNullOrWhiteSpace(string input, bool expectedResult)
        {
            // Arrange and Act
            bool result = ParameterExpressionHelper.IsNullOrWhiteSpace(input);

            // Assert
            Check.That(result).IsEqualTo(expectedResult);
        }
Exemplo n.º 3
0
        public void Parse_ParseAndOperator(string expression, string result)
        {
            // Arrange
            ParameterExpression[] parameters = { ParameterExpressionHelper.CreateParameterExpression(typeof(bool), "x") };
            var sut = new ExpressionParser(parameters, expression, null, null);

            // Act
            var parsedExpression = sut.Parse(null).ToString();

            // Assert
            Check.That(parsedExpression).Equals(result);
        }
Exemplo n.º 4
0
        public void Parse_CastIntShouldReturnConstantExpression(string expression, object result)
        {
            // Arrange
            ParameterExpression[] parameters = { ParameterExpressionHelper.CreateParameterExpression(typeof(bool), "x") };
            var sut = new ExpressionParser(parameters, expression, null, null);

            // Act
            var constantExpression = (ConstantExpression)sut.Parse(null);

            // Assert
            Check.That(constantExpression.Value).Equals(result);
        }
        public void ParameterExpressionHelper_CreateParameterExpression(Type type, string expression, string expectedResult, string substitute, bool renameEmpty)
        {
            // Arrange
            ParameterExpression[] parameters = { ParameterExpressionHelper.CreateParameterExpression(type, substitute, renameEmpty) };
            var sut = new ExpressionParser(parameters, expression, null, null);

            // Act
            var parsedExpression = sut.Parse(null).ToString();

            // Assert
            Check.That(parsedExpression).Matches(expectedResult);
        }
        public void Parse_NullableShouldReturnNullable(string expression, object resultType, object result)
        {
            // Arrange
            ParameterExpression[] parameters = { ParameterExpressionHelper.CreateParameterExpression(typeof(bool), "x") };
            var sut = new ExpressionParser(parameters, expression, null, null);

            // Act
            var unaryExpression = (UnaryExpression)sut.Parse(null);

            // Assert
            Check.That(unaryExpression.Type).Equals(resultType);
            Check.That(unaryExpression.ToString()).Equals(result);
        }
        /// <inheritdoc cref="ExpressionVisitor.VisitParameter"/>
        protected override Expression VisitParameter(ParameterExpression node)
        {
            if (string.Equals(_oldName, node.Name, StringComparison.Ordinal))
            {
                if (_parameterExpression == null)
                {
                    _parameterExpression = ParameterExpressionHelper.CreateParameterExpression(node.Type, _newName);
                }

                return(_parameterExpression);
                // throw new InvalidOperationException($"The {nameof(ParameterExpressionRenamer)} can only rename 1 (Typed)ParameterExpression in an Expression.");
            }
            else
            {
                return(node);
            }
        }
        public void Parse_PrioritizePropertyOrFieldOverTheType(string expression, string result)
        {
            // Arrange
            ParameterExpression[] parameters = { ParameterExpressionHelper.CreateParameterExpression(typeof(Company), "company") };
            var sut = new ExpressionParser(parameters, expression, null, _parsingConfig);

            // Act
            string parsedExpression = null;

            try
            {
                parsedExpression = sut.Parse(null).ToString();
            }
            catch (ParseException e)
            {
                parsedExpression = e.Message;
            }

            // Assert
            Check.That(parsedExpression).Equals(result);
        }