示例#1
0
        /// <inheritdoc/>
        public override ExpNode Execute(VectorProductOperNode node)
        {
            // Verify left and right child are two multiplyable vectors.
            if (node.LeftChild is TensorNode vector1 && vector1.DimensionCount == 1 &&
                node.RightChild is TensorNode vector2 && vector2.DimensionCount == 1 &&
                vector1.SizeIdentity == vector2.SizeIdentity)
            {
                int size = vector1.GetDimensionSize(1);
                switch (node.ProductMethod)
                {
                case VectorProductMethod.DOT:
                    ExpNode[] terms = new ExpNode[size];
                    for (int i = 0; i < size; i++)
                    {
                        terms[i] = QuickOpers.Multiply(vector1.GetChild(i), vector2.GetChild(i));
                    }
                    return(QuickOpers.Sum(terms).Execute(this));

                case VectorProductMethod.CROSS:     // TODO: Convert to matrix notation for determinant
                default:
                    return(node);
                }
            }

            return(HandleError(new CannotMultiplyTensors(this, node)));
        }
示例#2
0
 /// <summary>
 /// Creates a new <see cref="RecipricalOperNode"/> around <paramref name="node"/>.
 /// </summary>
 /// <param name="node">The <see cref="ExpNode"/> to take the reciprical of.</param>
 /// <returns>A new <see cref="RecipricalOperNode"/> around <paramref name="node"/>.</returns>
 public static RecipricalOperNode Reciprical(ExpNode node)
 {
     return(new RecipricalOperNode()
     {
         Child = node
     });
 }
示例#3
0
        public virtual void RunModel()
        {
            QueryModel model = new QueryModel(_workspace, _kind, null);
            ModelEngine engine = new ModelEngine(model);
            engine.Options.WeightScheme = WeightScheme.Custom;
            engine.Options.Timeout = 100;

            engine.RunUntil(delegate()
            {
                return model.Actions.Accessed > 5;
            });


            _query = model.QueryResult;
            _container = model.ResContainer;
            _pType = model.ResultType;

            if (_query != null || _pType != null)
            {
                switch (_queryType)
                {
                    case "server":
                        VerifyServer(_query);
                        break;
                    case "client":
                        VerifyClient(model);
                        break;
                    case "linq":
                        VerifyClientLinq(model);
                        break;
                }
            }
        }
示例#4
0
        private ExpNode parseElmnt()
        {
            if (lex.Peek() == Token.NUM)
            {
                return(new NumExpNode(lex.Take()));
            }
            if (lex.Peek() == Token.ID)
            {
                LexUnit id = lex.Take();
                if (lex.Peek() == Token.LPN)
                {
                    lex.Take();
                    FncCallExpNode fnc = new FncCallExpNode();
                    fnc.ID   = id;
                    fnc.args = parseArgs();
                    Match(Token.RPN, "expected ')' for valid function call");
                    return(fnc);
                }
                else
                {
                    return(new IdExpNode(id));
                }
            }

            if (lex.Peek() == Token.LPN)
            {
                lex.Take();
                ExpNode exp = parseExp();
                Match(Token.RPN, "expected ')' for valid expression");
                return(exp);
            }
            throw new ParseException(ref lex.unit, "invalid in expression");
        }
示例#5
0
        public ExpNode parseExp()
        {
            OpExpNode exp  = null;
            ExpNode   fact = null;

            if (lex.Peek() == Token.SUB)
            {
                exp       = new OpExpNode();
                exp.left  = null;
                exp.OP    = lex.Take();
                exp.right = parseFact();
            }
            else
            {
                fact = parseFact();
            }
            while (lex.Peek() == Token.ADD || lex.Peek() == Token.SUB)
            {
                OpExpNode tmp = new OpExpNode();
                tmp.left  = exp == null ? fact : exp;
                tmp.OP    = lex.Take();
                tmp.right = parseFact();
                exp       = tmp;
            }
            return(exp == null ? fact : exp);
        }
 public TypeVisiter(ExpNode node)
     : base(node)
 {
     rootParam = new Stack <ParameterExpression>();
     rootParam.Push(Expression.Parameter(typeof(T)));
     this.context = new MContext(typeof(T));
 }
示例#7
0
        private TreeNode getFactor()
        {
            TreeNode treeNode;

            switch (tokens[currentTokenIndex].Type)
            {
            case TokenType.BracketLeft:
                match(TokenType.BracketLeft);
                currentTokenIndex++;
                treeNode = getExp();
                currentTokenIndex++;
                match(TokenType.BracketRight);
                break;

            case TokenType.Id:
                treeNode = new ExpNode(tokens[currentTokenIndex]);
                match(TokenType.Id);
                break;

            case TokenType.Integer:
                treeNode = new ExpNode(tokens[currentTokenIndex]);
                match(TokenType.Integer);
                break;

            case TokenType.Float:
                treeNode = new ExpNode(tokens[currentTokenIndex]);
                match(TokenType.Float);
                break;

            default:
                throw new InvalidSyntaxException(tokens[currentTokenIndex]);
            }

            return(treeNode);
        }
示例#8
0
 public ExpVisiter(ExpNode root)
 {
     rootParam = new Stack <ParameterExpression>();
     rootParam.Push(Expression.Parameter(typeof(T)));
     this.context  = new MContext(typeof(T));
     this.rootNode = root;
 }
示例#9
0
 /// <summary>
 /// Creates a new negative <see cref="SignOperNode"/> around <paramref name="node"/>.
 /// </summary>
 /// <param name="node">The <see cref="ExpNode"/> to negate.</param>
 /// <returns>A new negative <see cref="SignOperNode"/> around <paramref name="node"/>.</returns>
 public static SignOperNode Negative(ExpNode node)
 {
     return(new SignOperNode(Sign.NEGATIVE)
     {
         Child = node
     });
 }
示例#10
0
        /// <summary>
        /// Creates a new <see cref="PowOperNode"/> as <paramref name="base"/>^<paramref name="exponent"/>.
        /// </summary>
        /// <param name="base">The base of the <see cref="PowOperNode"/>.</param>
        /// <param name="exponent">The exponent of the <see cref="PowOperNode"/>.</param>
        /// <returns>A new <see cref="PowOperNode"/> as <paramref name="base"/>^<paramref name="exponent"/>.</returns>
        public static PowOperNode Pow(ExpNode @base, ExpNode exponent)
        {
            PowOperNode powNode = new();

            powNode.LeftChild  = @base;
            powNode.RightChild = exponent;
            return(powNode);
        }
示例#11
0
        /// <inheritdoc/>
        public override void InsertChild(BranchNode node)
        {
            ExpNode lastChild = Children[ChildCount - 1];

            Children.RemoveAt(ChildCount - 1);
            node.AddChild(lastChild);
            AddChild(node);
        }
