/// <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); }
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 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."); } }
/// <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; } }
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 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 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); }
/// <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."); }