Exemplo n.º 1
0
        public static GraphCompareResults Compare(ObjectGraph root1, ObjectGraph root2, List <Object> Ignores)
        {
            // Do the comparison here //
            List <IGraphNode> nodes1 = root1.Decendants;
            List <IGraphNode> nodes2 = root2.Decendants;

            GraphCompareResults compareResults = new GraphCompareResults();

            ObjectGraph       compareResultGraph = root1.Clone();
            List <IGraphNode> resultTreeNodes    = compareResultGraph.Decendants;

            if (nodes1.Count != nodes2.Count)
            {
                CompareError error = new CompareError((ObjectGraph)nodes1[0], (ObjectGraph)nodes2[0], new Exception("Number of nodes do not match"));
                resultTreeNodes[0].SetValue(ObjectGraphComparer.CompareErrorProperty, error);
                compareResults.Errors.Add(error);
            }

            for (int i = 0; i < nodes1.Count; i++)
            {
                ObjectGraph node1 = (ObjectGraph)nodes1[i];

                var nodelist = from node in nodes2
                               where node1.QualifiedName.Equals(node.QualifiedName)
                               select node;

                List <IGraphNode> matchingNodes = nodelist.ToList <IGraphNode>();
                if (matchingNodes.Count == 0)
                {
                    CompareError error = new CompareError(node1, null, new Exception("Node not present in second tree"));
                    compareResults.Errors.Add(error);
                    resultTreeNodes[i].SetValue(ObjectGraphComparer.CompareErrorProperty, error);
                    continue;
                }
                if (matchingNodes.Count > 1)
                {
                    CompareError error = new CompareError(node1, null, new Exception("more than one match for this node in second tree"));
                    compareResults.Errors.Add(error);
                    resultTreeNodes[i].SetValue(ObjectGraphComparer.CompareErrorProperty, error);
                    continue;
                }

                ObjectGraph node2 = (ObjectGraph)matchingNodes[0];

                CompareError error1 = ObjectGraphComparer.CompareNodes(node1, node2);
                if (error1 != null)
                {
                    compareResults.Errors.Add(error1);
                    resultTreeNodes[i].SetValue(ObjectGraphComparer.CompareErrorProperty, error1);
                }
            }

            compareResults.Passed      = compareResults.Errors.Count == 0 ? true : false;
            compareResults.ResultGraph = compareResultGraph;
            return(compareResults);
        }
Exemplo n.º 2
0
        private static CompareError CompareNodes(ObjectGraph node1, ObjectGraph node2)
        {
            // Compare two nodes - just the nodes //
            // - compare the property name
            // - compare the property value
            object oMode = node1.GetValue(ObjectGraphComparer.CompareModeProperty);

            if (oMode == null)
            {
                oMode = CompareMode.PropertyNameAndValue;
            }

            CompareMode mode = (CompareMode)oMode;

            // default is compare name and value //

            if (mode == CompareMode.PropertyNameAndValue || mode == CompareMode.PropertyName)
            {
                // comapre name //
                if (!node1.Name.Equals(node2.Name))
                {
                    CompareError error = new CompareError(node1, node2, new Exception("Node names do not match"));
                    return(error);
                }
            }

            if (mode == CompareMode.PropertyNameAndValue || mode == CompareMode.PropertyValue)
            {
                // compare values - only compare if they are primitive types, if it is a complex
                // type, its properties will be child nodes in the metadata graph


                if (node1.DataType.IsPrimitive)
                {
                    ValueType value1 = node1.Data as ValueType;
                    ValueType value2 = node2.Data as ValueType;
                    // Need special handling for double and float as well as strings //
                    if (!ObjectGraphComparer.ComparePrimitive(value1, value2))
                    {
                        CompareError error = new CompareError(node1, node2, new Exception("Node values do not match"));
                        return(error);
                    }
                    return(null);
                }

                // string is not a primitive type //
                if (node1.DataType == typeof(String))
                { // for string case //
                    if (node1.Data == null && node2.Data == null)
                    {
                        return(null);
                    }

                    if (node1.Data == null || node2.Data == null)
                    {
                        CompareError error = new CompareError(node1, node2, new Exception("Node values do not match"));
                        return(error);
                    }

                    if (!node1.Data.Equals(node2.Data))
                    {
                        CompareError error = new CompareError(node1, node2, new Exception("Node values do not match"));
                        return(error);
                    }
                }
            }

            return(null);
        }