Пример #1
0
        public void Should_Build_Indexed_Property_In_Chain()
        {
            var result = ToList(ExpressionNodeBuilder.Build("Foo.Bar[5, 6].Baz"));

            Assert.Equal(4, result.Count);
            AssertIsProperty(result[0], "Foo");
            AssertIsProperty(result[1], "Bar");
            AssertIsIndexer(result[2], "5", "6");
            AssertIsProperty(result[3], "Baz");
        }
        public void Should_Build_Negated_Property_Chain()
        {
            var result = ToList(ExpressionNodeBuilder.Build("!Foo.Bar.Baz"));

            Assert.Equal(4, result.Count);
            Assert.IsType <LogicalNotNode>(result[0]);
            AssertIsProperty(result[1], "Foo");
            AssertIsProperty(result[2], "Bar");
            AssertIsProperty(result[3], "Baz");
        }
Пример #3
0
        public object Select(object o)
        {
            if (string.IsNullOrEmpty(MemberName))
            {
                return(o);
            }

            if (_expressionNode == null)
            {
                _expressionNode = ExpressionNodeBuilder.Build(MemberName);

                _memberValueNode = _expressionNode;

                while (_memberValueNode.Next != null)
                {
                    _memberValueNode = _memberValueNode.Next;
                }
            }

            _expressionNode.Target = new WeakReference(o);

            object result = _memberValueNode.CurrentValue.Target;

            _expressionNode.Target = null;

            if (result == AvaloniaProperty.UnsetValue)
            {
                return(null);
            }
            else if (result is BindingError)
            {
                return(null);
            }

            return(result);
        }
Пример #4
0
 public void Expression_Cannot_Have_Letter_After_Indexer()
 {
     Assert.Throws <ExpressionParseException>(
         () => ExpressionNodeBuilder.Build("Foo.Bar[3,4]A"));
 }
Пример #5
0
 public void Expression_Cannot_Have_Extra_Comma_At_End_Of_Indexer()
 {
     Assert.Throws <ExpressionParseException>(
         () => ExpressionNodeBuilder.Build("Foo.Bar[3,4,]"));
 }
Пример #6
0
 public void Expression_Cannot_Have_Empty_Indexer()
 {
     Assert.Throws <ExpressionParseException>(
         () => ExpressionNodeBuilder.Build("Foo.Bar[]"));
 }
Пример #7
0
 public void Expression_Cannot_End_With_Period()
 {
     Assert.Throws <ExpressionParseException>(
         () => ExpressionNodeBuilder.Build("Foo.Bar."));
 }
Пример #8
0
 public void Identifier_Cannot_Start_With_Symbol()
 {
     Assert.Throws <ExpressionParseException>(
         () => ExpressionNodeBuilder.Build("Foo.%Bar"));
 }
Пример #9
0
 public void Identifier_Cannot_Start_With_Digit()
 {
     Assert.Throws <ExpressionParseException>(
         () => ExpressionNodeBuilder.Build("1Foo"));
 }
Пример #10
0
        public void Should_Build_Property_With_Digits()
        {
            var result = ToList(ExpressionNodeBuilder.Build("F0o"));

            AssertIsProperty(result[0], "F0o");
        }
Пример #11
0
        public void Should_Build_Underscored_Property()
        {
            var result = ToList(ExpressionNodeBuilder.Build("_Foo"));

            AssertIsProperty(result[0], "_Foo");
        }
Пример #12
0
        public void Should_Build_Single_Property()
        {
            var result = ToList(ExpressionNodeBuilder.Build("Foo"));

            AssertIsProperty(result[0], "Foo");
        }