示例#12
0
文件: Integrator.cs 项目: Avid29/Calc
        /// <inheritdoc/>
        public override ExpNode Execute(MultiplicationOperNode node)
        {
            // TODO: Sinusoidal u substitutions
            // TODO: Constants recognitions for v
            Differentiator differentiator = new(_variable);

            // \int{u'vwx} = uvwx - \int{uv'wx} - \int{uvw'x} - \int{uvwx'}
            int partCount = node.ChildCount - 1;

            // Get u and du
            ExpNode du = node.GetChild(partCount);
            ExpNode u  = du.Clone().Execute(this);

            // Get dvs and vs
            ExpNode[] dvs = new ExpNode[partCount];
            ExpNode[] vs  = new ExpNode[partCount];
            for (int i = 0; i < partCount; i++)
            {
                vs[i]  = node.GetChild(i);
                dvs[i] = vs[i].Clone().Execute(differentiator);
            }

            AdditionOperNode aNode = new();

            // u*vs
            MultiplicationOperNode mNode = new();

            mNode.AddChild(u.Clone());
            for (int i = 0; i < partCount; i++)
            {
                mNode.AddChild(vs[i].Clone());
            }
            aNode.AddChild(mNode);

            // Combinatoric integrals
            for (int i = 0; i < partCount; i++)
            {
                IntegralOperNode intNode = new();
                mNode            = new MultiplicationOperNode();
                intNode.Variable = new VarValueNode(_variable);
                mNode.AddChild(u.Clone());
                for (int j = 0; j < partCount; j++)
                {
                    if (i == j)
                    {
                        mNode.AddChild(dvs[j].Clone());
                    }
                    else
                    {
                        mNode.AddChild(vs[j].Clone());
                    }
                }
                intNode.AddChild(mNode);
                aNode.AddChild(QuickOpers.Negative(intNode));
            }

            return(aNode);
        }
示例#13
0
        public override void Visit(IBinaryOpToken t)
        {
            ExpNode operand2 = m_nodes.Pop();
            ExpNode operand1 = m_nodes.Pop();

            char op = char.Parse(t.ToString());

            m_nodes.Push(Tables.BinaryOperatorsExpTable[op](operand1, operand2));
        }
示例#14
0
        /// <summary>
        /// Multiplies a tensor by scalars.
        /// </summary>
        /// <param name="node">The <see cref="MultiplicationOperNode"/> to simplify.</param>
        /// <param name="simplifier">The <see cref="Simplifier"/> calling.</param>
        /// <returns>The resuling <see cref="MultiplicationOperNode"/>.</returns>
        public static MultiplicationOperNode MultiplyScalarTensor(MultiplicationOperNode node, Simplifier simplifier)
        {
            TensorNode tensor1 = null;
            int        ti      = -1;

            for (int i = 0; i < node.ChildCount; i++)
            {
                if (i == ti)
                {
                    continue;
                }

                if (node.GetChild(i) is TensorNode tensor2)
                {
                    if (tensor1 != null)
                    {
                        if (i < ti)
                        {
                            TensorNode swap = tensor1;
                            tensor1 = tensor2;
                            tensor2 = swap;
                        }

                        if (!tensor1.CanMatrixMultiply(tensor2))
                        {
                            return((MultiplicationOperNode)simplifier.HandleError(new CannotMultiplyTensors(simplifier, node, $"Tensor nodes of size {tensor1.SizeIdentity} and {tensor2.SizeIdentity} could not be multiplied.")));
                        }
                    }
                    else
                    {
                        tensor1 = tensor2;
                        ti      = i;
                        i       = -1;
                    }
                }
                else
                {
                    if (tensor1 != null)
                    {
                        for (int j = 0; j < tensor1.ChildCount; j++)
                        {
                            ExpNode simpleChild = QuickOpers.Multiply(tensor1.GetChild(j), node.GetChild(i)).Execute(simplifier);
                            tensor1.ReplaceChild(simpleChild, j);
                        }

                        node.RemoveChild(i);
                        if (i < ti)
                        {
                            ti--;
                        }
                        i--;
                    }
                }
            }

            return(node);
        }
示例#15
0
        /// <inheritdoc/>
        public override ExpNode Execute(MultiplicationOperNode node)
        {
            double valueProg = 1;

            for (int i = 0; i < node.ChildCount; i++)
            {
                ExpNode simpleChild = node.GetChild(i).Execute(this);

                if (simpleChild is NumericalValueNode nvNode)
                {
                    valueProg *= nvNode.DoubleValue;
                    node.RemoveChild(i);
                    i--;
                }
                else if (simpleChild is MultiplicationOperNode mNode)
                {
                    mNode.TransferChildren(node);
                    node.RemoveChild(i);
                    i--;
                }
                else
                {
                    node.ReplaceChild(simpleChild, i);
                }
            }

            // Anything multiplied by 0, is zero
            if (valueProg == 0)
            {
                return(QuickOpers.MakeNumericalNode(0));
            }

            if (node.ChildCount == 0 || valueProg != 1)
            {
                node.AddChild(QuickOpers.MakeNumericalNode(valueProg));
            }

            MultiplicationHelpers.SimplfiyMTerms(node, this);

            if (node.ChildCount == 0)
            {
                return(QuickOpers.MakeNumericalNode(0));
            }
            else if (node.ChildCount == 1)
            {
                return(node.GetChild(0));
            }

            node = MultiplicationHelpers.MultiplyScalarTensor(node, this);

            if (node == null)
            {
                return(node);
            }

            return(MultiplicationHelpers.Distribute(node, this));
        }
示例#16
0
文件: ExpTree.cs 项目: Avid29/Calc
 private void FindInsertionNode(ExpNode node)
 {
     while ((_activeNode.Priority != Priority.OVERRIDE) &&
            node.Priority > _activeNode.Priority &&
            !_activeNode.IsRoot)
     {
         _activeNode = _activeNode.Parent;
     }
 }
示例#17
0
        /// <inheritdoc/>
        public override ExpNode Execute(TensorNode node)
        {
            for (int i = 0; i < node.ChildCount; i++)
            {
                ExpNode simpleChild = node.GetChild(i).Execute(this);
                node.ReplaceChild(simpleChild, i);
            }

            return(node);
        }
示例#18
0
文件: ExpTree.cs 项目: Avid29/Calc
        /// <summary>
        /// Adds a <see cref="OperNode"/> to the expression tree.
        /// </summary>
        /// <param name="node">The <see cref="OperNode"/> to add to the expression tree.</param>
        public void AddNode(OperNode node)
        {
            bool insert = !(node is UOperNode);

            if (_activeNode == null)
            {
                // This is the first Branch Node
                if (Root != null)
                {
                    // The first node is often a ValueNode
                    // That is the only time a ValueNode will be the active or root node

                    // Makes node the new active_node
                    node.AddChild(Root);
                }

                Root        = node;
                _activeNode = node;
                return;
            }

            FindInsertionNode(node);

            if (node.Priority > _activeNode.Priority)
            {
                // The new node is a lower priority than any node so far
                // or a parenthesis/function was hit
                // Add new node to top
                if (_activeNode.Priority == Priority.OVERRIDE)
                {
                    InsertOperNode(node, insert);
                }
                else if (Root == _activeNode)
                {
                    // node is new root
                    node.AddChild(Root);
                    Root = node;
                }
            }
            else if (node.Priority == _activeNode.Priority && (node is NOperNode))
            {
                for (int i = 0; i < node.ChildCount; i++)
                {
                    _activeNode.AddChild(node);
                }

                return;
            }
            else
            {
                InsertOperNode(node, insert);
            }

            _activeNode = node;
        }
示例#19
0
        /// <inheritdoc/>
        public override ExpNode Execute(AdditionOperNode node)
        {
            // Sum rule
            for (int i = 0; i < node.ChildCount; i++)
            {
                ExpNode diffChild = node.GetChild(i).Execute(this);
                node.ReplaceChild(diffChild, i);
            }

            return(node);
        }
