/// <summary>
/// Verifies that the resulting stream buffer is in the expected state.
/// </summary>
/// <param name="assert">The assertion handler.</param>
/// <param name="streamBuffer">The stream buffer whose state to verify.</param>
/// <param name="testCaseDebugDescription">A textual description of the test case to make debugging easier.</param>
public virtual void VerifyResult(AssertionHandler assert, BatchReaderStreamBufferWrapper streamBuffer, string testCaseDebugDescription)
{
Debug.Assert(assert != null, "assert != null");
Debug.Assert(streamBuffer != null, "streamBuffer != null");
if (this.ReadPositionInBuffer.HasValue)
{
assert.AreEqual(
this.ReadPositionInBuffer.Value, streamBuffer.CurrentReadPosition,
string.Format("\r\n{0}:\r\nCurrent read position in the buffer '{1}' does not match expected read position '{2}'", testCaseDebugDescription, streamBuffer.CurrentReadPosition, this.ReadPositionInBuffer.Value));
}
if (this.NumberOfBytesInBuffer.HasValue)
{
assert.AreEqual(
this.NumberOfBytesInBuffer.Value, streamBuffer.NumberOfBytesInBuffer,
string.Format("\r\n{0}:\r\nNumber of bytes in the buffer '{1}' does not match expected number '{2}'", testCaseDebugDescription, streamBuffer.NumberOfBytesInBuffer, this.NumberOfBytesInBuffer.Value));
}
if (this.ExpectedBytesInBuffer != null)
{
foreach (KeyValuePair<int, byte> kvp in this.ExpectedBytesInBuffer)
{
assert.AreEqual(
kvp.Value, streamBuffer.Bytes[kvp.Key],
string.Format("\r\n{0}:\r\nExpected value '{1}' at position '{2}' in the buffer but found '{3}'", testCaseDebugDescription, kvp.Value, kvp.Key, streamBuffer.Bytes[kvp.Key]));
}
}
}
private static void CompareCollectionValue(IEdmValue edmValue, ODataCollectionValue collectionValue, AssertionHandler assert)
{
assert.IsNotNull(edmValue, "EDM value instance must not be null.");
if (collectionValue == null)
{
ValidateNullValue(edmValue, assert);
return;
}
assert.AreEqual(EdmValueKind.Collection, edmValue.ValueKind, "Value kinds differ.");
if (edmValue.Type != null)
{
assert.AreEqual(EdmTypeKind.Collection, edmValue.Type.TypeKind(), "Type kinds differ.");
}
IEdmCollectionValue edmCollectionValue = (IEdmCollectionValue)edmValue;
IEnumerable items = collectionValue.Items;
if (items != null)
{
CompareCollectionItems(edmCollectionValue.Elements, items, assert);
}
else
{
assert.IsTrue(
edmCollectionValue.Elements == null || edmCollectionValue.Elements.Count() == 0,
"Expected empty collection value.");
}
}
/// <summary>
/// Verifies that the resulting stream buffer is in the expected state.
/// </summary>
/// <param name="assert">The assertion handler.</param>
/// <param name="streamBuffer">The stream buffer whose state to verify.</param>
/// <param name="testCaseDebugDescription">A textual description of the test case to make debugging easier.</param>
public virtual void VerifyResult(AssertionHandler assert, BatchReaderStreamBufferWrapper streamBuffer, string testCaseDebugDescription)
{
Debug.Assert(assert != null, "assert != null");
Debug.Assert(streamBuffer != null, "streamBuffer != null");
if (this.ReadPositionInBuffer.HasValue)
{
assert.AreEqual(
this.ReadPositionInBuffer.Value, streamBuffer.CurrentReadPosition,
string.Format("\r\n{0}:\r\nCurrent read position in the buffer '{1}' does not match expected read position '{2}'", testCaseDebugDescription, streamBuffer.CurrentReadPosition, this.ReadPositionInBuffer.Value));
}
if (this.NumberOfBytesInBuffer.HasValue)
{
assert.AreEqual(
this.NumberOfBytesInBuffer.Value, streamBuffer.NumberOfBytesInBuffer,
string.Format("\r\n{0}:\r\nNumber of bytes in the buffer '{1}' does not match expected number '{2}'", testCaseDebugDescription, streamBuffer.NumberOfBytesInBuffer, this.NumberOfBytesInBuffer.Value));
}
if (this.ExpectedBytesInBuffer != null)
{
foreach (KeyValuePair <int, byte> kvp in this.ExpectedBytesInBuffer)
{
assert.AreEqual(
kvp.Value, streamBuffer.Bytes[kvp.Key],
string.Format("\r\n{0}:\r\nExpected value '{1}' at position '{2}' in the buffer but found '{3}'", testCaseDebugDescription, kvp.Value, kvp.Key, streamBuffer.Bytes[kvp.Key]));
}
}
}
/// <summary>
/// Runs a single BufferingJsonReaderTestCaseDescriptor test with a single toggle index in it
/// and verifies that the reader state after turning off buffering is correct.
/// </summary>
/// <param name="testCase">The test case descriptor to run.</param>
/// <param name="assert"></param>
public static void ReadAndVerifyStateAfterStopBuffering(BufferingJsonReaderTestCaseDescriptor testCase, AssertionHandler assert)
{
assert.AreEqual(2, testCase.ToggleBufferingCallCounts.Length, "Expected a single toggle position.");
TextReader testReader = new StringReader(testCase.JsonText);
Exception exception = TestExceptionUtils.RunCatching(() =>
{
BufferingJsonReader bufferingJsonReader = new BufferingJsonReader(testReader, ODataConstants.DefaultMaxRecursionDepth, assert, isIeee754Compatible: true);
int callCount = -1;
int startBuffering = testCase.ToggleBufferingCallCounts[0];
int stopBuffering = testCase.ToggleBufferingCallCounts[1];
bool isBuffering = false;
List <BufferingJsonReaderTestCaseDescriptor.ReaderNode> bufferedNodes = new List <BufferingJsonReaderTestCaseDescriptor.ReaderNode>();
bool hasMore = false;
do
{
callCount++;
if (startBuffering == callCount)
{
BufferingJsonReaderTestCaseDescriptor.ReaderNode bufferedNode = new BufferingJsonReaderTestCaseDescriptor.ReaderNode(bufferingJsonReader.NodeType, bufferingJsonReader.Value);
bufferedNodes.Add(bufferedNode);
bufferingJsonReader.StartBuffering();
isBuffering = true;
}
if (stopBuffering == callCount)
{
bufferingJsonReader.StopBuffering();
isBuffering = false;
assert.AreEqual(bufferedNodes[0].NodeType, bufferingJsonReader.NodeType, "Node types must be equal.");
assert.AreEqual(bufferedNodes[0].Value, bufferingJsonReader.Value, "Values must be equal.");
bufferedNodes.RemoveAt(0);
}
hasMore = bufferingJsonReader.Read();
if (isBuffering)
{
bufferedNodes.Add(new BufferingJsonReaderTestCaseDescriptor.ReaderNode(bufferingJsonReader.NodeType, bufferingJsonReader.Value));
}
else if (bufferedNodes.Count > 0)
{
assert.AreEqual(bufferedNodes[0].NodeType, bufferingJsonReader.NodeType, "Node types must be equal.");
assert.AreEqual(bufferedNodes[0].Value, bufferingJsonReader.Value, "Values must be equal.");
bufferedNodes.RemoveAt(0);
}
}while (hasMore);
});
assert.IsNull(exception, "Did not expect an exception.");
}
public static void VerifyQueryResultsAreEqual(object expected, object actual, AssertionHandler assert)
{
IEnumerable expectedEnumerable = expected as IEnumerable;
IEnumerable actualEnumerable = actual as IEnumerable;
if (expectedEnumerable == null && actualEnumerable != null)
{
assert.IsTrue(false, "Expected a single value result but the actual result is an enumerable.");
return;
}
else if (expectedEnumerable != null && actualEnumerable == null)
{
assert.IsTrue(false, "Expected an enumerable result but the actual result is a single value.");
return;
}
if (expectedEnumerable != null)
{
VerificationUtils.VerifyEnumerationsAreEqual(expectedEnumerable.Cast <object>(), actualEnumerable.Cast <object>(), assert);
}
else
{
assert.AreEqual(expected, actual, "Expected and actual single value result are different.");
}
}
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;
}
}
private static void CompareStructuralValue(IEdmValue edmValue, ODataComplexValue complexValue, AssertionHandler assert)
{
assert.IsNotNull(edmValue, "EDM value instance must not be null.");
if (complexValue == null)
{
ValidateNullValue(edmValue, assert);
return;
}
assert.AreEqual(EdmValueKind.Structured, edmValue.ValueKind, "Value kinds differ.");
if (edmValue.Type != null)
{
assert.AreEqual(EdmTypeKind.Complex, edmValue.Type.TypeKind(), "Type kinds differ.");
}
CompareStructuralValue(edmValue, complexValue.Properties, assert);
}
/// <summary>
/// Compares the given values of the given type, and throws a DataComparisonException or AssertionFailedException if values don't match
/// </summary>
/// <param name="type">The expected type</param>
/// <param name="expected">The expected value</param>
/// <param name="actual">The actual value</param>
/// <param name="assert">The assertion handler to use</param>
protected virtual void Compare(QueryScalarType type, object expected, object actual, AssertionHandler assert)
{
ExceptionUtilities.CheckArgumentNotNull(type, "type");
ExceptionUtilities.CheckArgumentNotNull(assert, "assert");
if (expected == type.NullValue.Value)
{
assert.IsNull(actual, "Primitive value unexpectedly non-null");
}
else
{
assert.IsNotNull(actual, "Primitive value unexpectedly null");
assert.AreEqual(expected.GetType(), actual.GetType(), EqualityComparer <Type> .Default, "Types did not match");
var comparer = new DelegateBasedEqualityComparer <QueryScalarValue>((v1, v2) => v1.Type.EvaluationStrategy.Compare(v1, v2) == 0);
assert.AreEqual(type.CreateValue(expected), type.CreateValue(actual), comparer, "Primitive value did not match");
}
}
/// <summary>
/// Compares the given values of the given type, and throws a DataComparisonException or AssertionFailedException if values don't match
/// </summary>
/// <param name="type">The expected type</param>
/// <param name="expected">The expected value</param>
/// <param name="actual">The actual value</param>
/// <param name="assert">The assertion handler to use</param>
protected virtual void Compare(QueryScalarType type, object expected, object actual, AssertionHandler assert)
{
ExceptionUtilities.CheckArgumentNotNull(type, "type");
ExceptionUtilities.CheckArgumentNotNull(assert, "assert");
if (expected == type.NullValue.Value)
{
assert.IsNull(actual, "Primitive value unexpectedly non-null");
}
else
{
assert.IsNotNull(actual, "Primitive value unexpectedly null");
assert.AreEqual(expected.GetType(), actual.GetType(), EqualityComparer<Type>.Default, "Types did not match");
var comparer = new DelegateBasedEqualityComparer<QueryScalarValue>((v1, v2) => v1.Type.EvaluationStrategy.Compare(v1, v2) == 0);
assert.AreEqual(type.CreateValue(expected), type.CreateValue(actual), comparer, "Primitive value did not match");
}
}
/// <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 VerifyStringsAreEqual(ICollection <string> expected, ICollection <string> actual, AssertionHandler assert)
{
var expectedEnumerator = expected.GetEnumerator();
var actualEnumerator = actual.GetEnumerator();
while (expectedEnumerator.MoveNext())
{
assert.IsTrue(actualEnumerator.MoveNext(), "Length should be the same");
assert.AreEqual(expectedEnumerator.Current, actualEnumerator.Current, "Segment text is different");
}
}
public static void VerifyServiceOperationsAreEqual(IEdmOperationImport expected, IEdmOperationImport actual, AssertionHandler assert)
{
if (expected == null)
{
assert.IsNull(actual, "The service operation should be null.");
}
else
{
assert.IsNotNull(actual, "The service operation should not be null.");
assert.AreEqual(expected.Name, actual.Name, "The service operation names are different.");
}
}
public static void VerifyEntitySetsAreEqual(IEdmEntitySet expected, IEdmEntitySet actual, AssertionHandler assert)
{
if (expected == null)
{
assert.IsNull(actual, "The entity set should be null.");
}
else
{
assert.IsNotNull(actual, "The entity set should not be null.");
assert.AreEqual(expected.Name, actual.Name, "The entity set names are different.");
}
}
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;
}
}
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>
/// If an <see cref="AggregateException"/> is passed as <paramref name="exception"/> this method will check whether
/// more than one inner exceptions exist and throw if that is the case. Otherwise it returns the single inner exception.
/// </summary>
/// <param name="exception">The <see cref="Exception"/> instance to check.</param>
/// <param name="assert">The assertion handler.</param>
/// <returns>
/// If the <paramref name="exception"/> is an <see cref="AggregateException"/> a single inner exception is expected and returned;
/// otherwise returns the <paramref name="exception"/> itself.
/// </returns>
public static Exception UnwrapAggregateException(Exception exception, AssertionHandler assert)
{
AggregateException ae = exception as AggregateException;
if (ae == null)
{
return(exception);
}
ae = ae.Flatten();
assert.AreEqual(1, ae.InnerExceptions.Count, "Expected exception count does not match.");
return(ae.InnerExceptions[0]);
}
/// <summary>
/// Asserts that the given exception is the specified exception type.
/// </summary>
/// <typeparam name="TException">Exception type.</typeparam>
/// <param name="exception">The exception instance to verify.</param>
/// <param name="expectedExceptionMessage">The expected exception message. If this is null, the check will verify that no exception was thrown.</param>
/// <param name="desciption">String to attach to all errors so that it's easier to locate what went wrong.</param>
public static void IsExpectedException <TException>(this AssertionHandler assert, Exception exception, string expectedExceptionMessage, string description = null)
{
if (expectedExceptionMessage == null)
{
assert.IsNull(exception, "No exception was expected, but it occured. " + (description ?? string.Empty) + "\r\n" + (exception == null ? string.Empty : exception.ToString()));
}
else
{
assert.IsNotNull(exception, "Expected " + typeof(TException).FullName + " but it was not thrown. " + (description ?? string.Empty));
assert.IsTrue(exception is TException, "Exception had unexpected type " + exception.GetType().FullName + ", expected type is " + typeof(TException).FullName + ". " + description);
assert.AreEqual(expectedExceptionMessage, exception.Message, "Unexpected exception message. " + (description ?? string.Empty));
}
}
public static void VerifyPropertiesAreEqual(IEdmProperty expected, IEdmProperty actual, AssertionHandler assert)
{
if (expected == null)
{
assert.IsNull(actual, "The property should be null.");
}
else
{
assert.IsNotNull(actual, "The property should not be null.");
assert.AreEqual(expected.Name, actual.Name, "The property names are different.");
// No need to verify the type of the property, we just need to verify the declaring type, which can't be done here
// if the declaring type is the same and the names are the same, it's the same property.
}
}
private static void VerifySyntaxTreesAreEqualImpl(SyntacticTree expected, SyntacticTree actual, AssertionHandler assert)
{
VerifyStringsAreEqual(expected.Path, actual.Path, assert);
VerifyQueryTokensAreEqual(expected.Filter, actual.Filter, assert);
if (expected.OrderByTokens != null && actual.OrderByTokens != null)
{
VerifyQueryTokensAreEqual(expected.OrderByTokens.Cast <QueryToken>(), actual.OrderByTokens.Cast <QueryToken>(), assert);
}
else if ((expected.OrderByTokens != null && actual.OrderByTokens == null) || (expected.OrderByTokens == null && actual.OrderByTokens != null))
{
assert.Fail("Query tokens are different");
}
assert.AreEqual(expected.Skip, actual.Skip, "Skip values are different.");
VerificationUtils.VerifyEnumerationsAreEqual(
expected.QueryOptions,
actual.QueryOptions,
VerifyCustomQueryOptionQueryTokensAreEqual,
(item) => item.ToDebugString(),
assert);
}
public static void VeryfyRangeVariablesAreEqual(RangeVariable expected, RangeVariable actual,
AssertionHandler assert)
{
assert.AreEqual(expected.Name, actual.Name, "Name is different");
assert.AreEqual(expected.Kind, actual.Kind, "InternalKind is different");
}
/// <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;
}
}
private static void ComparePrimitiveValue(IEdmValue edmValue, object odataValue, AssertionHandler assert)
{
TypeCode typeCode = Type.GetTypeCode(odataValue.GetType());
switch (typeCode)
{
case TypeCode.Boolean:
assert.AreEqual(EdmValueKind.Boolean, edmValue.ValueKind, "Value kinds differ.");
assert.AreEqual(odataValue, ((IEdmBooleanValue)edmValue).Value, "Values differ.");
if (edmValue.Type != null)
{
assert.AreEqual(EdmTypeKind.Primitive, edmValue.Type.Definition.TypeKind, "EDM type kinds differ.");
assert.AreEqual(EdmPrimitiveTypeKind.Boolean, edmValue.Type.PrimitiveKind(), "EDM primitive kinds differ.");
}
return;
case TypeCode.Byte:
assert.AreEqual(EdmValueKind.Integer, edmValue.ValueKind, "Value kinds differ.");
assert.AreEqual(odataValue, (byte)((IEdmIntegerValue)edmValue).Value, "Values differ.");
if (edmValue.Type != null)
{
assert.AreEqual(EdmTypeKind.Primitive, edmValue.Type.Definition.TypeKind, "EDM type kinds differ.");
assert.AreEqual(EdmPrimitiveTypeKind.Byte, edmValue.Type.PrimitiveKind(), "EDM primitive kinds differ.");
}
return;
case TypeCode.SByte:
assert.AreEqual(EdmValueKind.Integer, edmValue.ValueKind, "Value kinds differ.");
assert.AreEqual(odataValue, (sbyte)((IEdmIntegerValue)edmValue).Value, "Values differ.");
if (edmValue.Type != null)
{
assert.AreEqual(EdmTypeKind.Primitive, edmValue.Type.Definition.TypeKind, "EDM type kinds differ.");
assert.AreEqual(EdmPrimitiveTypeKind.SByte, edmValue.Type.PrimitiveKind(), "EDM primitive kinds differ.");
}
return;
case TypeCode.Int16:
assert.AreEqual(EdmValueKind.Integer, edmValue.ValueKind, "Value kinds differ.");
assert.AreEqual(odataValue, (Int16)((IEdmIntegerValue)edmValue).Value, "Values differ.");
if (edmValue.Type != null)
{
assert.AreEqual(EdmTypeKind.Primitive, edmValue.Type.Definition.TypeKind, "EDM type kinds differ.");
assert.AreEqual(EdmPrimitiveTypeKind.Int16, edmValue.Type.PrimitiveKind(), "EDM primitive kinds differ.");
}
return;
case TypeCode.Int32:
assert.AreEqual(EdmValueKind.Integer, edmValue.ValueKind, "Value kinds differ.");
assert.AreEqual(odataValue, (Int32)((IEdmIntegerValue)edmValue).Value, "Values differ.");
if (edmValue.Type != null)
{
assert.AreEqual(EdmTypeKind.Primitive, edmValue.Type.Definition.TypeKind, "EDM type kinds differ.");
assert.AreEqual(EdmPrimitiveTypeKind.Int32, edmValue.Type.PrimitiveKind(), "EDM primitive kinds differ.");
}
return;
case TypeCode.Int64:
assert.AreEqual(EdmValueKind.Integer, edmValue.ValueKind, "Value kinds differ.");
assert.AreEqual(odataValue, (Int64)((IEdmIntegerValue)edmValue).Value, "Values differ.");
if (edmValue.Type != null)
{
assert.AreEqual(EdmTypeKind.Primitive, edmValue.Type.Definition.TypeKind, "EDM type kinds differ.");
assert.AreEqual(EdmPrimitiveTypeKind.Int64, edmValue.Type.PrimitiveKind(), "EDM primitive kinds differ.");
}
return;
case TypeCode.Decimal:
assert.AreEqual(EdmValueKind.Decimal, edmValue.ValueKind, "Value kinds differ.");
assert.AreEqual(odataValue, ((IEdmDecimalValue)edmValue).Value, "Values differ.");
if (edmValue.Type != null)
{
assert.AreEqual(EdmTypeKind.Primitive, edmValue.Type.Definition.TypeKind, "EDM type kinds differ.");
assert.AreEqual(EdmPrimitiveTypeKind.Decimal, edmValue.Type.PrimitiveKind(), "EDM primitive kinds differ.");
}
return;
case TypeCode.Single:
assert.AreEqual(EdmValueKind.Floating, edmValue.ValueKind, "Value kinds differ.");
assert.AreEqual(odataValue, (Single)((IEdmFloatingValue)edmValue).Value, "Values differ.");
if (edmValue.Type != null)
{
assert.AreEqual(EdmTypeKind.Primitive, edmValue.Type.Definition.TypeKind, "EDM type kinds differ.");
assert.AreEqual(EdmPrimitiveTypeKind.Single, edmValue.Type.PrimitiveKind(), "EDM primitive kinds differ.");
}
return;
case TypeCode.Double:
assert.AreEqual(EdmValueKind.Floating, edmValue.ValueKind, "Value kinds differ.");
assert.AreEqual(odataValue, ((IEdmFloatingValue)edmValue).Value, "Values differ.");
if (edmValue.Type != null)
{
assert.AreEqual(EdmTypeKind.Primitive, edmValue.Type.Definition.TypeKind, "EDM type kinds differ.");
assert.AreEqual(EdmPrimitiveTypeKind.Double, edmValue.Type.PrimitiveKind(), "EDM primitive kinds differ.");
}
return;
case TypeCode.String:
assert.AreEqual(EdmValueKind.String, edmValue.ValueKind, "Value kinds differ.");
assert.AreEqual(odataValue, ((IEdmStringValue)edmValue).Value, "Values differ.");
if (edmValue.Type != null)
{
assert.AreEqual(EdmTypeKind.Primitive, edmValue.Type.Definition.TypeKind, "EDM type kinds differ.");
assert.AreEqual(EdmPrimitiveTypeKind.String, edmValue.Type.PrimitiveKind(), "EDM primitive kinds differ.");
}
return;
default:
byte[] bytes = odataValue as byte[];
if (bytes != null)
{
assert.AreEqual(EdmValueKind.Binary, edmValue.ValueKind, "Value kinds differ.");
assert.AreEqual(odataValue, ((IEdmBinaryValue)edmValue).Value, "Values differ.");
if (edmValue.Type != null)
{
assert.AreEqual(EdmTypeKind.Primitive, edmValue.Type.Definition.TypeKind, "EDM type kinds differ.");
assert.AreEqual(EdmPrimitiveTypeKind.Binary, edmValue.Type.PrimitiveKind(), "EDM primitive kinds differ.");
}
return;
}
if (odataValue is DateTimeOffset)
{
assert.AreEqual(EdmValueKind.DateTimeOffset, edmValue.ValueKind, "Value kinds differ.");
assert.AreEqual(odataValue, ((IEdmDateTimeOffsetValue)edmValue).Value, "Values differ.");
if (edmValue.Type != null)
{
assert.AreEqual(EdmTypeKind.Primitive, edmValue.Type.Definition.TypeKind, "EDM type kinds differ.");
assert.AreEqual(EdmPrimitiveTypeKind.DateTimeOffset, edmValue.Type.PrimitiveKind(), "EDM primitive kinds differ.");
}
return;
}
if (odataValue is Guid)
{
assert.AreEqual(EdmValueKind.Guid, edmValue.ValueKind, "Value kinds differ.");
assert.AreEqual(odataValue, ((IEdmGuidValue)edmValue).Value, "Values differ.");
if (edmValue.Type != null)
{
assert.AreEqual(EdmTypeKind.Primitive, edmValue.Type.Definition.TypeKind, "EDM type kinds differ.");
assert.AreEqual(EdmPrimitiveTypeKind.Guid, edmValue.Type.PrimitiveKind(), "EDM primitive kinds differ.");
}
return;
}
if (odataValue is TimeSpan)
{
assert.AreEqual(EdmValueKind.Duration, edmValue.ValueKind, "Value kinds differ.");
assert.AreEqual(odataValue, ((IEdmDurationValue)edmValue).Value, "Values differ.");
if (edmValue.Type != null)
{
assert.AreEqual(EdmTypeKind.Primitive, edmValue.Type.Definition.TypeKind, "EDM type kinds differ.");
assert.AreEqual(EdmPrimitiveTypeKind.Duration, edmValue.Type.PrimitiveKind(), "EDM primitive kinds differ.");
}
return;
}
if (odataValue is ISpatial)
{
// TODO: [JsonLight] Add support for spatial values in ODataEdmStructuredValue
throw new System.NotSupportedException();
}
assert.Fail("Unsupported primitive type: " + odataValue.GetType().FullName);
return;
}
}
private static void VerifyOrderByQueryTokensAreEqual(OrderByToken expected, OrderByToken actual, AssertionHandler assert)
{
assert.AreEqual(expected.Direction, actual.Direction, "The Direction of the order by doesn't match the expected one.");
VerifyQueryTokensAreEqual(expected.Expression, actual.Expression, assert);
}
private static void VerifySingleValueFunctionCallQueryNodesAreEqual(SingleValueFunctionCallNode expected, SingleValueFunctionCallNode actual, AssertionHandler assert)
{
assert.AreEqual(expected.Name, actual.Name, "The names of the functions are different.");
VerifyQueryNodesAreEqual(expected.Parameters, actual.Parameters, assert);
QueryTestUtils.VerifyTypesAreEqual(expected.TypeReference, actual.TypeReference, assert);
}
public static void VerifyEntitySetsAreEqual(IEdmEntitySet expected, IEdmEntitySet actual, AssertionHandler assert)
{
if (expected == null)
{
assert.IsNull(actual, "The entity set should be null.");
}
else
{
assert.IsNotNull(actual, "The entity set should not be null.");
assert.AreEqual(expected.Name, actual.Name, "The entity set names are different.");
}
}
private static void VerifyFunctionCallQueryTokensAreEqual(FunctionCallToken expected, FunctionCallToken actual, AssertionHandler assert)
{
assert.AreEqual(expected.Name, actual.Name, "The Name of the function call token doesn't match the expected one.");
VerifyQueryTokensAreEqual(expected.Arguments, actual.Arguments, assert);
}
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;
}
}
private static void VerifyLiteralQueryTokensAreEqual(LiteralToken expected, LiteralToken actual, AssertionHandler assert)
{
assert.AreEqual(expected.Value, actual.Value, "Literal values are different.");
}
private static void CompareCollectionValue(IEdmValue edmValue, ODataCollectionValue collectionValue, AssertionHandler assert)
{
assert.IsNotNull(edmValue, "EDM value instance must not be null.");
if (collectionValue == null)
{
ValidateNullValue(edmValue, assert);
return;
}
assert.AreEqual(EdmValueKind.Collection, edmValue.ValueKind, "Value kinds differ.");
if (edmValue.Type != null)
{
assert.AreEqual(EdmTypeKind.Collection, edmValue.Type.TypeKind(), "Type kinds differ.");
}
IEdmCollectionValue edmCollectionValue = (IEdmCollectionValue)edmValue;
IEnumerable items = collectionValue.Items;
if (items != null)
{
CompareCollectionItems(edmCollectionValue.Elements, items, assert);
}
else
{
assert.IsTrue(
edmCollectionValue.Elements == null || edmCollectionValue.Elements.Count() == 0,
"Expected empty collection value.");
}
}
private static void VerifyConstantQueryNodesAreEqual(ConstantNode expected, ConstantNode actual, AssertionHandler assert)
{
assert.AreEqual(expected.Value, actual.Value, "The Value is different.");
QueryTestUtils.VerifyTypesAreEqual(expected.TypeReference, actual.TypeReference, assert);
}
private static void ValidateNullValue(IEdmValue edmValue, AssertionHandler assert)
{
assert.AreEqual(EdmValueKind.Null, edmValue.ValueKind, "Expected null value kind.");
assert.IsTrue(edmValue is IEdmNullValue, "Expected IEdmNullValue instance.");
}
public static void VerifyQueryResultsAreEqual(object expected, object actual, AssertionHandler assert)
{
IEnumerable expectedEnumerable = expected as IEnumerable;
IEnumerable actualEnumerable = actual as IEnumerable;
if (expectedEnumerable == null && actualEnumerable != null)
{
assert.IsTrue(false, "Expected a single value result but the actual result is an enumerable.");
return;
}
else if (expectedEnumerable != null && actualEnumerable == null)
{
assert.IsTrue(false, "Expected an enumerable result but the actual result is a single value.");
return;
}
if (expectedEnumerable != null)
{
VerificationUtils.VerifyEnumerationsAreEqual(expectedEnumerable.Cast<object>(), actualEnumerable.Cast<object>(), assert);
}
else
{
assert.AreEqual(expected, actual, "Expected and actual single value result are different.");
}
}
public static void VerifyServiceOperationsAreEqual(IEdmOperationImport expected, IEdmOperationImport actual, AssertionHandler assert)
{
if (expected == null)
{
assert.IsNull(actual, "The service operation should be null.");
}
else
{
assert.IsNotNull(actual, "The service operation should not be null.");
assert.AreEqual(expected.Name, actual.Name, "The service operation names are different.");
}
}
/// <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 VerifyStringsAreEqual(ICollection<string> expected, ICollection<string> actual, AssertionHandler assert)
{
var expectedEnumerator = expected.GetEnumerator();
var actualEnumerator = actual.GetEnumerator();
while(expectedEnumerator.MoveNext())
{
assert.IsTrue(actualEnumerator.MoveNext(), "Length should be the same");
assert.AreEqual(expectedEnumerator.Current, actualEnumerator.Current, "Segment text is different");
}
}
private static void VerifyPropertyAccessQueryTokensAreEqual(EndPathToken expected, EndPathToken actual, AssertionHandler assert)
{
assert.AreEqual(expected.Identifier, actual.Identifier, "The Name of the property access token doesn't match the expected one.");
VerifyQueryTokensAreEqual(expected.NextToken, actual.NextToken, assert);
}
/// <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 VerifyPropertiesAreEqual(IEdmProperty expected, IEdmProperty actual, AssertionHandler assert)
{
if (expected == null)
{
assert.IsNull(actual, "The property should be null.");
}
else
{
assert.IsNotNull(actual, "The property should not be null.");
assert.AreEqual(expected.Name, actual.Name, "The property names are different.");
// No need to verify the type of the property, we just need to verify the declaring type, which can't be done here
// if the declaring type is the same and the names are the same, it's the same property.
}
}
private static void VerifySyntaxTreesAreEqualImpl(SyntacticTree expected, SyntacticTree actual, AssertionHandler assert)
{
VerifyStringsAreEqual(expected.Path, actual.Path, assert);
VerifyQueryTokensAreEqual(expected.Filter, actual.Filter, assert);
if (expected.OrderByTokens != null && actual.OrderByTokens != null)
VerifyQueryTokensAreEqual(expected.OrderByTokens.Cast<QueryToken>(), actual.OrderByTokens.Cast<QueryToken>(), assert);
else if ((expected.OrderByTokens != null && actual.OrderByTokens == null) || (expected.OrderByTokens == null && actual.OrderByTokens != null))
assert.Fail("Query tokens are different");
assert.AreEqual(expected.Skip, actual.Skip, "Skip values are different.");
VerificationUtils.VerifyEnumerationsAreEqual(
expected.QueryOptions,
actual.QueryOptions,
VerifyCustomQueryOptionQueryTokensAreEqual,
(item) => item.ToDebugString(),
assert);
}
private static void VerifyUnaryOperatorQueryTokensAreEqual(UnaryOperatorToken expected, UnaryOperatorToken actual, AssertionHandler assert)
{
assert.AreEqual(expected.OperatorKind, actual.OperatorKind, "The unary operator kind doesn't match the expected one.");
VerifyQueryTokensAreEqual(expected.Operand, actual.Operand, assert);
}
private static void VerifyUnaryOperatorQueryTokensAreEqual(UnaryOperatorToken expected, UnaryOperatorToken actual, AssertionHandler assert)
{
assert.AreEqual(expected.OperatorKind, actual.OperatorKind, "The unary operator kind doesn't match the expected one.");
VerifyQueryTokensAreEqual(expected.Operand, actual.Operand, assert);
}
private static void VerifyNonRootSegmentQueryTokensAreEqual(InnerPathToken expected, InnerPathToken actual, AssertionHandler assert)
{
assert.AreEqual(expected.Identifier, actual.Identifier, "The Name of the navigation property token doesn't match the expected one.");
VerifyQueryTokensAreEqual(expected.NextToken, actual.NextToken, assert);
}
private static void VerifyNonRootSegmentQueryTokensAreEqual(InnerPathToken expected, InnerPathToken actual, AssertionHandler assert)
{
assert.AreEqual(expected.Identifier, actual.Identifier, "The Name of the navigation property token doesn't match the expected one.");
VerifyQueryTokensAreEqual(expected.NextToken, actual.NextToken, assert);
}
private static void VerifyFunctionParameterTokensAreEqual(FunctionParameterToken expected, FunctionParameterToken actual, AssertionHandler assert)
{
assert.AreEqual(expected.ParameterName, actual.ParameterName, "The Name of the function call token doesn't match the expected one.");
VerifyQueryTokensAreEqual(expected.ValueToken, actual.ValueToken, assert);
}
private static void VerifyFunctionParameterTokensAreEqual(FunctionParameterToken expected, FunctionParameterToken actual, AssertionHandler assert)
{
assert.AreEqual(expected.ParameterName, actual.ParameterName, "The Name of the function call token doesn't match the expected one.");
VerifyQueryTokensAreEqual(expected.ValueToken, actual.ValueToken, assert);
}
private static void VerifyCustomQueryOptionQueryTokensAreEqual(CustomQueryOptionToken expected, CustomQueryOptionToken actual, AssertionHandler assert)
{
assert.AreEqual(expected.Name, actual.Name, "The Name of the query option token doesn't match the expected one.");
assert.AreEqual(expected.Value, actual.Value, "The Value of the query option token doesn't match the expected one.");
}
private static void VerifyCustomQueryOptionQueryTokensAreEqual(CustomQueryOptionToken expected, CustomQueryOptionToken actual, AssertionHandler assert)
{
assert.AreEqual(expected.Name, actual.Name, "The Name of the query option token doesn't match the expected one.");
assert.AreEqual(expected.Value, actual.Value, "The Value of the query option token doesn't match the expected one.");
}
private static void CompareProperty(IEdmPropertyValue edmProperty, ODataProperty odataProperty, AssertionHandler assert)
{
assert.AreEqual(edmProperty.Name, odataProperty.Name, "Property names don't match.");
CompareValue(edmProperty.Value, odataProperty.Value, assert);
}
private static void VerifyUnaryOperatorQueryNodesAreEqual(UnaryOperatorNode expected, UnaryOperatorNode actual, AssertionHandler assert)
{
assert.AreEqual(expected.OperatorKind, actual.OperatorKind, "Operator kinds differ.");
VerifyQueryNodesAreEqual(expected.Operand, actual.Operand, assert);
}
private static void RunHeaderTest(
Func<IEnumerable<KeyValuePair<string, string>>> getHeadersFunc,
bool writing,
Func<string, string> getHeaderFunc,
Action<string, string> setHeaderAction,
AssertionHandler assert,
IExceptionVerifier exceptionVerifier)
{
assert.IsNotNull(getHeadersFunc(), "Non-null headers expected.");
assert.AreEqual(0, getHeadersFunc().Count(), "Empty header collection exptected.");
assert.IsNull(getHeaderFunc("a"), "Unexpectedly found header.");
ExpectedException expectedException = writing ? null : ODataExpectedExceptions.ODataException("ODataMessage_MustNotModifyMessage");
TestExceptionUtils.ExpectedException(
assert,
() =>
{
setHeaderAction("a", "b");
assert.AreEqual(1, getHeadersFunc().Count(), "One header expected.");
assert.AreEqual("b", getHeaderFunc("a"), "Header not found or invalid header value.");
List<KeyValuePair<string, string>> expectedHeaders = new List<KeyValuePair<string, string>>
{
new KeyValuePair<string, string>("a", "b")
};
VerificationUtils.VerifyEnumerationsAreEqual(
expectedHeaders,
getHeadersFunc(),
(first, second, assert2) => assert2.AreEqual(first, second, "Items differ."),
(item) => item.Key + " = " + item.Value,
assert);
setHeaderAction("a", "c");
assert.AreEqual(1, getHeadersFunc().Count(), "One header expected.");
assert.AreEqual("c", getHeaderFunc("a"), "Header not found or invalid header value.");
expectedHeaders[0] = new KeyValuePair<string, string>("a", "c");
VerificationUtils.VerifyEnumerationsAreEqual(
expectedHeaders,
getHeadersFunc(),
(first, second, assert2) => assert2.AreEqual(first, second, "Items differ."),
(item) => item.Key + " = " + item.Value,
assert);
setHeaderAction("d", "e");
assert.AreEqual(2, getHeadersFunc().Count(), "Two headers expected.");
assert.AreEqual("c", getHeaderFunc("a"), "Header not found or invalid header value.");
assert.AreEqual("e", getHeaderFunc("d"), "Header not found or invalid header value.");
expectedHeaders.Add(new KeyValuePair<string, string>("d", "e"));
VerificationUtils.VerifyEnumerationsAreEqual(
expectedHeaders,
getHeadersFunc(),
(first, second, assert2) => assert2.AreEqual(first, second, "Items differ."),
(item) => item.Key + " = " + item.Value,
assert);
setHeaderAction("d", null);
setHeaderAction("a", null);
assert.AreEqual(0, getHeadersFunc().Count(), "Empty header collection expected.");
assert.IsNull(getHeaderFunc("a"), "Unexpectedly found header.");
},
expectedException,
exceptionVerifier);
}
private static void VerifyConvertQueryNodesAreEqual(ConvertNode expected, ConvertNode actual, AssertionHandler assert)
{
assert.AreEqual(expected.TypeReference.TestFullName(), actual.TypeReference.TestFullName(), "The target type names differ.");
VerifyQueryNodesAreEqual(expected.Source, actual.Source, assert);
}
private static void CompareStructuralValue(IEdmValue edmValue, ODataComplexValue complexValue, AssertionHandler assert)
{
assert.IsNotNull(edmValue, "EDM value instance must not be null.");
if (complexValue == null)
{
ValidateNullValue(edmValue, assert);
return;
}
assert.AreEqual(EdmValueKind.Structured, edmValue.ValueKind, "Value kinds differ.");
if (edmValue.Type != null)
{
assert.AreEqual(EdmTypeKind.Complex, edmValue.Type.TypeKind(), "Type kinds differ.");
}
CompareStructuralValue(edmValue, complexValue.Properties, assert);
}
private static void VerifyLiteralQueryTokensAreEqual(LiteralToken expected, LiteralToken actual, AssertionHandler assert)
{
assert.AreEqual(expected.Value, actual.Value, "Literal values are different.");
}
private static void VerifyUnaryOperatorQueryNodesAreEqual(UnaryOperatorNode expected, UnaryOperatorNode actual, AssertionHandler assert)
{
assert.AreEqual(expected.OperatorKind, actual.OperatorKind, "Operator kinds differ.");
VerifyQueryNodesAreEqual(expected.Operand, actual.Operand, assert);
}
private static void VerifyPropertyAccessQueryTokensAreEqual(EndPathToken expected, EndPathToken actual, AssertionHandler assert)
{
assert.AreEqual(expected.Identifier, actual.Identifier, "The Name of the property access token doesn't match the expected one.");
VerifyQueryTokensAreEqual(expected.NextToken, actual.NextToken, assert);
}
private static void VerifySingleValueFunctionCallQueryNodesAreEqual(SingleValueFunctionCallNode expected, SingleValueFunctionCallNode actual, AssertionHandler assert)
{
assert.AreEqual(expected.Name, actual.Name, "The names of the functions are different.");
VerifyQueryNodesAreEqual(expected.Parameters, actual.Parameters, assert);
QueryTestUtils.VerifyTypesAreEqual(expected.TypeReference, actual.TypeReference, assert);
}
private static void VerifyFunctionCallQueryTokensAreEqual(FunctionCallToken expected, FunctionCallToken actual, AssertionHandler assert)
{
assert.AreEqual(expected.Name, actual.Name, "The Name of the function call token doesn't match the expected one.");
VerifyQueryTokensAreEqual(expected.Arguments, actual.Arguments, assert);
}
public static void VeryfyRangeVariablesAreEqual(RangeVariable expected, RangeVariable actual,
AssertionHandler assert)
{
assert.AreEqual(expected.Name, actual.Name, "Name is different");
assert.AreEqual(expected.Kind, actual.Kind, "InternalKind is different");
}
private static void VerifyOrderByQueryTokensAreEqual(OrderByToken expected, OrderByToken actual, AssertionHandler assert)
{
assert.AreEqual(expected.Direction, actual.Direction, "The Direction of the order by doesn't match the expected one.");
VerifyQueryTokensAreEqual(expected.Expression, actual.Expression, assert);
}
/// <summary>
/// Runs a single BufferingJsonReaderTestCaseDescriptor test.
/// </summary>
/// <param name="testCase">The test case descriptor to run.</param>
/// <param name="assert"></param>
public static void ReadAndVerifyBufferingJson(BufferingJsonReaderTestCaseDescriptor testCase, AssertionHandler assert)
{
TextReader testReader = new StringReader(testCase.JsonText);
BufferingJsonReader bufferingJsonReader = new BufferingJsonReader(testReader, ODataConstants.DefaultMaxRecursionDepth, assert, ODataFormat.Json, isIeee754Compatible: true);
bool isBuffering = false;
int callCount = -1;
int index = 0;
int[] toggleCallCounts = testCase.ToggleBufferingCallCounts;
int toggleAt = toggleCallCounts == null || toggleCallCounts.Length == 0 ? -1 : toggleCallCounts[index];
int nonBufferingResultIndex = -1;
int bufferingResultIndex = -1;
do
{
callCount++;
int ixToCompare;
if (isBuffering)
{
bufferingResultIndex++;
ixToCompare = bufferingResultIndex;
}
else
{
nonBufferingResultIndex++;
ixToCompare = nonBufferingResultIndex;
}
assert.IsTrue(!isBuffering || bufferingResultIndex >= nonBufferingResultIndex, "Buffering index must be greater or equal than non-buffering one.");
if (testCase.ExpectedNodes != null)
{
assert.AreEqual(testCase.ExpectedNodes[ixToCompare].NodeType, bufferingJsonReader.NodeType, "Node types don't match.");
assert.AreEqual(testCase.ExpectedNodes[ixToCompare].Value, bufferingJsonReader.Value, "Values don't match.");
}
if (toggleAt == callCount)
{
if (!isBuffering)
{
bufferingJsonReader.StartBuffering();
bufferingResultIndex = nonBufferingResultIndex;
isBuffering = true;
}
else
{
bufferingJsonReader.StopBuffering();
isBuffering = false;
}
if (index + 1 < toggleCallCounts.Length)
{
index++;
toggleAt = toggleCallCounts[index];
}
}
}
while (bufferingJsonReader.Read());
// we might have hit the end of the input in buffering mode; now empty the buffer.
if (isBuffering)
{
bufferingJsonReader.StopBuffering();
isBuffering = false;
if (testCase.ExpectedNodes != null)
{
assert.AreEqual(testCase.ExpectedNodes[nonBufferingResultIndex].NodeType, bufferingJsonReader.NodeType, "Node types don't match.");
assert.AreEqual(testCase.ExpectedNodes[nonBufferingResultIndex].Value, bufferingJsonReader.Value, "Values don't match.");
}
}
while (bufferingJsonReader.Read())
{
nonBufferingResultIndex++;
if (testCase.ExpectedNodes != null)
{
assert.AreEqual(testCase.ExpectedNodes[nonBufferingResultIndex].NodeType, bufferingJsonReader.NodeType, "Node types don't match.");
assert.AreEqual(testCase.ExpectedNodes[nonBufferingResultIndex].Value, bufferingJsonReader.Value, "Values don't match.");
}
}
// reading after end-of-input should stay in state end-of-input
bufferingJsonReader.Read();
assert.AreEqual(JsonNodeType.EndOfInput, bufferingJsonReader.NodeType, "Node types don't match.");
assert.AreEqual(null, bufferingJsonReader.Value, "Values don't match.");
}
private static void RunHeaderTest(
Func <IEnumerable <KeyValuePair <string, string> > > getHeadersFunc,
bool writing,
Func <string, string> getHeaderFunc,
Action <string, string> setHeaderAction,
AssertionHandler assert,
IExceptionVerifier exceptionVerifier)
{
assert.IsNotNull(getHeadersFunc(), "Non-null headers expected.");
assert.AreEqual(0, getHeadersFunc().Count(), "Empty header collection expected.");
assert.IsNull(getHeaderFunc("a"), "Unexpectedly found header.");
ExpectedException expectedException = writing ? null : ODataExpectedExceptions.ODataException("ODataMessage_MustNotModifyMessage");
TestExceptionUtils.ExpectedException(
assert,
() =>
{
setHeaderAction("a", "b");
assert.AreEqual(1, getHeadersFunc().Count(), "One header expected.");
assert.AreEqual("b", getHeaderFunc("a"), "Header not found or invalid header value.");
List <KeyValuePair <string, string> > expectedHeaders = new List <KeyValuePair <string, string> >
{
new KeyValuePair <string, string>("a", "b")
};
VerificationUtils.VerifyEnumerationsAreEqual(
expectedHeaders,
getHeadersFunc(),
(first, second, assert2) => assert2.AreEqual(first, second, "Items differ."),
(item) => item.Key + " = " + item.Value,
assert);
setHeaderAction("a", "c");
assert.AreEqual(1, getHeadersFunc().Count(), "One header expected.");
assert.AreEqual("c", getHeaderFunc("a"), "Header not found or invalid header value.");
expectedHeaders[0] = new KeyValuePair <string, string>("a", "c");
VerificationUtils.VerifyEnumerationsAreEqual(
expectedHeaders,
getHeadersFunc(),
(first, second, assert2) => assert2.AreEqual(first, second, "Items differ."),
(item) => item.Key + " = " + item.Value,
assert);
setHeaderAction("d", "e");
assert.AreEqual(2, getHeadersFunc().Count(), "Two headers expected.");
assert.AreEqual("c", getHeaderFunc("a"), "Header not found or invalid header value.");
assert.AreEqual("e", getHeaderFunc("d"), "Header not found or invalid header value.");
expectedHeaders.Add(new KeyValuePair <string, string>("d", "e"));
VerificationUtils.VerifyEnumerationsAreEqual(
expectedHeaders,
getHeadersFunc(),
(first, second, assert2) => assert2.AreEqual(first, second, "Items differ."),
(item) => item.Key + " = " + item.Value,
assert);
setHeaderAction("d", null);
setHeaderAction("a", null);
assert.AreEqual(0, getHeadersFunc().Count(), "Empty header collection expected.");
assert.IsNull(getHeaderFunc("a"), "Unexpectedly found header.");
},
expectedException,
exceptionVerifier);
}
/// <summary>
/// Runs a single BufferingJsonReaderTestCaseDescriptor test with a single toggle index in it
/// and verifies that the reader state after turning off buffering is correct.
/// </summary>
/// <param name="testCase">The test case descriptor to run.</param>
/// <param name="assert"></param>
public static void ReadAndVerifyStateAfterStopBuffering(BufferingJsonReaderTestCaseDescriptor testCase, AssertionHandler assert)
{
assert.AreEqual(2, testCase.ToggleBufferingCallCounts.Length, "Expected a single toggle position.");
TextReader testReader = new StringReader(testCase.JsonText);
Exception exception = TestExceptionUtils.RunCatching(() =>
{
BufferingJsonReader bufferingJsonReader = new BufferingJsonReader(testReader, ODataConstants.DefaultMaxRecursionDepth, assert, ODataFormat.Json, isIeee754Compatible: true);
int callCount = -1;
int startBuffering = testCase.ToggleBufferingCallCounts[0];
int stopBuffering = testCase.ToggleBufferingCallCounts[1];
bool isBuffering = false;
List<BufferingJsonReaderTestCaseDescriptor.ReaderNode> bufferedNodes = new List<BufferingJsonReaderTestCaseDescriptor.ReaderNode>();
bool hasMore = false;
do
{
callCount++;
if (startBuffering == callCount)
{
BufferingJsonReaderTestCaseDescriptor.ReaderNode bufferedNode = new BufferingJsonReaderTestCaseDescriptor.ReaderNode(bufferingJsonReader.NodeType, bufferingJsonReader.Value);
bufferedNodes.Add(bufferedNode);
bufferingJsonReader.StartBuffering();
isBuffering = true;
}
if (stopBuffering == callCount)
{
bufferingJsonReader.StopBuffering();
isBuffering = false;
assert.AreEqual(bufferedNodes[0].NodeType, bufferingJsonReader.NodeType, "Node types must be equal.");
assert.AreEqual(bufferedNodes[0].Value, bufferingJsonReader.Value, "Values must be equal.");
bufferedNodes.RemoveAt(0);
}
hasMore = bufferingJsonReader.Read();
if (isBuffering)
{
bufferedNodes.Add(new BufferingJsonReaderTestCaseDescriptor.ReaderNode(bufferingJsonReader.NodeType, bufferingJsonReader.Value));
}
else if (bufferedNodes.Count > 0)
{
assert.AreEqual(bufferedNodes[0].NodeType, bufferingJsonReader.NodeType, "Node types must be equal.");
assert.AreEqual(bufferedNodes[0].Value, bufferingJsonReader.Value, "Values must be equal.");
bufferedNodes.RemoveAt(0);
}
}
while (hasMore);
});
assert.IsNull(exception, "Did not expect an exception.");
}