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;
}
}