示例#20
0
        /// <summary>
        /// Checks if two <see cref="TensorNode"/>s are vectors and equal size.
        /// </summary>
        /// <param name="node">The first <see cref="ExpNode"/>.</param>
        /// <param name="other">The second <see cref="ExpNode"/>.</param>
        /// <param name="vector1">The first <see cref="ExpNode"/> as a <see cref="TensorNode"/>.</param>
        /// <param name="vector2">The second <see cref="ExpNode"/> as a <see cref="TensorNode"/>.</param>
        /// <returns>True if two <see cref="TensorNode"/>s are equal size and vectors.</returns>
        public static bool AreEqualSizeVectors(this ExpNode node, ExpNode other, out TensorNode vector1, out TensorNode vector2)
        {
            if (node is TensorNode tensor1 && other is TensorNode tensor2)
            {
                vector1 = tensor1;
                vector2 = tensor2;
                return(AreEqualSizeVectors(tensor1, tensor2));
            }

            vector1 = vector2 = null;
            return(false);
        }
示例#21
0
文件: ExpTree.cs 项目: Avid29/Calc
 /// <summary>
 /// Adds a <see cref="ValueNode"/> to the expression tree.
 /// </summary>
 /// <param name="node">The <see cref="ValueNode"/> to add to the expression tree.</param>
 public void AddNode(ValueNode node)
 {
     if (_activeNode == null)
     {
         // If first node
         Root = node;
     }
     else
     {
         _activeNode.AddChild(node);
     }
 }
示例#22
0
        public override void Visit(IUnaryOpToken t)
        {
            ExpNode operand = m_nodes.Peek();
            char    op      = char.Parse(t.ToString());

            ExpNode unaryOperator = Tables.UnaryOperatorsExpTable[op](operand);

            if (unaryOperator != null)
            {
                m_nodes.Pop();
                m_nodes.Push(unaryOperator);
            }
        }
