public override void Build(QueryTreeInfo queryTreeInfo) { switch (queryTreeInfo.queryComponent) { case QueryComponent.Top: { queryTreeInfo.queryNodeTree = queryTreeInfo.rootQueryNodeTree.Top(takeSkipValue); break; } case QueryComponent.Skip: { queryTreeInfo.queryNodeTree = queryTreeInfo.rootQueryNodeTree.Skip(takeSkipValue); break; } case QueryComponent.OrderBy: { //ORDERBY List <PropertyExpression> keyProperties = new List <PropertyExpression>(); ResourceType resourceType = queryTreeInfo.resourceContainer.BaseType; PropertyExpression[] propValues = resourceType.Key.Properties.Select(p => p.Property()).ToArray(); queryTreeInfo.queryNodeTree = queryTreeInfo.rootQueryNodeTree.Sort(propValues, true); queryTreeInfo.queryComponent = QueryComponent.OrderBy; break; } default: { break; } } }
public override void Build(QueryTreeInfo queryTreeInfo) { switch (queryTreeInfo.queryComponent) { case QueryComponent.Top: { queryTreeInfo.queryNodeTree = queryTreeInfo.rootQueryNodeTree.Top(takeSkipValue); break; } case QueryComponent.Skip: { queryTreeInfo.queryNodeTree = queryTreeInfo.rootQueryNodeTree.Skip(takeSkipValue); break; } case QueryComponent.OrderBy: { //ORDERBY List<PropertyExpression> keyProperties = new List<PropertyExpression>(); ResourceType resourceType = queryTreeInfo.resourceContainer.BaseType; PropertyExpression[] propValues = resourceType.Key.Properties.Select(p => p.Property()).ToArray(); queryTreeInfo.queryNodeTree = queryTreeInfo.rootQueryNodeTree.Sort(propValues, true); queryTreeInfo.queryComponent = QueryComponent.OrderBy; break; } default: { break; } } }
protected override bool VerifyLambda(QueryTreeInfo queryTreeInfo) { List <String> outVal = null; bool result = nodeValues.TryGetValue("Where", out outVal); //Check for the where key values for (int i = 0; i < refKeys.Count; i++) { bool valuePresent = false; foreach (String s in outVal) { if (s.Contains("element." + refKeys[i].Name)) { valuePresent = true; } } if (!valuePresent) { //RefKey not found in the list AstoriaTestLog.WriteLine("RefKey not found in the list"); return(false); } } return(true); }
public virtual bool Compare(QueryTreeInfo queryTreeInfo) { bool result = false; result = VerifyNodes(queryTreeInfo); result = VerifyMetaData(queryTreeInfo); result = VerifyLambda(queryTreeInfo); return result; }
public override void Build(QueryTreeInfo queryTreeInfo) { List<ResourceType> resourceTypes = queryTreeInfo.resourceContainer.ResourceTypes.ToList(); List<ResourceProperty> validProperties = resourceTypes .SelectMany(rt => rt.Properties.OfType<ResourceProperty>()) .ToList(); queryTreeInfo.queryNodeTree = queryTreeInfo.rootQueryNodeTree.New(validProperties[0].Property()); }
public virtual bool Compare(QueryTreeInfo queryTreeInfo) { bool result = false; result = VerifyNodes(queryTreeInfo); result = VerifyMetaData(queryTreeInfo); result = VerifyLambda(queryTreeInfo); return(result); }
protected override bool VerifyNodes(QueryTreeInfo queryTreeInfo) { //Find the list of keys for this resource set that will appear as where nodes in the tree foreach (ResourceType type in queryTreeInfo.resourceContainer.ResourceTypes) { foreach (ResourceProperty property in type.Properties.OfType<ResourceProperty>()) { if (property.PrimaryKey != null) { refKeys.Add(property); AstoriaTestLog.WriteLine(property.Name); } } } return true; }
protected override bool VerifyLambda(QueryTreeInfo queryTreeInfo) { XmlDocument currentTreeXml = queryTreeInfo.currentTreeXml; XmlNodeList projectedNodes = null; // Find the nodes that contain the projected properties if (queryTreeInfo.wkspc.DataLayerProviderKind == DataLayerProviderKind.Edm) { projectedNodes = currentTreeXml.SelectNodes("/Call/Arguments/Quote/Lambda/Body/MemberInit/MemberAssignment"); } else if (queryTreeInfo.wkspc.DataLayerProviderKind == DataLayerProviderKind.InMemoryLinq) { projectedNodes = currentTreeXml.SelectNodes("/Call/Arguments/Quote/Lambda/Body/Conditional/False/MemberInit/MemberAssignment"); } if (projectedNodes.Count == 0) { AstoriaTestLog.WriteLine("Projected nodes not found"); return false; } // Verify all the projected properties in the node foreach (XmlNode node in projectedNodes) { if (node.Attributes[0].Value == "PropertyNameList") { List<String> projectedProps = node.SelectSingleNode("./Constant").InnerText.Split(new char[] { ',' }).ToList(); if (projectedProps.Count != refKeys.Count) { AstoriaTestLog.WriteLine("Projected props count does not match refkeys"); return false; } foreach (ResourceProperty rp in refKeys) { if (!projectedProps.Contains(rp.Name)) { AstoriaTestLog.WriteLine("Projected props is not a refkey"); return false; } } } } return true; }
//Get the expression tree public static String ProcessExpressionTree(Workspace w, QueryTreeInfo queryTreeInfo) { // Retrieve expression tree. AstoriaResponse rs; RequestUtil.GetAndVerifyStatusCode(w, w.ServiceUri + "/ExpToXml", HttpStatusCode.OK, out rs); if (rs.ActualStatusCode != HttpStatusCode.OK && rs.ActualStatusCode != HttpStatusCode.NotFound) { AstoriaTestLog.WriteLine("/ExpToXml returned error code " + rs.ActualStatusCode.ToString() + ", payload:"); AstoriaTestLog.FailAndThrow(rs.Payload); } // Extract XML document from response. XmlDocument xml = new XmlDocument(); xml.LoadXml(rs.Payload); // Skip verification in retail builds as they do not contain expression capture hook. string embeddedDocument = xml.DocumentElement.InnerText; AstoriaTestLog.WriteLine(embeddedDocument); if (embeddedDocument.StartsWith("WARNING")) { // Warn the user. AstoriaTestLog.WriteLine("WARNING: missing expression tree!"); AstoriaTestLog.Skip("Test variation skipped"); } // Separate string form and XML form. string[] pair = embeddedDocument.Split(new string[] { "[[===]]" }, StringSplitOptions.None); xml.LoadXml(pair[1].Replace("utf-16", "utf-8")); AstoriaTestLog.WriteLine(xml.OuterXml); if (queryTreeInfo != null) { queryTreeInfo.currentTreeXml = xml; } //return xml; return(pair[0]); }
//Get the expression tree public static String ProcessExpressionTree(Workspace w, QueryTreeInfo queryTreeInfo) { // Retrieve expression tree. AstoriaResponse rs; RequestUtil.GetAndVerifyStatusCode(w, w.ServiceUri + "/ExpToXml", HttpStatusCode.OK, out rs); if (rs.ActualStatusCode != HttpStatusCode.OK && rs.ActualStatusCode != HttpStatusCode.NotFound) { AstoriaTestLog.WriteLine("/ExpToXml returned error code " + rs.ActualStatusCode.ToString() + ", payload:"); AstoriaTestLog.FailAndThrow(rs.Payload); } // Extract XML document from response. XmlDocument xml = new XmlDocument(); xml.LoadXml(rs.Payload); // Skip verification in retail builds as they do not contain expression capture hook. string embeddedDocument = xml.DocumentElement.InnerText; AstoriaTestLog.WriteLine(embeddedDocument); if (embeddedDocument.StartsWith("WARNING")) { // Warn the user. AstoriaTestLog.WriteLine("WARNING: missing expression tree!"); AstoriaTestLog.Skip("Test variation skipped"); } // Separate string form and XML form. string[] pair = embeddedDocument.Split(new string[] { "[[===]]" }, StringSplitOptions.None); xml.LoadXml(pair[1].Replace("utf-16", "utf-8")); AstoriaTestLog.WriteLine(xml.OuterXml); if (queryTreeInfo != null) { queryTreeInfo.currentTreeXml = xml; } //return xml; return pair[0]; }
protected override bool VerifyNodes(QueryTreeInfo queryTreeInfo) { //Find the list of keys for this resource set that will appear as where nodes in the tree foreach (ResourceType type in queryTreeInfo.resourceContainer.ResourceTypes) { foreach (ResourceProperty property in type.Properties.OfType <ResourceProperty>()) { if (property.PrimaryKey != null) { refKeys.Add(property); AstoriaTestLog.WriteLine(property.Name); } } } if (queryTreeInfo.currentTree.Contains(queryTreeInfo.rootTree)) { // Obtain the diff tree. The +1 is for the "." that is the node separator queryTreeInfo.diffTree = queryTreeInfo.currentTree.Substring(queryTreeInfo.rootTree.Length + 1); AstoriaTestLog.WriteLine("Diff Tree : " + queryTreeInfo.diffTree); } //Construct the Tree Dictionary String[] splitString = new String[] { ")." }; String[] result = queryTreeInfo.diffTree.Split(splitString, StringSplitOptions.None); AstoriaTestLog.WriteLine("Split string"); foreach (String s in result) { AstoriaTestLog.WriteLine(s); } //ThenBy and Where nodes can repeat, so create a list to capture the multiple values List <String> whereList = new List <String>(); //Look through each node and construct the dictionary foreach (String s in result) { if (s.StartsWith("Where")) { //Can have multiple where nodes, so just create the list of values here and add it to dictionary later String tempStr = s.Split(new String[] { "Where(" }, StringSplitOptions.RemoveEmptyEntries)[0]; //Dont add where(p => true) occurances //TODO: Confirm if its ok to ignore where(p=>true) nodes. if (!(tempStr.Contains("p => True"))) { whereList.Add(tempStr); } else { AstoriaTestLog.WriteLine("Where(p => true) node found, ignoring the node"); } } } //Add the where list to the dictionary if (!nodeValues.ContainsKey("Where")) { if (whereList.Count > 0) { nodeValues.Add("Where", whereList); } if ((refKeys.Count) != whereList.Count) { //Where node count doesnt match AstoriaTestLog.WriteLine("Where nodes count doesnt match"); return(false); } } return(true); }
protected override bool VerifyMetaData(QueryTreeInfo queryTreeInfo) { // No metadata to verify for this pattern return true; }
//Compare will in turn call these individual comparison functions //Verify the structure of the tree protected abstract bool VerifyNodes(QueryTreeInfo queryTreeInfo);
public override void Build(QueryTreeInfo queryTreeInfo) { queryTreeInfo.queryNodeTree = queryTreeInfo.rootQueryNodeTree.Where(queryTreeInfo.wkspc.GetRandomExistingKey(queryTreeInfo.resourceContainer)); //TODO: What if there is no entity that you can select? }
protected override bool VerifyLambda(QueryTreeInfo queryTreeInfo) { List <String> outVal = null; bool result = false; if (queryTreeInfo.queryComponent == QueryComponent.Top) { result = nodeValues.TryGetValue("Take", out outVal); } else if (queryTreeInfo.queryComponent == QueryComponent.Skip) { result = nodeValues.TryGetValue("Skip", out outVal); } //Check for take/skip value if (result) { if (!(takeSkipValue.ToString() == outVal[0])) { //Take node value does not match AstoriaTestLog.WriteLine("Take/Skip node value does not match"); return false; } } else { if (queryTreeInfo.queryComponent != QueryComponent.OrderBy) { //Take node not found in the list AstoriaTestLog.WriteLine("Take/Skip node not found"); return false; } } //Check for the orderby/thenby key values for (int i = 0; i < refKeys.Count ; i++ ) { bool keyPresent; List<String> outOrderByVal = null; List<String> outThenByVal = null; //Must find orderby node keyPresent = nodeValues.TryGetValue("OrderBy", out outOrderByVal); if (outVal != null) { outVal.Clear(); outVal.AddRange(outOrderByVal); } else { outVal = outOrderByVal; } if (keyPresent) { //thenby nodes are optional nodeValues.TryGetValue("ThenBy", out outThenByVal); if (outThenByVal != null) { outVal.AddRange(outThenByVal); } } else { //OrderBy/ThenBy node not found AstoriaTestLog.WriteLine("OrderBy/ThenBy node not found"); return false; } //Verify the values if (keyPresent) { bool valuePresent = false; foreach (String s in outVal) { if(s.Contains("element." + refKeys[i].Name)) { valuePresent = true; } } if(!valuePresent) { //RefKey not found in the list AstoriaTestLog.WriteLine("RefKey not found in the list"); return false; } } } return true; }
protected override bool VerifyMetaData(QueryTreeInfo queryTreeInfo) { // No metadata to verify for this pattern return(true); }
public abstract void Build(QueryTreeInfo input);
protected override bool VerifyNodes(QueryTreeInfo queryTreeInfo) { //Find the list of keys for this resource set that will appear as where nodes in the tree foreach (ResourceType type in queryTreeInfo.resourceContainer.ResourceTypes) { foreach (ResourceProperty property in type.Properties.OfType<ResourceProperty>()) { if (property.PrimaryKey != null) { refKeys.Add(property); AstoriaTestLog.WriteLine(property.Name); } } } if (queryTreeInfo.currentTree.Contains(queryTreeInfo.rootTree)) { // Obtain the diff tree. The +1 is for the "." that is the node separator queryTreeInfo.diffTree = queryTreeInfo.currentTree.Substring(queryTreeInfo.rootTree.Length + 1); AstoriaTestLog.WriteLine("Diff Tree : " + queryTreeInfo.diffTree); } //Construct the Tree Dictionary String[] splitString = new String[] { ")." }; String[] result = queryTreeInfo.diffTree.Split(splitString, StringSplitOptions.None); AstoriaTestLog.WriteLine("Split string"); foreach (String s in result) { AstoriaTestLog.WriteLine(s); } //ThenBy and Where nodes can repeat, so create a list to capture the multiple values List<String> whereList = new List<String>(); //Look through each node and construct the dictionary foreach (String s in result) { if (s.StartsWith("Where")) { //Can have multiple where nodes, so just create the list of values here and add it to dictionary later String tempStr = s.Split(new String[] { "Where(" }, StringSplitOptions.RemoveEmptyEntries)[0]; //Dont add where(p => true) occurances //TODO: Confirm if its ok to ignore where(p=>true) nodes. if (!(tempStr.Contains("p => True"))) { whereList.Add(tempStr); } else { AstoriaTestLog.WriteLine("Where(p => true) node found, ignoring the node"); } } } //Add the where list to the dictionary if (!nodeValues.ContainsKey("Where")) { if (whereList.Count > 0) { nodeValues.Add("Where", whereList); } if ((refKeys.Count) != whereList.Count) { //Where node count doesnt match AstoriaTestLog.WriteLine("Where nodes count doesnt match"); return false; } } return true; }
//Verify the meta data info in the nodes protected abstract bool VerifyMetaData(QueryTreeInfo queryTreeInfo);
protected override bool VerifyNodes(QueryTreeInfo queryTreeInfo) { //Find the list of keys for this resource set that will appear as orderby/thenby nodes in the tree foreach (ResourceType type in queryTreeInfo.resourceContainer.ResourceTypes) { foreach (ResourceProperty property in type.Properties.OfType<ResourceProperty>()) { if (property.PrimaryKey != null) { refKeys.Add(property); AstoriaTestLog.WriteLine(property.Name); } } } if (queryTreeInfo.currentTree.Contains(queryTreeInfo.rootTree)) { // Obtain the diff tree. The +1 is for the "." that is the node separator queryTreeInfo.diffTree= queryTreeInfo.currentTree.Substring(queryTreeInfo.rootTree.Length + 1); AstoriaTestLog.WriteLine("Diff Tree : " + queryTreeInfo.diffTree); } //Construct the Tree Dictionary String[] splitString = new String[] { ")." }; String[] result = queryTreeInfo.diffTree.Split(splitString, StringSplitOptions.None); AstoriaTestLog.WriteLine("Split string"); foreach (String s in result) { AstoriaTestLog.WriteLine(s); } //ThenBy and Where nodes can repeat, so create a list to capture the multiple values List <String> thenByList = new List<String>(); List<String> whereList = new List<String>(); String expectedNode = null; //Based on the queryComponent, identify the node we should look for in the tree if (queryTreeInfo.queryComponent == QueryComponent.Top) { expectedNode = "Take"; } else if (queryTreeInfo.queryComponent == QueryComponent.Skip) { expectedNode = "Skip"; } //Look through each node and construct the dictionary foreach (String s in result) { if (s.StartsWith("OrderBy")) { if (!nodeValues.ContainsKey("OrderBy")) { nodeValues.Add("OrderBy", new List<String>(s.Split(new String[] { "OrderBy(" }, StringSplitOptions.RemoveEmptyEntries))); } else { //OrderBy found again, return error AstoriaTestLog.WriteLine("More than 1 OrderBy node found"); return false; } } if (s.StartsWith("ThenBy")) { //Can have multiple thenby nodes, so just create the list of values here and add it to dictionary later thenByList.Add((s.Split(new String[] { "ThenBy(" }, StringSplitOptions.RemoveEmptyEntries)[0])); } //Check for take/skip if (expectedNode != null) { if (s.StartsWith(expectedNode)) { if (!nodeValues.ContainsKey(expectedNode)) { nodeValues.Add(expectedNode, new List<String>(s.Split(new String[] { expectedNode + "(", ")" }, StringSplitOptions.RemoveEmptyEntries))); } else { //Node found again, return error AstoriaTestLog.WriteLine("More than 1 " + expectedNode + " node found"); return false; } } } if (s.StartsWith("Where")) { //Can have multiple where nodes, so just create the list of values here and add it to dictionary later whereList.Add((s.Split(new String[] { "Where(" }, StringSplitOptions.RemoveEmptyEntries)[0])); } } //Verify that the correct number of orderby/thenby/take nodes are present //Check for take/skip if (expectedNode != null) { //Is Take/Skip node present if (!nodeValues.ContainsKey(expectedNode)) { //Take/Skip node not found AstoriaTestLog.WriteLine(expectedNode + " node not found"); return false; } } //Is OrderBy node present? if (!nodeValues.ContainsKey("OrderBy")) { //OrderBy node not found AstoriaTestLog.WriteLine("OrderBy node not found"); return false; } //Add the theyby list to the dictionary and Verify the count of ThenBy nodes if (!nodeValues.ContainsKey("ThenBy")) { if (thenByList.Count > 0) { nodeValues.Add("ThenBy", thenByList); } if ((refKeys.Count-1) != thenByList.Count) { //ThenBy node count doesnt match AstoriaTestLog.WriteLine("ThenBy nodes count doesnt match"); return false; } } //Add the where list to the dictionary if (!nodeValues.ContainsKey("Where")) { if (whereList.Count > 0) { nodeValues.Add("Where", whereList); } } return true; }
//Verify the lambda expressions where applicable - in cases like select node protected abstract bool VerifyLambda(QueryTreeInfo queryTreeInfo);
protected override bool VerifyLambda(QueryTreeInfo queryTreeInfo) { List<String> outVal = null; bool result = nodeValues.TryGetValue("Where", out outVal); //Check for the where key values for (int i = 0; i < refKeys.Count; i++) { bool valuePresent = false; foreach (String s in outVal) { if (s.Contains("element." + refKeys[i].Name)) { valuePresent = true; } } if (!valuePresent) { //RefKey not found in the list AstoriaTestLog.WriteLine("RefKey not found in the list"); return false; } } return true; }
protected override bool VerifyNodes(QueryTreeInfo queryTreeInfo) { //Find the list of keys for this resource set that will appear as orderby/thenby nodes in the tree foreach (ResourceType type in queryTreeInfo.resourceContainer.ResourceTypes) { foreach (ResourceProperty property in type.Properties.OfType <ResourceProperty>()) { if (property.PrimaryKey != null) { refKeys.Add(property); AstoriaTestLog.WriteLine(property.Name); } } } if (queryTreeInfo.currentTree.Contains(queryTreeInfo.rootTree)) { // Obtain the diff tree. The +1 is for the "." that is the node separator queryTreeInfo.diffTree = queryTreeInfo.currentTree.Substring(queryTreeInfo.rootTree.Length + 1); AstoriaTestLog.WriteLine("Diff Tree : " + queryTreeInfo.diffTree); } //Construct the Tree Dictionary String[] splitString = new String[] { ")." }; String[] result = queryTreeInfo.diffTree.Split(splitString, StringSplitOptions.None); AstoriaTestLog.WriteLine("Split string"); foreach (String s in result) { AstoriaTestLog.WriteLine(s); } //ThenBy and Where nodes can repeat, so create a list to capture the multiple values List <String> thenByList = new List <String>(); List <String> whereList = new List <String>(); String expectedNode = null; //Based on the queryComponent, identify the node we should look for in the tree if (queryTreeInfo.queryComponent == QueryComponent.Top) { expectedNode = "Take"; } else if (queryTreeInfo.queryComponent == QueryComponent.Skip) { expectedNode = "Skip"; } //Look through each node and construct the dictionary foreach (String s in result) { if (s.StartsWith("OrderBy")) { if (!nodeValues.ContainsKey("OrderBy")) { nodeValues.Add("OrderBy", new List <String>(s.Split(new String[] { "OrderBy(" }, StringSplitOptions.RemoveEmptyEntries))); } else { //OrderBy found again, return error AstoriaTestLog.WriteLine("More than 1 OrderBy node found"); return(false); } } if (s.StartsWith("ThenBy")) { //Can have multiple thenby nodes, so just create the list of values here and add it to dictionary later thenByList.Add((s.Split(new String[] { "ThenBy(" }, StringSplitOptions.RemoveEmptyEntries)[0])); } //Check for take/skip if (expectedNode != null) { if (s.StartsWith(expectedNode)) { if (!nodeValues.ContainsKey(expectedNode)) { nodeValues.Add(expectedNode, new List <String>(s.Split(new String[] { expectedNode + "(", ")" }, StringSplitOptions.RemoveEmptyEntries))); } else { //Node found again, return error AstoriaTestLog.WriteLine("More than 1 " + expectedNode + " node found"); return(false); } } } if (s.StartsWith("Where")) { //Can have multiple where nodes, so just create the list of values here and add it to dictionary later whereList.Add((s.Split(new String[] { "Where(" }, StringSplitOptions.RemoveEmptyEntries)[0])); } } //Verify that the correct number of orderby/thenby/take nodes are present //Check for take/skip if (expectedNode != null) { //Is Take/Skip node present if (!nodeValues.ContainsKey(expectedNode)) { //Take/Skip node not found AstoriaTestLog.WriteLine(expectedNode + " node not found"); return(false); } } //Is OrderBy node present? if (!nodeValues.ContainsKey("OrderBy")) { //OrderBy node not found AstoriaTestLog.WriteLine("OrderBy node not found"); return(false); } //Add the theyby list to the dictionary and Verify the count of ThenBy nodes if (!nodeValues.ContainsKey("ThenBy")) { if (thenByList.Count > 0) { nodeValues.Add("ThenBy", thenByList); } if ((refKeys.Count - 1) != thenByList.Count) { //ThenBy node count doesnt match AstoriaTestLog.WriteLine("ThenBy nodes count doesnt match"); return(false); } } //Add the where list to the dictionary if (!nodeValues.ContainsKey("Where")) { if (whereList.Count > 0) { nodeValues.Add("Where", whereList); } } return(true); }
protected override bool VerifyLambda(QueryTreeInfo queryTreeInfo) { List <String> outVal = null; bool result = false; if (queryTreeInfo.queryComponent == QueryComponent.Top) { result = nodeValues.TryGetValue("Take", out outVal); } else if (queryTreeInfo.queryComponent == QueryComponent.Skip) { result = nodeValues.TryGetValue("Skip", out outVal); } //Check for take/skip value if (result) { if (!(takeSkipValue.ToString() == outVal[0])) { //Take node value does not match AstoriaTestLog.WriteLine("Take/Skip node value does not match"); return(false); } } else { if (queryTreeInfo.queryComponent != QueryComponent.OrderBy) { //Take node not found in the list AstoriaTestLog.WriteLine("Take/Skip node not found"); return(false); } } //Check for the orderby/thenby key values for (int i = 0; i < refKeys.Count; i++) { bool keyPresent; List <String> outOrderByVal = null; List <String> outThenByVal = null; //Must find orderby node keyPresent = nodeValues.TryGetValue("OrderBy", out outOrderByVal); if (outVal != null) { outVal.Clear(); outVal.AddRange(outOrderByVal); } else { outVal = outOrderByVal; } if (keyPresent) { //thenby nodes are optional nodeValues.TryGetValue("ThenBy", out outThenByVal); if (outThenByVal != null) { outVal.AddRange(outThenByVal); } } else { //OrderBy/ThenBy node not found AstoriaTestLog.WriteLine("OrderBy/ThenBy node not found"); return(false); } //Verify the values if (keyPresent) { bool valuePresent = false; foreach (String s in outVal) { if (s.Contains("element." + refKeys[i].Name)) { valuePresent = true; } } if (!valuePresent) { //RefKey not found in the list AstoriaTestLog.WriteLine("RefKey not found in the list"); return(false); } } } return(true); }