public static void VerifyQueryNodesAreEqual(QueryNode expected, QueryNode actual, AssertionHandler assert) { try { if (expected == null) { assert.IsNull(actual, "The node should be null."); return; } else { assert.IsNotNull(actual, "The node should not be null."); } assert.AreEqual(expected.InternalKind, actual.InternalKind, "The node kind differs from expected one."); switch (expected.InternalKind) { case InternalQueryNodeKind.Constant: VerifyConstantQueryNodesAreEqual((ConstantNode)expected, (ConstantNode)actual, assert); break; case InternalQueryNodeKind.Convert: VerifyConvertQueryNodesAreEqual((ConvertNode)expected, (ConvertNode)actual, assert); break; case InternalQueryNodeKind.NonentityRangeVariableReference: VerifyNonentityRangeVariableReferenceNodesAreEqual((NonentityRangeVariableReferenceNode)expected, (NonentityRangeVariableReferenceNode)actual, assert); break; case InternalQueryNodeKind.EntityRangeVariableReference: VerifyEntityRangeVariableReferenceNodesAreEqual((EntityRangeVariableReferenceNode)expected, (EntityRangeVariableReferenceNode)actual, assert); break; case InternalQueryNodeKind.BinaryOperator: VerifyBinaryOperatorQueryNodesAreEqual((BinaryOperatorNode)expected, (BinaryOperatorNode)actual, assert); break; case InternalQueryNodeKind.UnaryOperator: VerifyUnaryOperatorQueryNodesAreEqual((UnaryOperatorNode)expected, (UnaryOperatorNode)actual, assert); break; case InternalQueryNodeKind.SingleValuePropertyAccess: VerifyPropertyAccessQueryNodesAreEqual((SingleValuePropertyAccessNode)expected, (SingleValuePropertyAccessNode)actual, assert); break; case InternalQueryNodeKind.SingleValueFunctionCall: VerifySingleValueFunctionCallQueryNodesAreEqual((SingleValueFunctionCallNode)expected, (SingleValueFunctionCallNode)actual, assert); break; default: throw new Exception("Query node of kind '" + expected.InternalKind.ToString() + "' not yet supported by VerifyQueryNodesAreEqual."); } } catch (Exception) { assert.Warn("Expected query node: " + expected.ToDebugString()); assert.Warn("Actual query node: " + actual.ToDebugString()); throw; } }
/// <summary> /// Verifies that two queries are equal. /// </summary> /// <param name="expected">The expected query.</param> /// <param name="actual">The actual query.</param> /// <param name="assert">Assertion handler to use.</param> internal static void VerifySyntaxTreesAreEqual(SyntacticTree expected, SyntacticTree actual, AssertionHandler assert) { try { if (!VerifyNullnessMatches(expected, actual, assert, "query")) { return; } VerifySyntaxTreesAreEqualImpl(expected, actual, assert); } catch (Exception) { assert.Warn("Expected query: " + expected.ToDebugString()); assert.Warn("Actual query: " + actual.ToDebugString()); throw; } }
public static void VerifyEnumerationsAreEqual <T>( IEnumerable <T> expectedEnumeration, IEnumerable <T> actualEnumeration, Action <T, T, AssertionHandler> verifyItem, Func <T, string> itemToDebugString, AssertionHandler assert) { if (expectedEnumeration == null) { assert.IsNull(actualEnumeration, "The enumeration of items should have been null."); return; } else { assert.IsNotNull(actualEnumeration, "The enumeration of items should not have been null."); } try { var expectedEnumerator = expectedEnumeration.GetEnumerator(); var actualEnumerator = actualEnumeration.GetEnumerator(); while (expectedEnumerator.MoveNext()) { assert.IsTrue( actualEnumerator.MoveNext(), "The actual enumeration has less items than the expected enumeration.\r\n" + "Expected items: " + string.Join(", ", expectedEnumeration.Select(t => "<" + itemToDebugString(t) + ">")) + "\r\n" + "Actual items: " + string.Join(", ", actualEnumeration.Select(t => "<" + itemToDebugString(t) + ">"))); verifyItem(expectedEnumerator.Current, actualEnumerator.Current, assert); } assert.IsFalse( actualEnumerator.MoveNext(), "The expected enumeration has less items than the actual enumeration.\r\n" + "Expected items: " + string.Join(", ", expectedEnumeration.Select(t => "<" + itemToDebugString(t) + ">")) + "\r\n" + "Actual items: " + string.Join(", ", actualEnumeration.Select(t => "<" + itemToDebugString(t) + ">"))); } catch (Exception) { assert.Warn("Expected items: " + string.Join(", ", expectedEnumeration.Select(t => "<" + itemToDebugString(t) + ">"))); assert.Warn("Actual items: " + string.Join(", ", actualEnumeration.Select(t => "<" + itemToDebugString(t) + ">"))); throw; } }
private static void VerifyPathSegmentTokensAreEqual(PathSegmentToken expected, PathSegmentToken actual, AssertionHandler assert) { try { if (!VerifyNullnessMatches(expected, actual, assert, "token")) { return; } assert.AreEqual(expected.GetType(), actual.GetType(), "The token kinds are different."); assert.AreEqual(expected.Identifier, actual.Identifier, "The token identifiers are different."); VerifyPathSegmentTokensAreEqual(expected.NextToken, actual.NextToken, assert); } catch (Exception) { assert.Warn("Expected query token: " + expected.ToDebugString()); assert.Warn("Actual query token: " + actual.ToDebugString()); throw; } }
/// <summary> /// Verifies that two query tokens are equal. /// </summary> /// <param name="expected">The expected query token.</param> /// <param name="actual">The actual query token.</param> /// <param name="assert">Assertion handler to use.</param> internal static void VerifyQueryTokensAreEqual(QueryToken expected, QueryToken actual, AssertionHandler assert) { try { if (!VerifyNullnessMatches(expected, actual, assert, "token")) { return; } assert.AreEqual(expected.Kind, actual.Kind, "The token kinds are different."); switch (expected.Kind) { case QueryTokenKind.Literal: VerifyLiteralQueryTokensAreEqual((LiteralToken)expected, (LiteralToken)actual, assert); break; case QueryTokenKind.BinaryOperator: VerifyBinaryOperatorQueryTokensAreEqual((BinaryOperatorToken)expected, (BinaryOperatorToken)actual, assert); break; case QueryTokenKind.UnaryOperator: VerifyUnaryOperatorQueryTokensAreEqual((UnaryOperatorToken)expected, (UnaryOperatorToken)actual, assert); break; case QueryTokenKind.EndPath: VerifyPropertyAccessQueryTokensAreEqual((EndPathToken)expected, (EndPathToken)actual, assert); break; case QueryTokenKind.InnerPath: VerifyNonRootSegmentQueryTokensAreEqual((InnerPathToken)expected, (InnerPathToken)actual, assert); break; case QueryTokenKind.FunctionCall: VerifyFunctionCallQueryTokensAreEqual((FunctionCallToken)expected, (FunctionCallToken)actual, assert); break; case QueryTokenKind.CustomQueryOption: VerifyCustomQueryOptionQueryTokensAreEqual((CustomQueryOptionToken)expected, (CustomQueryOptionToken)actual, assert); break; case QueryTokenKind.OrderBy: VerifyOrderByQueryTokensAreEqual((OrderByToken)expected, (OrderByToken)actual, assert); break; case QueryTokenKind.Select: VerifySelectQueryTokensAreEqual((SelectToken)expected, (SelectToken)actual, assert); break; case QueryTokenKind.Star: VerifyStarQueryTokensAreEqual((StarToken)expected, (StarToken)actual, assert); break; case QueryTokenKind.FunctionParameter: VerifyFunctionParameterTokensAreEqual((FunctionParameterToken)expected, (FunctionParameterToken)actual, assert); break; default: assert.Fail("The token kind '" + expected.Kind.ToString() + "' is not a lexical node."); break; } } catch (Exception) { assert.Warn("Expected query token: " + expected.ToDebugString()); assert.Warn("Actual query token: " + actual.ToDebugString()); throw; } }
/// <summary> /// Verifies that two queries are equal. /// </summary> /// <param name="expected">The expected query.</param> /// <param name="actual">The actual query.</param> /// <param name="assert">Assertion handler to use.</param> internal static void VerifySyntaxTreesAreEqual(SyntacticTree expected, SyntacticTree actual, AssertionHandler assert) { try { if (!VerifyNullnessMatches(expected, actual, assert, "query")) return; VerifySyntaxTreesAreEqualImpl(expected, actual, assert); } catch (Exception) { assert.Warn("Expected query: " + expected.ToDebugString()); assert.Warn("Actual query: " + actual.ToDebugString()); throw; } }
private static void VerifyPathSegmentTokensAreEqual(PathSegmentToken expected, PathSegmentToken actual, AssertionHandler assert) { try { if (!VerifyNullnessMatches(expected, actual, assert, "token")) return; assert.AreEqual(expected.GetType(), actual.GetType(), "The token kinds are different."); assert.AreEqual(expected.Identifier, actual.Identifier, "The token identifiers are different."); VerifyPathSegmentTokensAreEqual(expected.NextToken, actual.NextToken, assert); } catch (Exception) { assert.Warn("Expected query token: " + expected.ToDebugString()); assert.Warn("Actual query token: " + actual.ToDebugString()); throw; } }
/// <summary> /// Verifies that two query tokens are equal. /// </summary> /// <param name="expected">The expected query token.</param> /// <param name="actual">The actual query token.</param> /// <param name="assert">Assertion handler to use.</param> internal static void VerifyQueryTokensAreEqual(QueryToken expected, QueryToken actual, AssertionHandler assert) { try { if(!VerifyNullnessMatches(expected, actual, assert, "token")) return; assert.AreEqual(expected.Kind, actual.Kind, "The token kinds are different."); switch (expected.Kind) { case QueryTokenKind.Literal: VerifyLiteralQueryTokensAreEqual((LiteralToken)expected, (LiteralToken)actual, assert); break; case QueryTokenKind.BinaryOperator: VerifyBinaryOperatorQueryTokensAreEqual((BinaryOperatorToken)expected, (BinaryOperatorToken)actual, assert); break; case QueryTokenKind.UnaryOperator: VerifyUnaryOperatorQueryTokensAreEqual((UnaryOperatorToken)expected, (UnaryOperatorToken)actual, assert); break; case QueryTokenKind.EndPath: VerifyPropertyAccessQueryTokensAreEqual((EndPathToken)expected, (EndPathToken)actual, assert); break; case QueryTokenKind.InnerPath: VerifyNonRootSegmentQueryTokensAreEqual((InnerPathToken) expected,(InnerPathToken) actual, assert); break; case QueryTokenKind.FunctionCall: VerifyFunctionCallQueryTokensAreEqual((FunctionCallToken)expected, (FunctionCallToken)actual, assert); break; case QueryTokenKind.CustomQueryOption: VerifyCustomQueryOptionQueryTokensAreEqual((CustomQueryOptionToken)expected, (CustomQueryOptionToken)actual, assert); break; case QueryTokenKind.OrderBy: VerifyOrderByQueryTokensAreEqual((OrderByToken)expected, (OrderByToken)actual, assert); break; case QueryTokenKind.Select: VerifySelectQueryTokensAreEqual((SelectToken)expected, (SelectToken)actual, assert); break; case QueryTokenKind.Star: VerifyStarQueryTokensAreEqual((StarToken)expected, (StarToken)actual, assert); break; case QueryTokenKind.FunctionParameter: VerifyFunctionParameterTokensAreEqual((FunctionParameterToken)expected, (FunctionParameterToken)actual, assert); break; default: assert.Fail("The token kind '" + expected.Kind.ToString() + "' is not a lexical node."); break; } } catch (Exception) { assert.Warn("Expected query token: " + expected.ToDebugString()); assert.Warn("Actual query token: " + actual.ToDebugString()); throw; } }
public static void VerifyQueryNodesAreEqual(QueryNode expected, QueryNode actual, AssertionHandler assert) { try { if (expected == null) { assert.IsNull(actual, "The node should be null."); return; } else { assert.IsNotNull(actual, "The node should not be null."); } assert.AreEqual(expected.InternalKind, actual.InternalKind, "The node kind differs from expected one."); switch (expected.InternalKind) { case InternalQueryNodeKind.Constant: VerifyConstantQueryNodesAreEqual((ConstantNode)expected, (ConstantNode)actual, assert); break; case InternalQueryNodeKind.Convert: VerifyConvertQueryNodesAreEqual((ConvertNode)expected, (ConvertNode)actual, assert); break; case InternalQueryNodeKind.NonentityRangeVariableReference: VerifyNonentityRangeVariableReferenceNodesAreEqual((NonentityRangeVariableReferenceNode) expected, (NonentityRangeVariableReferenceNode) actual,assert); break; case InternalQueryNodeKind.EntityRangeVariableReference: VerifyEntityRangeVariableReferenceNodesAreEqual((EntityRangeVariableReferenceNode)expected, (EntityRangeVariableReferenceNode)actual, assert); break; case InternalQueryNodeKind.BinaryOperator: VerifyBinaryOperatorQueryNodesAreEqual((BinaryOperatorNode)expected, (BinaryOperatorNode)actual, assert); break; case InternalQueryNodeKind.UnaryOperator: VerifyUnaryOperatorQueryNodesAreEqual((UnaryOperatorNode)expected, (UnaryOperatorNode)actual, assert); break; case InternalQueryNodeKind.SingleValuePropertyAccess: VerifyPropertyAccessQueryNodesAreEqual((SingleValuePropertyAccessNode)expected, (SingleValuePropertyAccessNode)actual, assert); break; case InternalQueryNodeKind.SingleValueFunctionCall: VerifySingleValueFunctionCallQueryNodesAreEqual((SingleValueFunctionCallNode)expected, (SingleValueFunctionCallNode)actual, assert); break; default: throw new Exception("Query node of kind '" + expected.InternalKind.ToString() + "' not yet supported by VerifyQueryNodesAreEqual."); } } catch (Exception) { assert.Warn("Expected query node: " + expected.ToDebugString()); assert.Warn("Actual query node: " + actual.ToDebugString()); throw; } }