示例#23
0
        /// <summary>
        /// Initializes a new instance of the <see cref="AdditiveTerm"/> class.
        /// </summary>
        /// <param name="node">The node to create as a term.</param>
        public AdditiveTerm(ExpNode node)
        {
            DefaultPrinter printer = new();

            if (node is MultiplicationOperNode mNode && mNode.GetChild(0) is NumericalValueNode nvNode)
            {
                // Node is a multiply and it's first child is a numerical value
                // That numerical value is the coefficient
                _coefficient = nvNode.DoubleValue;

                // Remove coefficient from base
                mNode.RemoveChild(0);
                _base = mNode;
            }
示例#24
0
        public override void Visit(IFuncNameToken t)
        {
            // Get number of nessessary arguments
            int n = Tables.FunctionsArgsNumberTable[t.ToString()];

            // Pop arguments
            ExpNode[] arguments = new ExpNode[n];
            for (int i = 0; i < n; i++)
            {
                arguments[i] = m_nodes.Pop();
            }

            m_nodes.Push(Tables.FunctionsExpTable[t.ToString()](arguments));
        }
示例#25
0
        private ExpNode parseFact()
        {
            ExpNode   expn = parseExpnt();
            OpExpNode exp  = null;

            while (lex.Peek() == Token.MUL || lex.Peek() == Token.DIV)
            {
                OpExpNode tmp = new OpExpNode();
                tmp.left  = exp == null ? expn : exp;
                tmp.OP    = lex.Take();
                tmp.right = parseExpnt();
                exp       = tmp;
            }
            return(exp == null ? expn : exp);
        }
示例#26
0
文件: ExpTree.cs 项目: Avid29/Calc
 /// <summary>
 /// Adds a <see cref="BranchNode"/> to the expression tree.
 /// </summary>
 /// <param name="node">The <see cref="BranchNode"/> to add to the expression tree.</param>
 public void AddNode(BranchNode node)
 {
     if (node is OperNode oNode)
     {
         AddNode(oNode);
     }
     else if (_activeNode == null)
     {
         Root = node;
     }
     else
     {
         _activeNode.AddChild(node);
     }
 }
示例#27
0
        private ExpNode parseExpnt()
        {
            ExpNode elm = parseElmnt();

            if (lex.Peek() != Token.POW)
            {
                return(elm);
            }
            OpExpNode exp = new OpExpNode();

            exp.left  = elm;
            exp.OP    = lex.Take();
            exp.right = parseExpnt();
            return(exp);
        }
示例#28
0
        /// <inheritdoc/>
        public override void ReplaceChild(ExpNode node, int index)
        {
            switch (index)
            {
            case 0:
                LeftChild = node;
                break;

            case 1:
                RightChild = node;
                break;

            default:
                throw new ArgumentOutOfRangeException($"{nameof(BOperNode)} only contains two (2) children. Zero (0) and one (1) are the only indicies.");
            }
        }
示例#29
0
        /// <summary>
        /// Initializes a new instance of the <see cref="MultiplicativeTerm"/> class.
        /// </summary>
        /// <param name="node">The node to create as a term.</param>
        public MultiplicativeTerm(ExpNode node)
        {
            DefaultPrinter printer = new();

            if (node is PowOperNode powNode)
            {
                _base     = powNode.LeftChild;
                _exponent = powNode.RightChild;
            }
            else
            {
                _base     = node;
                _exponent = QuickOpers.MakeNumericalNode(1);
            }
            _baseString = _base.Print(printer);
        }
示例#30
0
        /// <inheritdoc/>
        public override void AddChild(ExpNode node)
        {
            if (LeftChild == null)
            {
                LeftChild = node;
            }
            else if (RightChild == null)
            {
                RightChild = node;
            }
            else
            {
                throw new BOperNodeAlreadyHasChildrenException(this);
            }

            node.Parent = this;
        }
示例#31
0
        /// <summary>
        /// Adds tensors.
        /// </summary>
        /// <param name="node">The <see cref="AdditionOperNode"/> containing tensors.</param>
        /// <param name="simplifier">The <see cref="Simplifier"/> calling.</param>
        /// <returns>The resuling <see cref="ExpNode"/>.</returns>
        public static ExpNode SumTensors(AdditionOperNode node, Simplifier simplifier)
        {
            if (node.GetChild(0) is TensorNode tensorNode)
            {
                for (int i = 1; i < node.ChildCount; i++)
                {
                    if (node.GetChild(i) is TensorNode otherTensorNode)
                    {
                        if (otherTensorNode.SizeIdentity == tensorNode.SizeIdentity)
                        {
                            for (int j = 0; j < tensorNode.ChildCount; j++)
                            {
                                ExpNode addedNode = QuickOpers
                                                    .Sum(tensorNode.GetChild(j), otherTensorNode.GetChild(j))
                                                    .Execute(simplifier);
                                tensorNode.ReplaceChild(addedNode, j);
                            }
                        }
                        else
                        {
                            return(simplifier.HandleError(new CannotAddTensors(simplifier, node, $"Cannot add tensor of shape {otherTensorNode.SizeIdentity} and tensor of shape {tensorNode.SizeIdentity}.")));
                        }
                    }
                    else
                    {
                        return(simplifier.HandleError(new CannotAddTensors(simplifier, node, "Cannot add scalar and tensor.")));
                    }
                }

                return(tensorNode);
            }
            else
            {
                // There is a scalar.
                // There cannot be any tensors
                for (int i = 1; i < node.ChildCount; i++)
                {
                    if (node.GetChild(i) is TensorNode)
                    {
                        return(simplifier.HandleError(new CannotAddTensors(simplifier, node, "Cannot add tensor and scalar.")));
                    }
                }
            }

            return(node);
        }
        public override string Build(ExpNode node)
        {
            nodeStack = new Stack<ExpNode>();
            document = new XmlDocument();
           // document.AppendChild(document.CreateXmlDeclaration("1.0", Encoding.UTF8.WebName, "yes"));

            this.Visit(null, node, null);
            
            StringBuilder builder = new StringBuilder();

            // settings taken from server
            XmlWriterSettings settings = new XmlWriterSettings();
            settings.Encoding = Encoding.UTF8;
            settings.Indent = true;
            settings.NewLineHandling = NewLineHandling.Entitize;
            XmlWriter writer = XmlWriter.Create(builder, settings);

            writer.WriteProcessingInstruction("xml", "version=\"1.0\" encoding=\"" + Encoding.UTF8.WebName + "\" standalone=\"yes\"");
            document.Save(writer);
            

            return builder.ToString();
        }
示例#33
0
        protected virtual string BuildMemberOrMethodExpression(ExpNode node, ExpNode caller, ExpNode[] arguments, string name)
        {
            string instance = null;
            string args = "";
            string actualName = null;

            if (caller != null)
                instance = this.Visit(node, caller);

            if (name.ToLowerInvariant() == "contains")
            {
                actualName = "contains";
                args = this.Visit(node, arguments[0]);
                return string.Format("{0}({1},{2})", actualName, instance, args);
            }
            else
            {
                actualName = name.ToLowerInvariant();

                if (arguments != null && arguments.Length > 0)
                {
                    for (int i = 0; i < arguments.Length; i++)
                        args += this.Visit(node, arguments[i]) + ", ";

                    args = args.Substring(0, args.Length - 2);

                    if (instance == null)
                        return string.Format("{0}({1})", actualName, args);
                    else
                        return string.Format("{0}({1},{2})", actualName, instance, args);
                }
                else
                    return string.Format("{0}({1})", actualName, instance);
            }
        }
示例#34
0
 public ServiceOperationExpression(ExpNode input, ServiceOperationParameterExpression[] arguments)
     : base(input)
 {
     this.Arguments = arguments;
 }
示例#35
0
 public static MemberBindExpression Bind(this ResourceType resourceType, string LeftHandSide, ExpNode RightHandSide)
 {
     TypedMemberExpression targetProperty = new TypedMemberExpression(resourceType.ClientClrType, resourceType.Properties[LeftHandSide].Name);
     return new MemberBindExpression(RightHandSide, targetProperty);
 }
示例#36
0
        public virtual KeyExpressions GetAllExistingKeys(ExpNode query, ResourceContainer resourceContainer)
        {
            KeyExpressions keys = new KeyExpressions();
            IQueryable objects = this.GetUnderlyingProviderQueryResults(query);
            IEnumerator enumerator = null;
            try
            {
                enumerator = objects.GetEnumerator();
                while (enumerator.MoveNext())
                {
                    Type t = enumerator.Current.GetType();
                    if (AstoriaTestProperties.EdmObjectLayer == ServiceEdmObjectLayer.PocoWithProxy && AstoriaTestProperties.DataLayerProviderKinds.Contains(Astoria.DataLayerProviderKind.Edm))
                        t = t.BaseType;
                    List<ResourceType> types = resourceContainer.ResourceTypes.Where(rt => rt.Name.Equals(t.Name) && rt.Namespace.Equals(t.Namespace)).ToList();

                    ResourceType actualResourceType = types.Single();
                    keys.Add(GetKeyExpression(resourceContainer, actualResourceType, enumerator.Current));
                }
            }
            catch (NullReferenceException exc)
            {
                //TODO: Due to a client bug
            }
            finally
            {
                IDisposable disposable = (enumerator as IDisposable);
                if (null != disposable)
                {
                    disposable.Dispose();
                }
            }
            return keys;
        }
示例#37
0
 public virtual IQueryable GetUnderlyingProviderQueryResults(ExpNode q)
 {
     LinqQueryBuilder linqQueryBuilder = new LinqQueryBuilder(this);
     linqQueryBuilder.Build(q);
     return linqQueryBuilder.QueryResult;
 }
示例#38
0
 //Constructor
 public PredicateExpression(QueryNode input, ExpNode predicate)
     : base(input)
 {
     _predicate = predicate;
     _type = input.Type;
 }
示例#39
0
        public void Expand()
        {
            string sExpand = String.Empty;
            PropertyExpression[] expandValues = new PropertyExpression[1];

            List<ResourceProperty> properties = new List<ResourceProperty>();
            foreach (ResourceProperty property in from.Properties)
            {
                if (property.IsNavigation && from.Properties.Contains(property) &&
                        !(from.Name == "BugDefectTrackingSet" || from.Name == "BugProjectTrackingSet"))
                    properties.Add(property);
            }

            if (properties.Count > 0)
            {
                expandValues[0] = new PropertyExpression(properties[0]);
                sExpand = expandValues[0].ToString();

                if (_query is TopExpression)
                    _query = ((TopExpression)_query).Expand(expandValues) as ExpandExpression;
                else if (_query is OrderByExpression)
                    _query = ((OrderByExpression)_query).Expand(expandValues) as ExpandExpression;
                else if (_query is ScanExpression)
                    _query = ((ScanExpression)_query).Expand(expandValues) as ExpandExpression;
                else if (_query is NavigationExpression)
                    _query = ((NavigationExpression)_query).Expand(expandValues) as ExpandExpression;
                else if (_query is SkipExpression)
                    _query = ((SkipExpression)_query).Expand(expandValues) as ExpandExpression;
                else if (_query is PredicateExpression)
                    _query = ((PredicateExpression)_query).Expand(expandValues) as ExpandExpression;
                else if (_query is CountExpression)
                    _query = ((CountExpression)_query).Expand(expandValues) as ExpandExpression;
                else if (_query is NavigationExpression)
                    _query = ((NavigationExpression)_query).Expand(expandValues) as ExpandExpression;
              
                bExpand = true;
                _action = LastAction.Expand;
                bIsOption = true;
                AstoriaTestLog.WriteLineIgnore(".Expand(" + sExpand + ")");
            }
        }
示例#40
0
        public OrderByExpression(QueryNode input, ExpNode[] properties, QueryNode scannode, bool bAscDesc, bool excludeFromUri)
            : base(input)
        {
            _properties = properties;
            _scannode = scannode;
            _bAscDesc = bAscDesc;
            _excludeFromUri = excludeFromUri;

            if (excludeFromUri)
                _properties = properties.OrderBy(p => p.Name).ToArray();
        }
示例#41
0
 public static OrderByExpression Sort(this QueryNode input, ExpNode[] properties, bool bAscDesc)
 {
     return Sort(input, properties, bAscDesc, false);
 }
示例#42
0
        protected override String Visit(ExpNode caller, ExpNode node)
        {

            if (node is ProjectExpression)
            {
                ProjectExpression e = (ProjectExpression)node;
                if (e.Projections.Count == 0)
                {
                    return String.Format("{0}",
                            this.Visit(e, e.Input)
                            );
                }
                else if (e.Projections.Count == 1)
                {
                    if (e.Projections[0] is PropertyExpression)
                    {
                        return String.Format("{0}/{1}",
                            this.Visit(e, e.Input),
                            this.Visit(e, e.Projections[0])
                            );
                    }
                }
                else
                    throw new Exception("More than 1 projection, invalid");

            }
            else if (node is ServiceOperationExpression)
            {
                AstoriaTestLog.WriteLine("Calling Service Operation");
                ServiceOperationExpression e = (ServiceOperationExpression)node;

                string serviceOp = this.Visit(e, e.Input);
                AstoriaTestLog.WriteLine(serviceOp);
                StringBuilder sbParametersString = new StringBuilder();
                if (!serviceOp.Contains("?"))
                {
                    sbParametersString.Append("?");
                }
                for (int index = 0; index < e.Arguments.Length; index++)
                {
                    ServiceOperationParameterExpression parameter = e.Arguments[index];
                    if (index > 0)
                    {
                        sbParametersString.Append("&");
                    }
                    string strLiteralString = CreateKeyStringValue(parameter.ParameterValue);
                    sbParametersString.AppendFormat("{0}={1}", parameter.ParameterName, strLiteralString);
                }
                return String.Format("{0}{1}", serviceOp, sbParametersString.ToString());
            }
            else if (node is ScanExpression)
            {
                ScanExpression e = (ScanExpression)node;

                if (e.Input is VariableExpression && ((VariableExpression)e.Input).Variable is ResourceContainer)
                    return String.Format("{0}",
                            this.Visit(e, e.Input)
                            );
                throw new Exception("Unsupported on in scan expression");

            }
            else if (node is PredicateExpression)
            {
                PredicateExpression e = (PredicateExpression)node;
                KeyExpression key = e.Predicate as KeyExpression;
                if (key != null)
                {
                    return String.Format("{0}({1})",
                        this.Visit(e, e.Input),
                        this.Visit(e, e.Predicate)
                        );
                }
                else
                    return String.Format("{0}?$filter={1}",
                        this.Visit(e, e.Input),
                        this.Visit(e, e.Predicate)
                        );
            }
            else if (node is CountExpression)
            {
                CountExpression e = (CountExpression)node;
                string sCount = "";
                string visit = "";

                if (!e.IsInline)
                {
                    visit = this.Visit(e, e.Input);
                    sCount = string.Format("{0}/$count", visit);
                }
                else
                {
                    visit = this.Visit(e, e.Input);

                    if (visit.IndexOf("?$") == -1)
                        sCount = string.Format("{0}?$inlinecount={1}", visit, e.CountKind);
                    else
                        sCount = string.Format("{0}&$inlinecount={1}", visit, e.CountKind);
                }
                return sCount;
            }
            else if (node is NewExpression)
            {
                NewExpression e = (NewExpression)node;
                string uri = this.Visit(e, e.Input);
                ExpNode[] pe = new ExpNode[] { };

                List<ExpNode> nodes = new List<ExpNode>();
                foreach (ExpNode parameter in e.Arguments)
                {
                    nodes.Add(parameter as ExpNode);
                }
                pe = nodes.ToArray();
                string _select = String.Format("{0}", this.Visit(e, pe[0]));

                if (nodes.Count > 1)
                {
                    for (int j = 1; j < nodes.Count; j++)
                    {
                        _select = String.Format("{0},{1}", _select, this.Visit(e, pe[j]));
                    }
                }

                if (uri.IndexOf("?$") == -1)
                    return string.Format("{0}?$select={1}", uri, _select);
                else
                    return string.Format("{0}&$select={1}", uri, _select);

            }
            else if (node is MemberBindExpression)
            {
                return this.Visit(node, ((MemberBindExpression)node).SourceProperty);
            }
            else if (node is TopExpression)
            {
                TopExpression e = (TopExpression)node;
                string visit = this.Visit(e, e.Input);

                if (visit.IndexOf("?$") == -1)
                    return string.Format("{0}?$top={1}", visit, e.Predicate);
                else
                    return string.Format("{0}&$top={1}", visit, e.Predicate);
            }
            else if (node is SkipExpression)
            {
                SkipExpression e = (SkipExpression)node;
                string visit = this.Visit(e, e.Input);

                if (visit.IndexOf("?$") == -1)
                    return string.Format("{0}?$skip={1}", visit, e.Predicate);
                else
                    return string.Format("{0}&$skip={1}", visit, e.Predicate);
            }
            else if (node is OrderByExpression)
            {
                OrderByExpression e = (OrderByExpression)node;
                string ordervalue = String.Empty;
                int i = 0;

                string visit = this.Visit(e, e.Input);
                if (e.ExcludeFromUri) { return visit; }

                string propVisit = this.Visit(e, e.PropertiesExp[0]);

                switch (e.AscDesc)
                {
                    case true:
                        if (visit.IndexOf("?$") == -1)
                            ordervalue = String.Format("{0}?$orderby={1}", visit, propVisit);
                        else
                            ordervalue = String.Format("{0}&$orderby={1}", visit, propVisit);
                        break;
                    case false:
                        if (visit.IndexOf("?$") == -1)
                            ordervalue = String.Format("{0}?$orderby={1} desc", visit, propVisit);
                        else
                            ordervalue = String.Format("{0}&$orderby={1} desc", visit, propVisit);
                        break;
                };

                if (e.PropertiesExp.Length > 0)
                {
                    for (i++; i < e.PropertiesExp.Length; i++)
                    {
                        String nextValue = this.Visit(e, e.PropertiesExp[i]);
                        nextValue = String.Format("{0}", nextValue);

                        switch (e.AscDesc)
                        {
                            case true:
                                ordervalue = String.Format("{0},{1}", ordervalue, nextValue);
                                break;
                            case false:
                                ordervalue = String.Format("{0},{1} desc", ordervalue, nextValue);
                                break;
                        }
                    }
                }
                return ordervalue;
            }
            else if (node is ThenByExpression)
            {
                ThenByExpression e = (ThenByExpression)node;
                string ordervalue = String.Empty;
                int i = 0;

                string visit = this.Visit(e, e.Input);
                if (e.ExcludeFromUri) { return visit; }

                switch (e.AscDesc)
                {
                    case true:
                        ordervalue = String.Format("{0},{1}", visit, e.Properties[0].Name);
                        break;
                    case false:
                        ordervalue = String.Format("{0},{1} desc", visit, e.Properties[0].Name);
                        break;
                }

                if (e.Properties.Length > 0)
                {
                    for (i++; i < e.Properties.Length; i++)
                    {
                        String nextValue = e.Properties[i].Name;
                        nextValue = String.Format("{0}", nextValue);

                        switch (e.AscDesc)
                        {
                            case true:
                                ordervalue = String.Format("{0},{1}", ordervalue, nextValue);
                                break;
                            case false:
                                ordervalue = String.Format("{0},{1} desc", ordervalue, nextValue);
                                break;
                        }
                    }
                }
                return ordervalue;
            }
            else if (node is ExpandExpression)
            {
                ExpandExpression e = (ExpandExpression)node;
                string uri = this.Visit(e, e.Input);

                string expand = String.Format("{0}", this.Visit(e, e.PropertiesExp[0]));

                if (e.Properties.Length > 1)
                    for (int i = 1; i < e.Properties.Length; i++)
                        expand = String.Format("{0},{1}", expand, this.Visit(e, e.PropertiesExp[i]));

                if (uri.IndexOf("?$") == -1)
                    return string.Format("{0}?$expand={1}", uri, expand);
                else
                    return string.Format("{0}&$expand={1}", uri, expand);

            }
            else if (node is NavigationExpression)
            {
                NavigationExpression e = (NavigationExpression)node;
                if (!e.IsLink)
                    return String.Format("{0}/{1}", this.Visit(e, e.Input), this.Visit(e, e.PropertyExp));
                else
                    return String.Format("{0}/{1}/$ref", this.Visit(e, e.Input), this.Visit(e, e.PropertyExp));
            }
            else if (node is KeyExpression)
            {
                KeyExpression key = node as KeyExpression;
                return CreateKeyString(key);
            }
            else if (node is NestedPropertyExpression)
            {
                NestedPropertyExpression e = (NestedPropertyExpression)node;
                string enitySetname = e.Name;
                string nestedProperty = "";

                foreach (PropertyExpression p in e.PropertyExpressions)
                {
                    string interim = this.Visit(e, p);
                    //AstoriaTestLog.WriteLine(interim); 
                    if (p.ValueOnly)
                        nestedProperty = String.Format("{0}/{1}/{2},", nestedProperty, enitySetname, interim + "/$value").TrimStart('/');
                    else
                        nestedProperty = String.Format("{0}/{1}/{2},", nestedProperty, enitySetname, interim).TrimStart('/');

                }

                return nestedProperty.TrimEnd(',').Replace(",/", ",");
            }
            else if (node is PropertyExpression)
            {
                PropertyExpression e = (PropertyExpression)node;
                if (e.ValueOnly)
                    return e.Property.Name + "/$value";
                else
                    return e.Property.Name;
            }
            else if (node is VariableExpression)
            {
                VariableExpression e = (VariableExpression)node;
                return e.Variable.Name;
            }
            if (node is LogicalExpression)
            {
                LogicalExpression e = (LogicalExpression)node;
                string left = this.Visit(e, e.Left);
                string right = null;

                if (e.Operator != LogicalOperator.Not)
                {
                    right = this.Visit(e, e.Right);
                }

                string logical;
                switch (e.Operator)
                {
                    case LogicalOperator.And:
                        logical = string.Format("{0} and {1}", left, right);
                        break;
                    case LogicalOperator.Or:
                        logical = string.Format("{0} or {1}", left, right);
                        break;
                    case LogicalOperator.Not:
                        logical = string.Format("not {0}", left);
                        break;

                    default:
                        throw new Exception("Unhandled Comparison Type: " + e.Operator);
                }
                return logical;
            }
            else if (node is ComparisonExpression)
            {
                ComparisonExpression e = (ComparisonExpression)node;
                String left = this.Visit(e, e.Left);
                String right = this.Visit(e, e.Right);

                switch (e.Operator)
                {
                    case ComparisonOperator.Equal:
                        return String.Format("{0} eq {1}", left, right);

                    case ComparisonOperator.NotEqual:
                        return String.Format("{0} ne {1}", left, right);

                    case ComparisonOperator.GreaterThan:
                        return String.Format("{0} gt {1}", left, right);

                    case ComparisonOperator.GreaterThanOrEqual:
                        return String.Format("{0} ge {1}", left, right);

                    case ComparisonOperator.LessThan:
                        return String.Format("{0} lt {1}", left, right);

                    case ComparisonOperator.LessThanOrEqual:
                        return String.Format("{0} le {1}", left, right);

                    default:
                        throw new Exception("Unhandled Comparison Type: " + e.Operator);
                };
            }
            else if (node is IsOfExpression || node is CastExpression)
            {
                ExpNode target;
                NodeType targetType;
                string operation;
                if (node is IsOfExpression)
                {
                    IsOfExpression e = (IsOfExpression)node;
                    operation = "isof";
                    target = e.Target;
                    targetType = e.TargetType;
                }
                else
                {
                    CastExpression e = (CastExpression)node;
                    operation = "cast";
                    target = e.Target;
                    targetType = e.TargetType;
                }

                string targetTypeName = targetType.FullName;
                if (targetType is PrimitiveType)
                {
                    targetTypeName = TypeData.FindForType(targetType.ClrType).GetEdmTypeName();
                }

                if (target == null)
                {
                    return String.Format("{0}('{1}')", operation, targetTypeName);
                }
                else
                {
                    return String.Format("{0}({1}, '{2}')", operation, this.Visit(node, target), targetTypeName);
                }
            }
            else if (node is ArithmeticExpression)
            {
                ArithmeticExpression e = (ArithmeticExpression)node;
                String left = this.Visit(e, e.Left);
                String right = this.Visit(e, e.Right);

                switch (e.Operator)
                {
                    case ArithmeticOperator.Add:
                        return String.Format("{0} add {1}", left, right);

                    case ArithmeticOperator.Div:
                        return String.Format("{0} div {1}", left, right);

                    case ArithmeticOperator.Mod:
                        return String.Format("{0} mod {1}", left, right);

                    case ArithmeticOperator.Mult:
                        return String.Format("{0} mul {1}", left, right);

                    case ArithmeticOperator.Sub:
                        return String.Format("{0} sub {1}", left, right);

                    default:
                        throw new Exception("Unhandled Arithmetic Type: " + e.Operator);
                };
            }
            else if (node is MethodExpression)
            {
                MethodExpression e = (MethodExpression)node;
                return BuildMemberOrMethodExpression(node, e.Caller, e.Arguments, e.Name);
            }
            else if (node is MemberExpression)
            {
                MemberExpression e = (MemberExpression)node;
                return BuildMemberOrMethodExpression(node, e.Caller, e.Arguments, e.Name);
            }
            else if (node is ConstantExpression)
            {
                ConstantExpression e = (ConstantExpression)node;
                object value = e.Value.ClrValue;

                string val = TypeData.FormatForKey(value, this.UseSmallCasing, false);
                if (this.EscapeUriValues)
                {
                    // FormatForKey already does this for doubles that don't have the D
                    if (!(value is double) || Versioning.Server.SupportsV2Features)
                        val = Uri.EscapeDataString(val);
                }

                if (value == null)
                    val = "null";
                else if (!(value is String))
                {
                    val = val.Replace("+", "").Replace("%2B", "");
                }

                return val;
            }
            else if (node is NegateExpression)
            {
                NegateExpression e = (NegateExpression)node;
                return "-(" + this.Visit(e, e.Argument) + ")";
            }
            else if (node is FirstExpression)
            {
                FirstExpression first = node as FirstExpression;
                return this.Visit(first, first.Input);
            }
            else if (node is FirstOrDefaultExpression)
            {
                FirstOrDefaultExpression first = node as FirstOrDefaultExpression;
                return this.Visit(first, first.Input);
            }
            else if (node is SingleExpression)
            {
                SingleExpression first = node as SingleExpression;
                return this.Visit(first, first.Input);
            }
            else if (node is SingleOrDefaultExpression)
            {
                SingleOrDefaultExpression first = node as SingleOrDefaultExpression;
                return this.Visit(first, first.Input);
            }
            else
            {
                throw new Exception(this.GetType().Name + " Unhandled Node: " + node.GetType().Name);
            }
        }
        protected void Visit(ExpNode caller, ExpNode node, XmlElement parentNode)
        {
            nodeStack.Push(node);
            if (node == null)
            {
                throw new ArgumentNullException("node");
            }

            if (node is KeyedResourceInstance && (!(node is AssociationResourceInstance)))
            {
                KeyedResourceInstance e = (KeyedResourceInstance)node;
                CreateEntryElement(e, parentNode);
            }
            else if (node is AssociationResourceInstance)
            {
                AssociationResourceInstance e = (AssociationResourceInstance)node;
                if (caller == null)
                    CreateLinkPayload(e, parentNode);
                else
                    CreateBinding(e, parentNode);
            }
            //Below are two special cases
            else if (caller == null && node is ResourceInstanceSimpleProperty)
            {
                this.VisitResourceInstanceSimpleProperty(node as ResourceInstanceSimpleProperty, parentNode);
            }
            else if (caller == null && node is ResourceInstanceComplexProperty)
            {
                this.VisitResourceInstanceComplexProperty(node as ResourceInstanceComplexProperty, parentNode);
            }
            else if (caller == null && node is ResourceInstanceNavRefProperty)
            {
                ResourceInstanceNavRefProperty navRef = node as ResourceInstanceNavRefProperty;
                AssociationResourceInstance associationResourceInstance = navRef.TreeNode as AssociationResourceInstance;
                if (associationResourceInstance != null && associationResourceInstance.Operation == AssociationOperation.Remove)
                {
                    this.CreateUnBinding(parentNode);
                }
                else
                    throw new Exception("Unknown node type:" + navRef.TreeNode.GetType());
            }
            else if (caller == null && node is ResourceInstanceCollection)
            {
                ResourceInstanceCollection collection = node as ResourceInstanceCollection;
                CreateLinksElement(collection, null);

            }
            else
            {
                throw new Exception("Unknown node type: " + node.GetType());
            }
            nodeStack.Pop();
        }
示例#44
0
        public AstoriaRequest CreateRequest(ExpNode query, ResourceBodyTree updateTree, RequestVerb operation)
        {
            AstoriaRequest request = new AstoriaRequest(this);
            request.Verb = operation;
            request.Query = query as QueryNode;
            request.UpdateTree = updateTree;

            PrepareRequest(request);

            return request;
        }
示例#45
0
 public abstract string Build(ExpNode node);
示例#46
0
 public override string Build(ExpNode node)
 {
     string serviceName;
     string queryUri = base.Build(node);
     return this.Workspace.ServiceUri + "/" + queryUri;
 }
示例#47
0
        public virtual void DirectedTests()
        {
            QueryModel model = new QueryModel(_workspace, SerializationFormatKind.Atom, null);
            ModelEngine engine = new ModelEngine(model);

            engine.Options.WeightScheme = WeightScheme.Custom;
            engine.Options.Timeout = 100;

            engine.RunUntil(delegate()
            {
                return engine.Models.Actions.AllCovered;
            });

            //engine.RunScenario(model.Actions.Find("From", "Where", " Navigation","Select","Expand"));
            //engine.RunUntil(delegate()
            //{
            //    return model.Actions.Accessed > 4;
            //});

             _query = model.QueryResult;
            _container = model.ResContainer;
            _pType = model.ResultType;

            if (_query != null || _pType != null)
            {
                VerifyClient(model);
            }
        }
示例#48
0
 public AstoriaRequest CreateRequest(ExpNode query)
 {
     return this.CreateRequest(query, null, RequestVerb.Get);
 }
示例#49
0
 public static PredicateExpression Where(this QueryNode input, ExpNode predicate)
 {
     return new PredicateExpression(input, predicate);
 }
示例#50
0
        public void VerifyServer(ExpNode q)
        {
            AstoriaTestLog.WriteLineIgnore("Verify server query");
            try
            {

                UriQueryBuilder ub = new UriQueryBuilder(_workspace, "");
                string ruri = ub.Build(q);
                AstoriaTestLog.WriteLineIgnore(ruri);


                AstoriaRequest request = _workspace.CreateRequest(q);
                request.Format = _kind;

                if (request.URI.Length > 260) { return; }

                AstoriaResponse response = request.GetResponse();
                response.Verify();
            }
            catch (Exception e)
            {
                AstoriaTestLog.WriteLineIgnore(e.ToString());
            }

        }
示例#51
0
 public MemberBindExpression(ExpNode sourceProperty, TypedMemberExpression targetProperty)
     : base("MemberBindExpression")
 {
     SourceProperty = sourceProperty;
     TargetProperty = targetProperty;
     //SourceProperty = new PropertyExpression( 
 }
示例#52
0
 public static void Verify(Workspace w, ExpNode q, IEnumerable results, ResourceType resType)
 {
     Verify(w, q, results, resType, null, false);
 }
示例#53
0
        //Data

        //Constructor
        public ScanExpression(ExpNode input)
            : base(input)
        {
            _type = input.Type;
        }
示例#54
0
        public static void Verify(Workspace w, ExpNode q, IEnumerable results, ResourceType resType, ComplexType cType, bool bCount)
        {
            long count = 0;
            if (bCount)
            {

                object[] args = new object[] { results };
                Type qorType = typeof(QueryOperationResponseWrapper<>).MakeGenericType(resType.ClientClrType);
                object qor = Activator.CreateInstance(qorType, args);

                PropertyInfo pi = qor.GetType().GetProperty("GetTotalCount");
                object i = pi.GetValue(qor, new object[] { });

                count = (long)i;

                LinqQueryBuilder lb = new LinqQueryBuilder(w);
                lb.CountingMode = true;
                lb.Build(q);

                object baselineElementsCount = CommonPayload.CreateList(lb.QueryResult).Count;
                AstoriaTestLog.IsTrue(count == Convert.ToInt64(baselineElementsCount), "Count is different.Count is " + count.ToString() + ". Baseline count is " + baselineElementsCount.ToString());
            }

            LinqQueryBuilder linqBuilder = new LinqQueryBuilder(w);
            linqBuilder.Build(q);

            IQueryable baselines = linqBuilder.QueryResult;

            IEnumerator b = null;

            IEnumerator r = null;

            try
            {
                b = TrustedMethods.IQueryableGetEnumerator(baselines);
                r = results.GetEnumerator();
            }
            catch (InvalidOperationException invalidOperation)
            {
                if (!AstoriaTestProperties.IsRemoteClient)
                    throw invalidOperation;
            }

            PropertyInfo propertyInfo = null;
            Object expectedResult1 = null;
            Object expectedResult2 = null;

            try
            {
                while (b.MoveNext() && r.MoveNext())
                {
                    if (b.Current == null)
                    {
                        return;
                    }

                    if (r.Current == null)
                    {
                        throw new TestFailedException("Less results than expected");

                    }
                    //skip verification for Binary data type for Linq to Sql
                    if (AstoriaTestProperties.DataLayerProviderKinds[0] == DataLayerProviderKind.LinqToSql && b.Current is System.Byte[])
                        return;

                    if (b.Current is System.Byte[])
                    {
                        byte[] newBase = (byte[])b.Current;
                        byte[] newAct = (byte[])r.Current;

                        if (newBase.Length != newAct.Length)
                            throw new TestFailedException("Failed to compare the results!");
                    }
#if !ClientSKUFramework

                    else if (b.Current is System.Data.Linq.Binary)
                    {
                        System.Data.Linq.Binary newBase = (System.Data.Linq.Binary)b.Current;
                        System.Data.Linq.Binary newAct = new System.Data.Linq.Binary((byte[])r.Current);

                        if (newBase.Length != newAct.Length)
                            throw new TestFailedException("Failed to compare the results!");

                    }
#endif

                    else if (b.Current is System.Xml.Linq.XElement)
                    {
                        if (b.Current.ToString() != r.Current.ToString())
                            throw new TestFailedException("Failed to compare the results!");
                    }
                    else
                    {
                        if (!b.Current.Equals(r.Current))
                        {
                            if (cType != null)
                            {
                                foreach (ResourceProperty property in cType.Properties)
                                {
                                    if (!property.IsNavigation && !property.IsComplexType && !(property.Type is CollectionType))
                                    {
                                        propertyInfo = b.Current.GetType().GetProperty(property.Name);
                                        expectedResult1 = propertyInfo.GetValue(b.Current, null);

                                        PropertyInfo propertyInfo2 = r.Current.GetType().GetProperty(property.Name);
                                        expectedResult2 = propertyInfo2.GetValue(r.Current, null);

                                        if (expectedResult1 != expectedResult2)
                                        {
                                            if (expectedResult1 is System.Xml.Linq.XElement)
                                            {
                                                expectedResult1 = ((System.Xml.Linq.XElement)expectedResult1).ToString(System.Xml.Linq.SaveOptions.None);
                                            }
                                            if (expectedResult2 is System.Xml.Linq.XElement)
                                            {
                                                expectedResult2 = ((System.Xml.Linq.XElement)expectedResult2).ToString(System.Xml.Linq.SaveOptions.None);
                                            }
					    #if !ClientSKUFramework

                                            if (expectedResult1 is byte[])
                                            {
                                                expectedResult1 = new System.Data.Linq.Binary((byte[])expectedResult1);
                                            }

                                            if (expectedResult2 is byte[])
                                            {
                                                expectedResult2 = new System.Data.Linq.Binary((byte[])expectedResult2);
                                            }
					    #endif


                                            AstoriaTestLog.AreEqual(expectedResult1, expectedResult2, String.Format("Resource value for {0} does not match", property.Name), false);
                                        }
                                    }
                                }
                            }
                            else
                            {
                                foreach (ResourceProperty property in resType.Properties)
                                {
                                    if (!property.IsNavigation && !property.IsComplexType && !(property.Type is CollectionType))
                                    {
                                        //skip verification for Binary data type for Linq to Sql
                                        if (AstoriaTestProperties.DataLayerProviderKinds[0] == DataLayerProviderKind.LinqToSql && property.Type.Name == "LinqToSqlBinary")
                                            return;

                                        propertyInfo = b.Current.GetType().GetProperty(property.Name);
                                        expectedResult1 = propertyInfo.GetValue(b.Current, null);

                                        PropertyInfo propertyinfo2 = r.Current.GetType().GetProperty(property.Name);
                                        expectedResult2 = propertyinfo2.GetValue(r.Current, null);

                                        if (expectedResult1 != expectedResult2)
                                        {
                                            if (expectedResult1 is System.Xml.Linq.XElement)
                                            {
                                                expectedResult1 = ((System.Xml.Linq.XElement)expectedResult1).ToString(System.Xml.Linq.SaveOptions.None);
                                            }

                                            if (expectedResult2 is System.Xml.Linq.XElement)
                                            {
                                                expectedResult2 = ((System.Xml.Linq.XElement)expectedResult2).ToString(System.Xml.Linq.SaveOptions.None);
                                            }
					    #if !ClientSKUFramework
                                            if (expectedResult1 is byte[])
                                            {
                                                expectedResult1 = new System.Data.Linq.Binary((byte[])expectedResult1);
                                            }

                                            if (expectedResult2 is byte[])
                                            {
                                                expectedResult2 = new System.Data.Linq.Binary((byte[])expectedResult2);
                                            }
					    #endif
                                            AstoriaTestLog.AreEqual(expectedResult1, expectedResult2, String.Format("Resource value for {0} does not match", property.Name), false);
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
            catch (Exception e)
            {
                AstoriaTestLog.WriteLine(e.ToString());
                throw;
            }
        }
示例#55
0
 public OrderByExpression(QueryNode input, ExpNode[] properties, QueryNode scannode, bool bAscDesc)
     : this(input, properties, scannode, bAscDesc, false)
 {
 }
示例#56
0
 public static void ExecuteLinq(Workspace workspace, ExpNode q, ResourceContainer container)
 {
     try
     {
         ExecuteLinq(workspace, q, container, false, null);
     }
     catch (Exception e)
     {
         AstoriaTestLog.FailAndContinue(e);
     }
 }
示例#57
0
 //Constructor
 public NewExpression(ExpNode input, params ExpNode[] arguments)
     : base(input)
 {
     _target = input;
     _arguments = new Nodes<ExpNode>(this, arguments);
     //_type = target.Type;
 }
示例#58
0
        public static void ExecuteLinq(Workspace workspace, ExpNode q, ResourceContainer container, bool bSingle, ExpNode altq)
        {

            System.Uri uri = new Uri(workspace.ServiceUri);

            WebDataCtxWrapper ctx = new WebDataCtxWrapper(uri);
            ctx.Credentials = System.Net.CredentialCache.DefaultNetworkCredentials;
            ctx.MergeOption = MergeOption.NoTracking;

            Type resType = container.BaseType.ClientClrType;
            ResolveClientType(workspace, ctx, resType);

            Type cType = typeof(WebDataCtxWrapper);
            MethodInfo mi = cType.GetMethod("CreateQuery", new Type[] { typeof(string) });

            Type pType = container.BaseType.ClientClrType;
            MethodInfo miConstructed = mi.MakeGenericMethod(pType);

            string uri2 = container.Name;
            AstoriaTestLog.WriteLineIgnore(workspace.ServiceUri + "/" + uri2);

            object[] args = { uri2 };
            object query = miConstructed.Invoke(ctx, args);

            LinqQueryBuilder lb = new LinqQueryBuilder(workspace, (IQueryable)query);
            string uri3 = lb.Build(q);
            AstoriaTestLog.WriteLineIgnore("Linq expression: " + lb.QueryExpression);

            //if (bSingle)
            //{
            //    var single = lb.QueryResultSingle;
            //    VerifyLinqSingle(workspace, altq, single, container);
            //}
            //else
            //{
            var queryable = lb.QueryResult;
            VerifyLinq(workspace, q, (IQueryable)queryable);
            //}

        }
示例#59
0
 public static OrderByExpression Sort(this QueryNode input, ExpNode[] properties, bool bAscDesc, bool excludeFromUri)
 {
     QueryNode scaninput = input;
     while (!(scaninput is ScanExpression) && !(scaninput is PredicateExpression) && !(scaninput is NavigationExpression))
     {
         scaninput = scaninput.Input as QueryNode;
     }
     if (input is ScanExpression || input is PredicateExpression || input is NavigationExpression)
         return new OrderByExpression(input, properties, input, bAscDesc, excludeFromUri);
     else
         return new OrderByExpression(input, properties, scaninput, bAscDesc, excludeFromUri);
 }
示例#60
0
        public static void VerifyLinq(Workspace workspace, ExpNode q, IQueryable results)
        {
            //verify if the results are ok before building the URI
            System.Collections.ArrayList list = new System.Collections.ArrayList();
            foreach (object element in results)
                list.Add(element);


            //UriQueryBuilder ub = new UriQueryBuilder(workspace, "");
            // string ruri = ub.Build(q);

            //System.Uri uri = new Uri(workspace.ServiceUri);
            // string uriRel = ruri.Substring(ruri.IndexOf("/") + 1);
            // AstoriaTestLog.WriteLineIgnore(uri.ToString() + uriRel);

            AstoriaRequest request = workspace.CreateRequest(q);
            request.Format = SerializationFormatKind.Atom;

            try
            {
                AstoriaResponse response = request.GetResponse();
                //response.VerifyHttpStatusCodeOk(response.StatusCode);

                CommonPayload payload = response.CommonPayload;
                if (payload.Value != null)
                    payload.CompareValue(results, false, false);
                else
                    payload.Compare(results);

                //AstoriaTestLog.AreEqual(response.ContentType, SerializationFormatKinds.ContentTypeFromKind(response.OriginalRequest.SerializationKind),
                //"Content-Type does not match Accept header request");
            }
            catch (Exception e)
            {
                AstoriaTestLog.FailAndContinue(e);
            }
        }