Ejemplo n.º 1
0
        /// <summary>
        /// Runs the test specified by this test descriptor.
        /// </summary>
        /// <param name="testConfiguration">The test configuration to use for running the test.</param>
        public virtual void RunTest(ReaderTestConfiguration testConfiguration)
        {
            if (this.ShouldSkipForTestConfiguration(testConfiguration))
            {
                return;
            }

            TestMessage message = this.CreateInputMessage(testConfiguration);
            IEdmModel   model   = this.GetMetadataProvider(testConfiguration);
            ReaderTestExpectedResult expectedResult = this.GetExpectedResult(testConfiguration);

            ExceptionUtilities.Assert(expectedResult != null, "The expected result could not be determined for the test. Did you specify it?");

            Exception exception = TestExceptionUtils.RunCatching(() =>
            {
                using (ODataMessageReaderTestWrapper messageReaderWrapper = TestReaderUtils.CreateMessageReader(message, model, testConfiguration))
                {
                    expectedResult.VerifyResult(messageReaderWrapper, this.PayloadKind, testConfiguration);
                }
            });

            try
            {
                expectedResult.VerifyException(exception);
            }
            catch (Exception)
            {
                this.TraceFailureInformation(testConfiguration);
                throw;
            }
        }
Ejemplo n.º 2
0
        /// <summary>
        /// Applies the specified max protocol version to copy of the settings.
        /// </summary>
        /// <param name="maxProtocolVersion">The max protocol version to apply.</param>
        /// <returns>A copy of this configuration with the max protocol version applied.</returns>
        public ReaderTestConfiguration CloneAndApplyMaxProtocolVersion(ODataVersion maxProtocolVersion)
        {
            ReaderTestConfiguration testConfiguration = new ReaderTestConfiguration(this);

            testConfiguration.MessageReaderSettings.MaxProtocolVersion = maxProtocolVersion;
            return(testConfiguration);
        }
        /// <summary>
        /// Gets The model to use for the specified test configuration.
        /// </summary>
        /// <param name="testConfiguration">The test configuration to use.</param>
        /// <returns>The model to use for the test.</returns>
        protected override IEdmModel GetMetadataProvider(ReaderTestConfiguration testConfiguration)
        {
            IEdmModel model = base.GetMetadataProvider(testConfiguration);

            if (model == null)
            {
                // Try to set the cached model if it is null. If the PayloadEdmModel is null cached model will stay null.
                if (this.cachedModel == null)
                {
                    this.cachedModel = this.PayloadEdmModel;
                }

                if (this.cachedModel != null)
                {
                    if (this.Annotations != null)
                    {
                        this.cachedModel = EdmModelBuilder.BuildAnnotationModel(this.Annotations, this.cachedModel);
                    }
                }

                model = this.cachedModel;
            }

            return(model);
        }
 /// <summary>
 /// Constructor.
 /// </summary>
 /// <param name="batchTestConfiguration">The test configuration for the entire batch payload.</param>
 /// <param name="applyExpectedResultNormalizers">The func which applies expected result normalizers to a payload element.</param>
 public BatchPayloadExpectedResultNormalizer(
     ReaderTestConfiguration batchTestConfiguration,
     Func <ODataPayloadElement, ReaderTestConfiguration, ODataPayloadElement> applyExpectedResultNormalizers)
 {
     this.batchTestConfiguration         = batchTestConfiguration;
     this.applyExpectedResultNormalizers = applyExpectedResultNormalizers;
 }
        /// <summary>
        /// Called to get the expected result of the test.
        /// </summary>
        /// <param name="testConfiguration">The test configuration to use.</param>
        /// <returns>The expected result.</returns>
        protected override ReaderTestExpectedResult GetExpectedResult(ReaderTestConfiguration testConfiguration)
        {
            ReaderTestExpectedResult expectedResult = base.GetExpectedResult(testConfiguration);

            if (expectedResult == null)
            {
                IEdmModel      model          = this.GetMetadataProvider(testConfiguration);
                ReaderMetadata readerMetadata = new ReaderMetadata(model, this.PayloadElement);

                // First use the input payload as the expected result.
                ODataPayloadElement expectedResultPayloadElement = this.PayloadElement;

                // If we have an override specifically for expected result, use that instead.
                if (this.ExpectedResultPayloadElement != null)
                {
                    expectedResultPayloadElement = this.ExpectedResultPayloadElement(testConfiguration);
                }

                if (expectedResultPayloadElement.ElementType == ODataPayloadElementType.BatchRequestPayload || expectedResultPayloadElement.ElementType == ODataPayloadElementType.BatchResponsePayload)
                {
                    if (this.ExpectedResultNormalizers.Count > 0)
                    {
                        expectedResultPayloadElement = new BatchPayloadExpectedResultNormalizer(
                            testConfiguration,
                            this.ApplyExpectedResultNormalizers).Normalize(expectedResultPayloadElement);
                    }

                    IEdmModel payloadModel = this.GetMetadataProvider(testConfiguration);
                    return(new BatchReaderTestExpectedResult(this.settings.BatchExpectedResultSettings)
                    {
                        ExpectedBatchPayload = expectedResultPayloadElement,
                        PayloadModel = payloadModel,
                        ExpectedException = this.ExpectedException,
                    });
                }
                else
                {
                    expectedResultPayloadElement = this.ApplyExpectedResultNormalizers(expectedResultPayloadElement, testConfiguration);
                }

                return(new PayloadReaderTestExpectedResult(this.settings.ExpectedResultSettings)
                {
                    ExpectedPayloadElement = expectedResultPayloadElement,
                    ExpectedException = this.ExpectedException,
                    ReaderMetadata = readerMetadata,
                    IgnorePropertyOrder = this.IgnorePropertyOrder,
                });
            }
            else
            {
                PayloadReaderTestExpectedResult payloadReaderTestExpectedResult = expectedResult as PayloadReaderTestExpectedResult;
                if (payloadReaderTestExpectedResult != null && payloadReaderTestExpectedResult.ReaderMetadata == null)
                {
                    IEdmModel model = this.GetMetadataProvider(testConfiguration);
                    payloadReaderTestExpectedResult.ReaderMetadata = new ReaderMetadata(model, this.PayloadElement);
                }

                return(expectedResult);
            }
        }
        /// <summary>
        /// Writes the content of the input message into a stream.
        /// </summary>
        /// <param name="testConfiguration">The test configuration to use.</param>
        /// <param name="stream">The stream to write to.</param>
        private void WriteInputMessageContent(ReaderTestConfiguration testConfiguration, Stream stream)
        {
            if (this.InputCreator != null)
            {
                // Note that by default the StreamWriter uses UTF8 encoding which is exactly what we want.
                using (StreamWriter textWriter = new StreamWriter(stream))
                {
                    textWriter.Write(this.InputCreator(testConfiguration));
                }
            }
            else
            {
                if (testConfiguration.Format == ODataFormat.Atom)
                {
                    ExceptionUtilities.Assert(
                        this.AtomInput != null || this.AtomInputXml != null,
                        "The test tries to use ATOM format, thus the AtomInput or AtomInputXml must be specified.");

                    // Note that by default the Save will use UTF8 encoding which is exactly what we want.
                    this.AtomInput.Save(stream, SaveOptions.DisableFormatting);
                }
                else if (testConfiguration.Format == null)
                {
                    ExceptionUtilities.CheckObjectNotNull(this.DefaultInput, "The test tries to use Default format, thus the DefaultInput must be specified.");

                    // Note that by default the StreamWriter uses UTF8 encoding which is exactly what we want.
                    using (StreamWriter textWriter = new StreamWriter(stream))
                    {
                        textWriter.Write(this.DefaultInput);
                    }
                }
            }
        }
Ejemplo n.º 7
0
 /// <summary>
 /// Constructor.
 /// </summary>
 /// <param name="other">The <see cref="ReaderTestConfiguration"/> instance used to initialize the new instance.</param>
 /// <param name="behaviorKind">The behavior to use when running this test.</param>
 private ReaderTestConfiguration(ReaderTestConfiguration other, TestODataBehaviorKind behaviorKind)
     : base(other.Format, other.Version, other.IsRequest, behaviorKind)
 {
     this.MessageReaderSettings         = other.MessageReaderSettings.Clone();
     this.Synchronous                   = other.Synchronous;
     this.SkipStateValidationBeforeRead = other.SkipStateValidationBeforeRead;
 }
        /// <summary>
        /// Called to create the input message for the reader test.
        /// </summary>
        /// <param name="testConfiguration">The test configuration.</param>
        /// <returns>The newly created test message to use.</returns>
        protected override TestMessage CreateInputMessage(ReaderTestConfiguration testConfiguration)
        {
            MemoryStream memoryStream  = new MemoryStream(this.GetPayload(testConfiguration));
            TestStream   messageStream = new TestStream(memoryStream);

            if (testConfiguration.Synchronous)
            {
                messageStream.FailAsynchronousCalls = true;
            }
            else
            {
                messageStream.FailSynchronousCalls = true;
            }

            this.testMessage = TestReaderUtils.CreateInputMessageFromStream(
                messageStream,
                testConfiguration,
                /*payloadKind*/ null,
                this.ContentType,
                /*urlResolver*/ null);

            if (this.TestMessageWrapper != null)
            {
                this.testMessage = this.TestMessageWrapper(this.testMessage);
            }

            return(this.testMessage);
        }
Ejemplo n.º 9
0
        /// <summary>
        /// Returns the payload to be used for this test case and the specified test configuration.
        /// </summary>
        /// <param name="testConfiguration">The test configuration to use.</param>
        /// <returns>The payload to use for testing.</returns>
        private byte[] GetPayload(ReaderTestConfiguration testConfiguration)
        {
            if (testConfiguration.Format != null && testConfiguration.Format != ODataFormat.Metadata)
            {
                // NOTE: metadata reading is not supported in other formats; return an empty payload for error tests
                return(new byte[0]);
            }

            TestStream testStream = new TestStream(new MemoryStream(), ignoreDispose: true);

            if (this.PayloadEdmModel != null)
            {
                using (XmlWriter xmlWriter = XmlWriter.Create(testStream))
                {
                    IEnumerable <EdmError> errors;

                    if (!CsdlWriter.TryWriteCsdl(this.PayloadEdmModel, xmlWriter, CsdlTarget.OData, out errors))
                    {
                        var errorBuilder = new StringBuilder();

                        foreach (var error in errors)
                        {
                            errorBuilder.AppendLine(error.ToString());
                        }

                        throw new Exception("TryWriteEdmx Error:" + errorBuilder);
                    }
                }
            }

            byte[] payload = new byte[testStream.Length];
            testStream.Seek(0, SeekOrigin.Begin);
            testStream.Read(payload, 0, (int)testStream.Length);
            return(payload);
        }
Ejemplo n.º 10
0
        /// <summary>
        /// Applies the specified behavior with default settings.
        /// </summary>
        /// <param name="behaviorKind">The behavior kind to apply.</param>
        /// <returns>A copy of this configuration with the new behavior applied.</returns>
        public ReaderTestConfiguration CloneAndApplyBehavior(TestODataBehaviorKind behaviorKind)
        {
            ReaderTestConfiguration testConfiguration = new ReaderTestConfiguration(this, behaviorKind);

            switch (behaviorKind)
            {
            case TestODataBehaviorKind.Default:
                break;

            case TestODataBehaviorKind.WcfDataServicesClient:
                testConfiguration.MessageReaderSettings.Validations &= ~ValidationKinds.ThrowOnDuplicatePropertyNames;
                testConfiguration.MessageReaderSettings.ClientCustomTypeResolver = null;
                testConfiguration.MessageReaderSettings.Validations &= ~ValidationKinds.ThrowIfTypeConflictsWithMetadata;
                break;

            case TestODataBehaviorKind.WcfDataServicesServer:
                testConfiguration.MessageReaderSettings.Validations &= ~ValidationKinds.ThrowOnDuplicatePropertyNames;
                testConfiguration.MessageReaderSettings.ClientCustomTypeResolver = null;
                testConfiguration.MessageReaderSettings.Validations &= ~ValidationKinds.ThrowIfTypeConflictsWithMetadata;
                // EnableReadingEntryContentInEntryStartState == true
                break;
            }

            return(testConfiguration);
        }
        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="parameterReader">The reader to wrap.</param>
        /// <param name="testConfiguration">The test configuration to use.</param>
        public ODataParameterReaderTestWrapper(ODataParameterReader parameterReader, ReaderTestConfiguration testConfiguration)
        {
            ExceptionUtilities.CheckArgumentNotNull(parameterReader, "parameterReader");
            ExceptionUtilities.CheckArgumentNotNull(testConfiguration, "testConfiguration");

            this.parameterReader = parameterReader;
            this.testConfiguration = testConfiguration;
        }
Ejemplo n.º 12
0
        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="collectionReader">The reader to wrap.</param>
        /// <param name="testConfiguration">The test configuration to use.</param>
        public ODataCollectionReaderTestWrapper(ODataCollectionReader collectionReader, ReaderTestConfiguration testConfiguration)
        {
            ExceptionUtilities.CheckArgumentNotNull(collectionReader, "collectionReader");
            ExceptionUtilities.CheckArgumentNotNull(testConfiguration, "testConfiguration");

            this.collectionReader  = collectionReader;
            this.testConfiguration = testConfiguration;
        }
        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="batchReader">The reader to wrap.</param>
        /// <param name="testConfiguration">The test configuration to use.</param>
        public ODataBatchReaderTestWrapper(ODataBatchReader batchReader, ReaderTestConfiguration testConfiguration)
        {
            ExceptionUtilities.CheckArgumentNotNull(batchReader, "batchReader");
            ExceptionUtilities.CheckArgumentNotNull(testConfiguration, "testConfiguration");

            this.batchReader = batchReader;
            this.testConfiguration = testConfiguration;
        }
Ejemplo n.º 14
0
        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="reader">The reader to wrap.</param>
        /// <param name="testConfiguration">The test configuration to use.</param>
        public ODataReaderTestWrapper(ODataReader reader, ReaderTestConfiguration testConfiguration)
        {
            ExceptionUtilities.CheckArgumentNotNull(reader, "reader");
            ExceptionUtilities.CheckArgumentNotNull(testConfiguration, "testConfiguration");

            this.reader = reader;
            this.testConfiguration = testConfiguration;
        }
        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="collectionReader">The reader to wrap.</param>
        /// <param name="testConfiguration">The test configuration to use.</param>
        public ODataCollectionReaderTestWrapper(ODataCollectionReader collectionReader, ReaderTestConfiguration testConfiguration)
        {
            ExceptionUtilities.CheckArgumentNotNull(collectionReader, "collectionReader");
            ExceptionUtilities.CheckArgumentNotNull(testConfiguration, "testConfiguration");

            this.collectionReader = collectionReader;
            this.testConfiguration = testConfiguration;
        }
        /// <summary>
        /// If overriden dumps the content of an input message which would be created for the specified test configuration
        /// into a string and returns it. This is used only for debugging purposes.
        /// </summary>
        /// <param name="testConfiguration">The test configuration to use.</param>
        /// <returns>The string content of the input message.</returns>
        protected override string DumpInputMessageContent(ReaderTestConfiguration testConfiguration)
        {
            MemoryStream stream     = new MemoryStream();
            TestStream   testStream = new TestStream(stream, true /*ignoreDispose*/);

            this.WriteInputMessageContent(testConfiguration, testStream);
            return(Encoding.UTF8.GetString(stream.GetBuffer(), 0, (int)stream.Length));
        }
        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="parameterReader">The reader to wrap.</param>
        /// <param name="testConfiguration">The test configuration to use.</param>
        public ODataParameterReaderTestWrapper(ODataParameterReader parameterReader, ReaderTestConfiguration testConfiguration)
        {
            ExceptionUtilities.CheckArgumentNotNull(parameterReader, "parameterReader");
            ExceptionUtilities.CheckArgumentNotNull(testConfiguration, "testConfiguration");

            this.parameterReader   = parameterReader;
            this.testConfiguration = testConfiguration;
        }
Ejemplo n.º 18
0
        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="batchReader">The reader to wrap.</param>
        /// <param name="testConfiguration">The test configuration to use.</param>
        public ODataBatchReaderTestWrapper(ODataBatchReader batchReader, ReaderTestConfiguration testConfiguration)
        {
            ExceptionUtilities.CheckArgumentNotNull(batchReader, "batchReader");
            ExceptionUtilities.CheckArgumentNotNull(testConfiguration, "testConfiguration");

            this.batchReader       = batchReader;
            this.testConfiguration = testConfiguration;
        }
        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="reader">The reader to wrap.</param>
        /// <param name="testConfiguration">The test configuration to use.</param>
        public ODataReaderTestWrapper(ODataReader reader, ReaderTestConfiguration testConfiguration)
        {
            ExceptionUtilities.CheckArgumentNotNull(reader, "reader");
            ExceptionUtilities.CheckArgumentNotNull(testConfiguration, "testConfiguration");

            this.reader            = reader;
            this.testConfiguration = testConfiguration;
        }
        /// <summary>
        /// Called to create the input message for the reader test and sets the specified value for the Content-Type header.
        /// </summary>
        /// <param name="testConfiguration">The test configuration.</param>
        /// <returns>The newly created test message to use.</returns>
        protected override TestMessage CreateInputMessage(ReaderTestConfiguration testConfiguration)
        {
            TestMessage testMessage = base.CreateInputMessage(testConfiguration);

            // overwrite the content-type header of the message
            testMessage.SetHeader(ODataConstants.ContentTypeHeader, this.ContentType);

            return testMessage;
        }
Ejemplo n.º 21
0
        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="messageReader">The message reader to wrap.</param>
        /// <param name="testConfiguration">The test configuration to use.</param>
        /// <remarks>
        /// This constructor is used if not special checks against a test message should be performed.
        /// Use the constructor overload that takes a <see cref="TestMessage"/> argument to enforce checks
        /// around disposal of the message.
        /// </remarks>
        public ODataMessageReaderTestWrapper(ODataMessageReader messageReader, ODataMessageReaderSettings messageReaderSettings, ReaderTestConfiguration testConfiguration)
        {
            ExceptionUtilities.CheckArgumentNotNull(messageReader, "messageReader");
            ExceptionUtilities.CheckArgumentNotNull(testConfiguration, "testConfiguration");

            this.messageReader         = messageReader;
            this.messageReaderSettings = messageReaderSettings;
            this.testConfiguration     = testConfiguration;
        }
Ejemplo n.º 22
0
        /// <summary>
        /// Called to create the input message for the reader test and sets the specified value for the Content-Type header.
        /// </summary>
        /// <param name="testConfiguration">The test configuration.</param>
        /// <returns>The newly created test message to use.</returns>
        protected override TestMessage CreateInputMessage(ReaderTestConfiguration testConfiguration)
        {
            TestMessage testMessage = base.CreateInputMessage(testConfiguration);

            // overwrite the content-type header of the message
            testMessage.SetHeader(ODataConstants.ContentTypeHeader, this.ContentType);

            return(testMessage);
        }
        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="messageReader">The message reader to wrap.</param>
        /// <param name="testConfiguration">The test configuration to use.</param>
        /// <remarks>
        /// This constructor is used if not special checks against a test message should be performed. 
        /// Use the constructor overload that takes a <see cref="TestMessage"/> argument to enforce checks
        /// around disposal of the message.
        /// </remarks>
        public ODataMessageReaderTestWrapper(ODataMessageReader messageReader, ODataMessageReaderSettings messageReaderSettings, ReaderTestConfiguration testConfiguration)
        {
            ExceptionUtilities.CheckArgumentNotNull(messageReader, "messageReader");
            ExceptionUtilities.CheckArgumentNotNull(testConfiguration, "testConfiguration");

            this.messageReader = messageReader;
            this.messageReaderSettings = messageReaderSettings;
            this.testConfiguration = testConfiguration;
        }
 /// <summary>
 /// Called to get the expected result of the test.
 /// </summary>
 /// <param name="testConfiguration">The test configuration to use.</param>
 /// <returns>The expected result.</returns>
 protected override ReaderTestExpectedResult GetExpectedResult(ReaderTestConfiguration testConfiguration)
 {
     return(new PayloadKindDetectionTestExpectedResult(this.settings.ExpectedResultSettings)
     {
         TestMessage = this.testMessage,
         ReadDetectedPayloads = this.ReadDetectedPayloads,
         ExpectedDetectionResults = this.ExpectedDetectionResults == null ? null : this.ExpectedDetectionResults(testConfiguration),
         ExpectedException = this.ExpectedException,
     });
 }
Ejemplo n.º 25
0
 /// <summary>
 /// Called before the test is actually executed for the specified test configuration to determine if the test should be skipped.
 /// </summary>
 /// <param name="testConfiguration">The test configuration to use.</param>
 /// <returns>true if the test should be skipped for the <paramref name="testConfiguration"/> or false to run the test.</returns>
 /// <remarks>Derived classes should always call the base class and return true if the base class returned true.</remarks>
 protected virtual bool ShouldSkipForTestConfiguration(ReaderTestConfiguration testConfiguration)
 {
     if (this.SkipTestConfiguration != null)
     {
         return(this.SkipTestConfiguration(testConfiguration));
     }
     else
     {
         return(false);
     }
 }
Ejemplo n.º 26
0
 /// <summary>
 /// Called to get the expected result of the test.
 /// </summary>
 /// <param name="testConfiguration">The test configuration to use.</param>
 /// <returns>The expected result.</returns>
 protected virtual ReaderTestExpectedResult GetExpectedResult(ReaderTestConfiguration testConfiguration)
 {
     if (this.ExpectedResultCallback != null)
     {
         return(this.ExpectedResultCallback(testConfiguration));
     }
     else
     {
         return(null);
     }
 }
Ejemplo n.º 27
0
        /// <summary>
        /// Verifies that the result of the test (the message reader) is what the test expected.
        /// </summary>
        /// <param name="messageReader">The message reader which is the result of the test. This method should use it to read the results
        /// of the parsing and verify those.</param>
        /// <param name="payloadKind">The payload kind specified in the test descriptor.</param>
        /// <param name="testConfiguration">The test configuration to use.</param>
        public override void VerifyResult(
            ODataMessageReaderTestWrapper messageReader,
            ODataPayloadKind payloadKind,
            ReaderTestConfiguration testConfiguration)
        {
            // First compare the payload kind detection results.
            IEnumerable <ODataPayloadKindDetectionResult> actualDetectionResults = messageReader.DetectPayloadKind();

            this.VerifyPayloadKindDetectionResult(actualDetectionResults);

            // Then try to read the message as the detected kind if requested
            if (this.ReadDetectedPayloads)
            {
                bool firstResult = true;
                foreach (PayloadKindDetectionResult result in this.ExpectedDetectionResults)
                {
                    if (firstResult)
                    {
                        // For the first result use the existing message reader
                        firstResult = false;
                    }
                    else
                    {
                        // For all subsequent results we need to reset the test stream and create a new message reader
                        // over it.
                        this.TestMessage.Reset();
                        messageReader = TestReaderUtils.CreateMessageReader(this.TestMessage, result.Model, testConfiguration);

                        // Detect the payload kinds again and make sure we can also read the subsequent payload kinds
                        // immediately after detection.
                        actualDetectionResults = messageReader.DetectPayloadKind();
                        this.VerifyPayloadKindDetectionResult(actualDetectionResults);
                    }

                    TestExceptionUtils.ExpectedException(
                        this.settings.Assert,
                        () =>
                    {
                        using (messageReader)
                        {
                            this.settings.MessageToObjectModelReader.ReadMessage(
                                messageReader,
                                result.PayloadKind,
                                result.Model,
                                new PayloadReaderTestDescriptor.ReaderMetadata(result.ExpectedType),
                                /*expectedBatchPayload*/ null,
                                testConfiguration);
                        }
                    },
                        result.ExpectedException,
                        this.settings.ExceptionVerifier);
                }
            }
        }
        /// <summary>
        /// Verifies that the result of the test (the message reader) is what the test expected.
        /// </summary>
        /// <param name="messageReader">The message reader which is the result of the test. This method should use it to read the results
        /// of the parsing and verify those.</param>
        /// <param name="payloadKind">The payload kind specified in the test descriptor.</param>
        /// <param name="testConfiguration">The test configuration to use.</param>
        public override void VerifyResult(
            ODataMessageReaderTestWrapper messageReader,
            ODataPayloadKind payloadKind,
            ReaderTestConfiguration testConfiguration)
        {
            // First compare the payload kind detection results.
            IEnumerable<ODataPayloadKindDetectionResult> actualDetectionResults = messageReader.DetectPayloadKind();
            this.VerifyPayloadKindDetectionResult(actualDetectionResults);

            // Then try to read the message as the detected kind if requested
            if (this.ReadDetectedPayloads)
            {
                bool firstResult = true;
                foreach (PayloadKindDetectionResult result in this.ExpectedDetectionResults)
                {
                    if (firstResult)
                    {
                        // For the first result use the existing message reader
                        firstResult = false;
                    }
                    else
                    {
                        // For all subsequent results we need to reset the test stream and create a new message reader
                        // over it.
                        this.TestMessage.Reset();
                        messageReader = TestReaderUtils.CreateMessageReader(this.TestMessage, result.Model, testConfiguration);

                        // Detect the payload kinds again and make sure we can also read the subsequent payload kinds
                        // immediately after detection.
                        actualDetectionResults = messageReader.DetectPayloadKind();
                        this.VerifyPayloadKindDetectionResult(actualDetectionResults);
                    }

                    TestExceptionUtils.ExpectedException(
                        this.settings.Assert,
                        () =>
                            {
                                using (messageReader)
                                {
                                    this.settings.MessageToObjectModelReader.ReadMessage(
                                        messageReader,
                                        result.PayloadKind,
                                        result.Model,
                                        new PayloadReaderTestDescriptor.ReaderMetadata(result.ExpectedType),
                                        /*expectedBatchPayload*/ null,
                                        testConfiguration);
                                }
                            },
                        result.ExpectedException,
                        this.settings.ExceptionVerifier);
                }
            }
        }
Ejemplo n.º 29
0
        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="messageReader">The message reader to wrap.</param>
        /// <param name="testConfiguration">The test configuration to use.</param>
        /// <param name="message">The message to read from.</param>
        /// <remarks>
        /// This constructor is used if special checks against <paramref name="message"/> should be performed.
        /// Use the constructor overload that does not take a <see cref="TestMessage"/> argument to prevent any checks
        /// around disposal of the message.
        /// </remarks>
        public ODataMessageReaderTestWrapper(ODataMessageReader messageReader, ODataMessageReaderSettings messageReaderSettings, ReaderTestConfiguration testConfiguration, TestMessage message)
        {
            ExceptionUtilities.CheckArgumentNotNull(messageReader, "messageReader");
            ExceptionUtilities.CheckArgumentNotNull(testConfiguration, "testConfiguration");
            ExceptionUtilities.CheckArgumentNotNull(message, "message");

            this.messageReader         = messageReader;
            this.messageReaderSettings = messageReaderSettings;
            this.testConfiguration     = testConfiguration;
            this.message = message;

            ExceptionUtilities.Assert(this.message.TestStream == null || this.message.TestStream.DisposeCount == 0, "If the underlying message stream is a TestStream, its dispose count must be 0.");
            ExceptionUtilities.Assert(!this.message.StreamRetrieved, "GetMessage and GetMessageAsync must not be called previously on the given message.");
        }
        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="messageReader">The message reader to wrap.</param>
        /// <param name="testConfiguration">The test configuration to use.</param>
        /// <param name="message">The message to read from.</param>
        /// <remarks>
        /// This constructor is used if special checks against <paramref name="message"/> should be performed. 
        /// Use the constructor overload that does not take a <see cref="TestMessage"/> argument to prevent any checks
        /// around disposal of the message.
        /// </remarks>
        public ODataMessageReaderTestWrapper(ODataMessageReader messageReader, ODataMessageReaderSettings messageReaderSettings, ReaderTestConfiguration testConfiguration, TestMessage message)
        {
            ExceptionUtilities.CheckArgumentNotNull(messageReader, "messageReader");
            ExceptionUtilities.CheckArgumentNotNull(testConfiguration, "testConfiguration");
            ExceptionUtilities.CheckArgumentNotNull(message, "message");

            this.messageReader = messageReader;
            this.messageReaderSettings = messageReaderSettings;
            this.testConfiguration = testConfiguration;
            this.message = message;

            ExceptionUtilities.Assert(this.message.TestStream == null || this.message.TestStream.DisposeCount == 0, "If the underlying message stream is a TestStream, its dispose count must be 0.");
            ExceptionUtilities.Assert(!this.message.StreamRetrieved, "GetMessage and GetMessageAsync must not be called previously on the given message.");
        }
 /// <summary>
 /// Called before the test is actually executed for the specified test configuration to determine if the test should be skipped.
 /// </summary>
 /// <param name="testConfiguration">The test configuration to use.</param>
 /// <returns>true if the test should be skipped for the <paramref name="testConfiguration"/> or false to run the test.</returns>
 /// <remarks>Derived classes should always call the base class and return true if the base class returned true.</remarks>
 protected override bool ShouldSkipForTestConfiguration(ReaderTestConfiguration testConfiguration)
 {
     if (this.PayloadDescriptor.SkipTestConfiguration != null && this.PayloadDescriptor.SkipTestConfiguration(testConfiguration))
     {
         return(true);
     }
     else if (this.SkipTestConfiguration != null)
     {
         return(this.SkipTestConfiguration(testConfiguration));
     }
     else
     {
         return(false);
     }
 }
Ejemplo n.º 32
0
        public void EncodingPropertyTest()
        {
            // NOTE: the XmlReader (when created via XmlReader.Create) will use the Xml declaration and/or scan
            //       ahead to detect the encoding from the payload. Only if both fail, do we have the opportunity
            //       to make a difference by specifying the encoding in the content type.
            //
            // Create an non-standard character in the iso-8859-9 (Turkish) encoding
            Encoding iso88599Encoding = Encoding.GetEncoding("iso-8859-9");
            char[] chars = iso88599Encoding.GetChars(new byte[] { 250 });
            string payloadValue = new string(chars);

            var testCases = new[]
            {
                new
                {
                    ContentType = "application/xml",
                    ResultString = payloadValue,
                    ExpectedException = new ExpectedException(typeof(XmlException)),
                },
                new
                {
                    ContentType = "application/xml;charset=iso-8859-9",
                    ResultString = payloadValue,
                    ExpectedException = (ExpectedException)null,
                },
            };

            var testDescriptors = testCases.Select(testCase =>
                new ReaderEncodingTestDescriptor(this.Settings, testCase.ContentType)
                {
                    PayloadElement = PayloadBuilder.PrimitiveProperty(null, payloadValue)
                        .SerializationEncoding("iso-8859-9", /*omitDeclaration*/ true),
                    ExpectedResultPayloadElement = tc => PayloadBuilder.PrimitiveProperty(null, testCase.ResultString),
                    ExpectedException = testCase.ExpectedException,
                }
            );

            this.CombinatorialEngineProvider.RunCombinations(
                testDescriptors,
                this.ReaderTestConfigurationProvider.AtomFormatConfigurations,
                (testDescriptor, testConfiguration) =>
                {
                    testConfiguration = new ReaderTestConfiguration(testConfiguration);
                    testConfiguration.MessageReaderSettings.DisableMessageStreamDisposal = true;

                    testDescriptor.RunTest(testConfiguration);
                });
        }
Ejemplo n.º 33
0
        /// <summary>
        /// Called to get the expected result of the test.
        /// </summary>
        /// <param name="testConfiguration">The test configuration to use.</param>
        /// <returns>The expected result.</returns>
        protected override ReaderTestExpectedResult GetExpectedResult(ReaderTestConfiguration testConfiguration)
        {
            ReaderTestExpectedResult expectedResult = base.GetExpectedResult(testConfiguration);

            if (expectedResult == null)
            {
                return(new MetadataReaderTestExpectedResult(this.settings.ExpectedResultSettings)
                {
                    ExpectedException = this.ExpectedException,
                });
            }
            else
            {
                return(expectedResult);
            }
        }
Ejemplo n.º 34
0
        /// <summary>
        /// Gets The model to use for the specified test configuration.
        /// </summary>
        /// <param name="testConfiguration">The test configuration to use.</param>
        /// <returns>The model to use for the test.</returns>
        protected virtual IEdmModel GetMetadataProvider(ReaderTestConfiguration testConfiguration)
        {
            if (this.cachedModel == null && this.Model != null)
            {
                if (this.Annotations != null)
                {
                    this.cachedModel = EdmModelBuilder.BuildAnnotationModel(this.Annotations, this.Model);
                }
                else
                {
                    this.cachedModel = this.Model;
                }
            }

            return(this.cachedModel);
        }
        /// <summary>
        /// Called to create the input message for the reader test.
        /// </summary>
        /// <param name="testConfiguration">The test configuration.</param>
        /// <returns>The newly created test message to use.</returns>
        protected override TestMessage CreateInputMessage(ReaderTestConfiguration testConfiguration)
        {
            MemoryStream memoryStream = new MemoryStream();

            this.WriteInputMessageContent(testConfiguration, new TestStream(memoryStream, ignoreDispose: true));
            memoryStream.Seek(0, SeekOrigin.Begin);
            TestStream  messageStream = new TestStream(memoryStream);
            TestMessage testMessage   = TestReaderUtils.CreateInputMessageFromStream(
                messageStream,
                testConfiguration,
                this.PayloadKind,
                /*customContentTypeHeader*/ null,
                /*urlResolver*/ null);

            return(testMessage);
        }
        /// <summary>
        /// If overriden dumps additional description of the test descriptor for the specified testConfiguration.
        /// This is used only for debugging purposes.
        /// </summary>
        /// <param name="testConfiguration">The test configuration to use.</param>
        /// <returns>String description of the test.</returns>
        protected override string DumpAdditionalTestDescriptions(ReaderTestConfiguration testConfiguration)
        {
            StringBuilder result = new StringBuilder(base.DumpAdditionalTestDescriptions(testConfiguration));

            if (this.PayloadEdmModel != null)
            {
                result.AppendLine();
                result.AppendLine("PayloadModel CSDL:");

                List <StringBuilder>   stringBuilders = new List <StringBuilder>();
                List <XmlWriter>       xmlWriters     = new List <XmlWriter>();
                IEnumerable <EdmError> errors;
                this.PayloadEdmModel.SetEdmVersion(Microsoft.OData.Edm.Library.EdmConstants.EdmVersionLatest);
                this.PayloadEdmModel.TryWriteCsdl(
                    s =>
                {
                    stringBuilders.Add(new StringBuilder());
                    xmlWriters.Add(XmlWriter.Create(stringBuilders.Last()));

                    return(xmlWriters.Last());
                }, out errors);

                for (int i = 0; i < stringBuilders.Count; i++)
                {
                    xmlWriters[i].Close();
                }

                foreach (var sb in stringBuilders)
                {
                    result.AppendLine(sb.ToString());
                }

                if (this.Annotations != null)
                {
                    result.AppendLine();
                    result.AppendLine("Annotations:");
                    string annotationSchema =
                        "<Schema Namespace='TestModelStandardAnnotations' xmlns='http://docs.oasis-open.org/odata/ns/edm'>" +
                        this.Annotations +
                        "</Schema>";

                    result.AppendLine(XElement.Parse(annotationSchema).ToString());
                }
            }

            return(result.ToString());
        }
        /// <summary>
        /// Gets The model to use for the specified test configuration.
        /// </summary>
        /// <param name="testConfiguration">The test configuration to use.</param>
        /// <returns>The model to use for the test.</returns>
        protected override IEdmModel GetMetadataProvider(ReaderTestConfiguration testConfiguration)
        {
            IEdmModel model = base.GetMetadataProvider(testConfiguration);

            if (model != null)
            {
                return(model);
            }

            // NOTE: get the model from the first result (if any) as the model for the message writer.
            //       This message writer will be used to validate the first result only.
            PayloadKindDetectionResult firstResult = this.ExpectedDetectionResults == null
                ? null
                : this.ExpectedDetectionResults(testConfiguration).FirstOrDefault();

            return(firstResult == null ? null : firstResult.Model);
        }
Ejemplo n.º 38
0
        /// <summary>
        /// Verifies that the result of the test (the message reader) is what the test expected.
        /// </summary>
        /// <param name="messageReader">The message reader which is the result of the test. This method should use it to read the results
        /// of the parsing and verify those.</param>
        /// <param name="payloadKind">The payload kind specified in the test descriptor.</param>
        /// <param name="testConfiguration">The test configuration to use.</param>
        public override void VerifyResult(
            ODataMessageReaderTestWrapper messageReader,
            ODataPayloadKind payloadKind,
            ReaderTestConfiguration testConfiguration)
        {
            object odataObject = this.settings.MessageToObjectModelReader.ReadMessage(
                messageReader,
                payloadKind,
                /*payloadModel*/ null,
                this.ReaderMetadata,
                /*expectedBatchPayload*/ null,
                testConfiguration);

            if (this.ODataObjectModelValidator != null)
            {
                this.ODataObjectModelValidator.ValidateODataObjectModel(odataObject);
            }

            // only compare the payloads if the expected payload is not 'null'; null indicates to skip the comparison
            if (this.ExpectedPayloadElement != null)
            {
                ODataPayloadElement actualPayloadElement = this.settings.ObjectModelToPayloadElementConverter.Convert(odataObject, !testConfiguration.IsRequest);
                if (this.IgnorePropertyOrder)
                {
                    if (testConfiguration.Format == ODataFormat.Json && !testConfiguration.IsRequest)
                    {
                        this.settings.JsonLightResponseIgnorePropertyOrderODataPayloadElementComparer.Compare(this.ExpectedPayloadElement, actualPayloadElement);
                    }
                    else
                    {
                        this.settings.IgnorePropertyOrderODataPayloadElementComparer.Compare(this.ExpectedPayloadElement, actualPayloadElement);
                    }
                }
                else
                {
                    if (testConfiguration.Format == ODataFormat.Json && !testConfiguration.IsRequest)
                    {
                        this.settings.ODataJsonLightResponsePayloadElementComparer.Compare(this.ExpectedPayloadElement, actualPayloadElement);
                    }
                    else
                    {
                        this.settings.ODataPayloadElementComparer.Compare(this.ExpectedPayloadElement, actualPayloadElement);
                    }
                }
            }
        }
Ejemplo n.º 39
0
        /// <summary>
        /// Helper method to create a test message from its content.
        /// </summary>
        /// <param name="messageContent">Stream with the content of the message.</param>
        /// <param name="testConfiguration">The test configuration.</param>
        /// <param name="payloadKind">The payload kind to use to compute and set the content type header; or null if no content type header should be set.</param>
        /// <param name="customContentTypeHeader">A custom content type header to be used in the message.</param>
        /// <param name="urlResolver">Url resolver to add to the test message created.</param>
        /// <returns>Newly created test message.</returns>
        public static TestMessage CreateInputMessageFromStream(
            TestStream messageContent,
            ReaderTestConfiguration testConfiguration,
            ODataPayloadKind?payloadKind,
            string customContentTypeHeader,
            IODataUrlResolver urlResolver)
        {
            TestMessage message;

            if (testConfiguration.IsRequest)
            {
                if (urlResolver != null)
                {
                    message = new TestRequestMessageWithUrlResolver(messageContent, urlResolver, testConfiguration.Synchronous ? TestMessageFlags.NoAsynchronous : TestMessageFlags.NoSynchronous);
                }
                else
                {
                    message = new TestRequestMessage(messageContent, testConfiguration.Synchronous ? TestMessageFlags.NoAsynchronous : TestMessageFlags.NoSynchronous);
                }
            }
            else
            {
                if (urlResolver != null)
                {
                    message = new TestResponseMessageWithUrlResolver(messageContent, urlResolver, testConfiguration.Synchronous ? TestMessageFlags.NoAsynchronous : TestMessageFlags.NoSynchronous);
                }
                else
                {
                    message = new TestResponseMessage(messageContent, testConfiguration.Synchronous ? TestMessageFlags.NoAsynchronous : TestMessageFlags.NoSynchronous);
                }
            }

            // set the OData-Version header
            message.SetHeader(ODataConstants.ODataVersionHeader, testConfiguration.Version.ToText());

            if (customContentTypeHeader != null)
            {
                message.SetHeader(ODataConstants.ContentTypeHeader, customContentTypeHeader);
            }
            else if (payloadKind.HasValue)
            {
                message.SetContentType(testConfiguration.Format, payloadKind.Value);
            }

            return(message);
        }
        /// <summary>
        /// Verifies that the result of the test (the message reader) is what the test expected.
        /// </summary>
        /// <param name="messageReader">The message reader which is the result of the test. This method should use it to read the results
        /// of the parsing and verify those.</param>
        /// <param name="payloadKind">The payload kind specified in the test descriptor.</param>
        /// <param name="testConfiguration">The test configuration to use.</param>
        public override void VerifyResult(
            ODataMessageReaderTestWrapper messageReader,
            ODataPayloadKind payloadKind, 
            ReaderTestConfiguration testConfiguration)
        {
            this.settings.Assert.IsTrue(payloadKind == ODataPayloadKind.MetadataDocument, "Only metadata payload kind is supported.");

            object metadata = this.settings.MessageToObjectModelReader.ReadMessage(
                messageReader, 
                payloadKind,
                /*payloadModel*/ null,
                PayloadReaderTestDescriptor.ReaderMetadata.None,
                /*expectedBatchPayload*/ null,
                testConfiguration);
            IEdmModel actualModel = metadata as IEdmModel;
            this.settings.Assert.IsTrue(metadata != null && actualModel != null, "Expected a non-null model to be read.");
        }
Ejemplo n.º 41
0
        public void TopLevelDeeplyRecursiveErrorTest()
        {
            int depthLimit = 5;

            IEnumerable<PayloadReaderTestDescriptor> testDescriptors = PayloadReaderTestDescriptorGenerator.CreateErrorDeeplyNestedReaderTestDescriptors(this.Settings, depthLimit);

            this.CombinatorialEngineProvider.RunCombinations(
                testDescriptors,
                this.ReaderTestConfigurationProvider.ExplicitFormatConfigurations.Where(tc => !tc.IsRequest),
                (testDescriptor, testConfiguration) =>
                {
                    // Copy the test configuration so we can modify the depth limit.
                    testConfiguration = new ReaderTestConfiguration(testConfiguration);
                    testConfiguration.MessageReaderSettings.MessageQuotas.MaxNestingDepth = depthLimit;

                    testDescriptor.RunTest(testConfiguration);
                });
        }
Ejemplo n.º 42
0
        // TODO: add encoding tests

        /// <summary>
        /// Ignore some test configurations based on the content type since we need to serialize the payloads
        /// with a supported format for that content type.
        /// </summary>
        /// <param name="contentType"></param>
        /// <param name="testConfiguration"></param>
        /// <returns></returns>
        private static bool IgnoreTestConfiguration(string contentType, ReaderTestConfiguration testConfiguration)
        {
            if (testConfiguration.Format != ODataFormat.Json)
            {
                string formatName = testConfiguration.Format == null ? "null" : testConfiguration.Format.GetType().Name;
                throw new NotSupportedException("Unsupported format " + formatName + " for method IgnoreTestConfiguration.");
            }

            return false;
        }
Ejemplo n.º 43
0
        public void ContentTypeHeaderParsingTest()
        {
            IEnumerable<ContentTypeTestCase> testCases = new ContentTypeTestCase[]
            {
                #region Atom test cases
                new ContentTypeTestCase 
                { 
                    // only reading an entry or feed should succeed
                    ContentType = "application/atom+xml;type=feed", 
                    ExpectedFormat = ODataFormat.Atom, 
                },
                new ContentTypeTestCase 
                { 
                    // only reading an entry or feed should succeed
                    ContentType = "application/atom+xml;type=entry", 
                    ExpectedFormat = ODataFormat.Atom, 
                },
                new ContentTypeTestCase 
                { 
                    // reading a feed, an entry, and metadata should succeed
                    ContentType = "application/atom+xml", 
                    ExpectedFormat = ODataFormat.Atom,
                },
                new ContentTypeTestCase 
                { 
                    // reading a property, an entity reference link, entity reference links, a collection, a service document, and an error should succeed
                    ContentType = "application/xml", 
                    ExpectedFormat = ODataFormat.Atom,
                },
                new ContentTypeTestCase 
                { 
                    // reading a property, an entity reference link, entity reference links, and a collection should succeed
                    ContentType = "text/xml", 
                    ExpectedFormat = ODataFormat.Atom,
                },
                new ContentTypeTestCase 
                { 
                    // reading a service document should succeed
                    ContentType = "application/atomsvc+xml", 
                    ExpectedFormat = ODataFormat.Atom, 
                },
                #endregion Atom test cases

                #region RawValue test cases
                new ContentTypeTestCase 
                { 
                    // only reading a raw value will succeed
                    ContentType = "text/plain", 
                    ExpectedFormat = ODataFormat.RawValue,
                    ShouldSucceedForPayloadKind = pk => 
                        pk == ODataPayloadKind.Value 
                        || pk == ODataPayloadKind.BinaryValue,
                },
                new ContentTypeTestCase 
                { 
                    // only reading a raw value or binary value will succeed; raw values can be read as binary values when the content type is application/octet-stream
                    ContentType = "application/octet-stream", 
                    ExpectedFormat = ODataFormat.RawValue, 
                    ShouldSucceedForPayloadKind = pk => 
                        pk == ODataPayloadKind.Value 
                        || pk == ODataPayloadKind.BinaryValue,
                },
                new ContentTypeTestCase 
                { 
                    // only raw value / binary value will succeed
                    ContentType = "multipart/mixed",
                    ExpectedFormat = ODataFormat.RawValue, 
                    ShouldSucceedForPayloadKind = pk => false,
                },
                new ContentTypeTestCase 
                { 
                    // Test for: MimeType allows 0x7F character, but ContentType parsing doesn't
                    ContentType = "application/"+0x7F, 
                    ExpectedFormat = ODataFormat.RawValue,
                    ShouldSucceedForPayloadKind = pk => false,
                },

                #endregion RawValue test cases

                #region JSON Lite test cases
                new ContentTypeTestCase 
                { 
                    // only batch and raw value will fail (batch payload kind tested separately in BatchContentTypeHeaderParsingTest)
                    ContentType = ApplicationJsonODataLight, 
                    ExpectedFormat = ODataFormat.Json, 
                    ShouldSucceedForPayloadKind = pk => 
                        pk != ODataPayloadKind.Value 
                        && pk != ODataPayloadKind.BinaryValue,
                },
                new ContentTypeTestCase 
                { 
                    // only batch and raw value will fail (batch payload kind tested separately in BatchContentTypeHeaderParsingTest)
                    ContentType = ApplicationJsonODataLightStreaming, 
                    ExpectedFormat = ODataFormat.Json, 
                    ShouldSucceedForPayloadKind = pk => 
                        pk != ODataPayloadKind.Value 
                        && pk != ODataPayloadKind.BinaryValue,
                },
                new ContentTypeTestCase 
                { 
                    // only batch and raw value will fail (batch payload kind tested separately in BatchContentTypeHeaderParsingTest)
                    ContentType = ApplicationJsonODataLightNonStreaming, 
                    ExpectedFormat = ODataFormat.Json, 
                    ShouldSucceedForPayloadKind = pk => 
                        pk != ODataPayloadKind.Value 
                        && pk != ODataPayloadKind.BinaryValue,
                },
                #endregion JSON Lite test cases

                #region Error test cases
                new ContentTypeTestCase 
                { 
                    // unsupported content type; everything will fail
                    ContentType = "application/foo", 
                    ShouldSucceedForPayloadKind = pk => false,
                },
                new ContentTypeTestCase 
                { 
                    // unsupported content type with parameters; everything will fail
                    ContentType = "abc/pqr;a=b;c=d",
                    ShouldSucceedForPayloadKind = pk => false,
                },
                new ContentTypeTestCase 
                { 
                    // "image/jpeg" is not supported, even for raw values.
                    ContentType = "image/jpeg",
                    ShouldSucceedForPayloadKind = pk => false,
                },
                #endregion Error test cases

                #region Content Type is null or empty
                new ContentTypeTestCase 
                { 
                    // null content type and zero content length should be default to Json if the payload kind is not binary value or value.
                    ContentType = null,
                    ContentLength = 0,
                    ExpectedFormat = ODataFormat.Json,
                    ShouldSucceedForPayloadKind = pk => true,
                    ShouldIgnoreTest = pk => pk == ODataPayloadKind.BinaryValue || pk == ODataPayloadKind.Value
                },
                new ContentTypeTestCase 
                { 
                    // null content type and zero content length should be default to RawValue if the payload kind is binary value or value.
                    ContentType = null,
                    ContentLength = 0,
                    ExpectedFormat = ODataFormat.RawValue,
                    ShouldSucceedForPayloadKind = pk => true,
                    ShouldIgnoreTest = pk => pk != ODataPayloadKind.Value
                },
                #endregion
            };

            string[] parameters = new string[] 
            {
                "foo=bar",
                "foo1=bar1;foo2=bar2"
            };

            testCases = testCases.Concat(testCases.Where(tc => tc.ContentType != null).SelectMany(tc => parameters.Select(p => new ContentTypeTestCase(tc) { ContentType = tc.ContentType + ";" + p })));

            int oDataPayloadKindCount = EnumExtensionMethods.GetValues<ODataPayloadKind>().Length;
            this.Assert.AreEqual(oDataPayloadKindCount, TestReaderUtils.ODataPayloadKinds.Length, "The number of payload kind have changed, please update this test.");

            IEdmModel model = Microsoft.Test.OData.Utils.Metadata.TestModels.BuildTestModel();

            // We don't support batch payloads here; we test those separately in BatchContentTypeHeaderParsingTest
            IEnumerable<ODataPayloadKind> payloadKinds =
                TestReaderUtils.ODataPayloadKinds.Where(k => k != ODataPayloadKind.Batch && k != ODataPayloadKind.Unsupported);
            this.CombinatorialEngineProvider.RunCombinations(
                testCases,
                payloadKinds,
                this.ReaderTestConfigurationProvider.AllFormatConfigurations,
                (testCase, payloadKind, testConfiguration) =>
                {
                    testConfiguration = new ReaderTestConfiguration(testConfiguration);
                    testConfiguration.MessageReaderSettings.EnableAtom = false;
                    if (IgnoreTestCase(payloadKind, testConfiguration))
                    {
                        return;
                    }

                    if (testCase.ShouldIgnoreTest != null && testCase.ShouldIgnoreTest(payloadKind))
                    {
                        return;
                    }

                    string supportedMediaTypes;

                    if (payloadKind == ODataPayloadKind.Value || payloadKind == ODataPayloadKind.BinaryValue)
                    {
                        supportedMediaTypes = TestMediaTypeUtils.GetSupportedMediaTypes(ODataPayloadKind.Value) + ", " + TestMediaTypeUtils.GetSupportedMediaTypes(ODataPayloadKind.BinaryValue);
                    }
                    else
                    {
                        supportedMediaTypes = TestMediaTypeUtils.GetSupportedMediaTypes(payloadKind, /*includeAppJson*/true);
                    }

                    ExpectedException expectedException = testCase.ExpectedException == null
                         ? testCase.ShouldSucceedForPayloadKind!=null && testCase.ShouldSucceedForPayloadKind(payloadKind)
                             ? null
                             : ODataExpectedExceptions.ODataContentTypeException("MediaTypeUtils_CannotDetermineFormatFromContentType", supportedMediaTypes, testCase.ContentType ?? "")
                         : testCase.ExpectedException;

                    // Make sure to run success test cases only in configurations that will work.
                    if (expectedException == null
                        && testConfiguration.Format != null
                        && testCase.ExpectedFormat != testConfiguration.Format)
                    {
                        return;
                    }

                    ODataPayloadElement payloadElement = CreatePayloadElement(model, payloadKind, testConfiguration);

                    // When we write a value with a content type different than 'text/plain', we will read it as binary.
                    // Likewise, when we write a binary value with a 'text/plain' content type, we will read it as a string.
                    Func<ReaderTestConfiguration, ODataPayloadElement> expectedResultElementFunc = null;
                    if (payloadKind == ODataPayloadKind.Value && testCase.ContentType != null && !testCase.ContentType.StartsWith("text/plain"))
                    {
                        expectedResultElementFunc = (testConfig) => ConvertToBinaryPayloadElement(payloadElement);
                    }
                    else if (payloadKind == ODataPayloadKind.BinaryValue && testCase.ContentType != null && testCase.ContentType.StartsWith("text/plain"))
                    {
                        expectedResultElementFunc = (testConfig) => ConvertToStringPayloadElement(payloadElement);
                    }

                    ODataFormat expectedFormat = testCase.ExpectedFormat;

                    ReaderContentTypeTestDescriptor testDescriptor = new ReaderContentTypeTestDescriptor(this.Settings)
                    {
                        PayloadElement = payloadElement,
                        ExpectedResultPayloadElement = expectedResultElementFunc,
                        PayloadEdmModel = model,
                        ExpectedFormat = expectedFormat,
                        ContentType = testCase.ContentType,
                        ExpectedException = expectedException
                    };

                    testDescriptor.RunTest(testConfiguration);
                    testConfiguration.MessageReaderSettings.EnableAtom = true;
                });
        }
        private void RunMetadataMessageSizeLimitTests(IEdmModel model, MessageSizeLimitTestCase[] testCases)
        {
            this.CombinatorialEngineProvider.RunCombinations(
                testCases,
                this.ReaderTestConfigurationProvider.DefaultFormatConfigurations.Where(tc => !tc.IsRequest && tc.Synchronous),
                (testCase, testConfiguration) =>
                {
                    int size = -1;
                    if (testConfiguration.Format == ODataFormat.Atom && testCase.AtomSizes != null)
                    {
                        size = testConfiguration.IsRequest ? testCase.AtomSizes.RequestSize : testCase.AtomSizes.ResponseSize;
                    }
                    else if (testConfiguration.Format == ODataFormat.Json && testCase.JsonLightSizes != null)
                    {
                        size = testConfiguration.IsRequest ? testCase.JsonLightSizes.RequestSize : testCase.JsonLightSizes.ResponseSize;
                    }
                    else if (testCase.RawSizes != null)
                    {
                        size = testConfiguration.IsRequest ? testCase.RawSizes.RequestSize : testCase.RawSizes.ResponseSize;
                    }

                    ExpectedException expectedException = size < 0
                        ? null
                        : ODataExpectedExceptions.ODataException("MessageStreamWrappingStream_ByteLimitExceeded", size.ToString(), testCase.MaxMessageSize.ToString());

                    var testDescriptor = new MetadataReaderTestDescriptor(this.MetadataSettings)
                    {
                        PayloadEdmModel = model,
                        ExpectedException = expectedException,
                    };

                    if (testCase.MaxMessageSize > 0)
                    {
                        testConfiguration = new ReaderTestConfiguration(testConfiguration);
                        testConfiguration.MessageReaderSettings.MessageQuotas.MaxReceivedMessageSize = testCase.MaxMessageSize;
                    }

                    testDescriptor.RunTest(testConfiguration);
                });
        }
        private void RunMessageSizeLimitTests(
            IEnumerable<ReaderTestConfiguration> testConfigurations,
            EdmModel model,
            ODataPayloadElement payload,
            MessageSizeLimitTestCase[] testCases,
            Func<ReaderTestConfiguration, bool> skipTestConfigurationFunc = null)
        {
            var transformScope = this.Settings.PayloadTransformFactory.EmptyScope();
            using (transformScope.Apply())
            {
                this.CombinatorialEngineProvider.RunCombinations(
                    testCases,
                    testConfigurations,
                    (testCase, testConfiguration) =>
                    {
                        int size = -1;
                        if (testConfiguration.Format == ODataFormat.Atom && testCase.AtomSizes != null)
                        {
                            size = testConfiguration.IsRequest ? testCase.AtomSizes.RequestSize : testCase.AtomSizes.ResponseSize;
                        }
                        else if (testConfiguration.Format == ODataFormat.Json && testCase.JsonLightSizes != null)
                        {
                            size = testConfiguration.IsRequest ? testCase.JsonLightSizes.RequestSize : testCase.JsonLightSizes.ResponseSize;
                        }
                        else if (testCase.RawSizes != null)
                        {
                            size = testConfiguration.IsRequest ? testCase.RawSizes.RequestSize : testCase.RawSizes.ResponseSize;
                        }

                        int maxSize = testCase.MaxMessageSize >= 0 ? testCase.MaxMessageSize : 1024 * 1024;
                        ExpectedException expectedException = size < 0
                            ? null
                            : ODataExpectedExceptions.ODataException("MessageStreamWrappingStream_ByteLimitExceeded", size.ToString(), maxSize.ToString());

                        var testDescriptor = new PayloadReaderTestDescriptor(this.Settings)
                        {
                            PayloadEdmModel = model,
                            PayloadElement = payload.DeepCopy(),
                            ExpectedException = expectedException,
                            SkipTestConfiguration = skipTestConfigurationFunc,
                            ApplyPayloadTransformations = false,
                        };

                        testDescriptor.ExpectedResultNormalizers.Add(
                            tc => (Func<ODataPayloadElement, ODataPayloadElement>)null);

                        if (testCase.MaxMessageSize > 0)
                        {
                            testConfiguration = new ReaderTestConfiguration(testConfiguration);
                            testConfiguration.MessageReaderSettings.MessageQuotas.MaxReceivedMessageSize = testCase.MaxMessageSize;
                        }

                        testDescriptor.RunTest(testConfiguration);
                    });
            }
        }
Ejemplo n.º 46
0
 private static ODataFormat ComputeExpectedFormat(ReaderTestConfiguration testConfiguration, string contentType)
 {
     switch (contentType)
     {
         case ApplicationJson:
         case ApplicationJsonODataLight:
             return ODataFormat.Json;
         default:
             return null;
     }
 }
        /// <summary>
        /// Applies expected result normalizers to the specified payload element.
        /// </summary>
        /// <param name="expectedResultPayloadElement">The payload element to apply the normalizers to.</param>
        /// <param name="testConfiguration">The test configuration to use.</param>
        /// <returns>The expected result after normalization.</returns>
        private ODataPayloadElement ApplyExpectedResultNormalizers(ODataPayloadElement expectedResultPayloadElement, ReaderTestConfiguration testConfiguration)
        {
            // If we have some normalizers and some of them do apply to this test configuration
            // make a copy and apply the normalizer.
            if (this.ExpectedResultNormalizers != null)
            {
                ODataPayloadElement expectedResultPayloadElementCopy = null;
                foreach (var getNormalizerFunc in this.ExpectedResultNormalizers)
                {
                    var normalizer = getNormalizerFunc(testConfiguration);
                    if (normalizer != null)
                    {
                        if (expectedResultPayloadElementCopy == null)
                        {
                            expectedResultPayloadElementCopy = expectedResultPayloadElement.DeepCopy();
                        }

                        expectedResultPayloadElementCopy = normalizer(expectedResultPayloadElementCopy);
                    }
                }

                expectedResultPayloadElement = expectedResultPayloadElementCopy ?? expectedResultPayloadElement;
            }

            return expectedResultPayloadElement;

        }
Ejemplo n.º 48
0
 /// <summary>
 /// Constructor.
 /// </summary>
 /// <param name="other">The <see cref="ReaderTestConfiguration"/> instance used to initialize the new instance.</param>
 /// <param name="behaviorKind">The behavior to use when running this test.</param>
 private ReaderTestConfiguration(ReaderTestConfiguration other, TestODataBehaviorKind behaviorKind)
     : base(other.Format, other.Version, other.IsRequest, behaviorKind)
 {
     this.MessageReaderSettings = new ODataMessageReaderSettings(other.MessageReaderSettings);
     this.Synchronous = other.Synchronous;
 }
Ejemplo n.º 49
0
 /// <summary>
 /// Constructor.
 /// </summary>
 /// <param name="other">The <see cref="ReaderTestConfiguration"/> instance used to initialize the new instance.</param>
 public ReaderTestConfiguration(ReaderTestConfiguration other)
     :this(other, other.RunBehaviorKind)
 {
 }
        /// <summary>
        /// Called to get the expected result of the test.
        /// </summary>
        /// <param name="testConfiguration">The test configuration to use.</param>
        /// <returns>The expected result.</returns>
        protected override ReaderTestExpectedResult GetExpectedResult(ReaderTestConfiguration testConfiguration)
        {
            ReaderTestExpectedResult expectedResult = base.GetExpectedResult(testConfiguration);
            if (expectedResult == null)
            {
                IEdmModel model = this.GetMetadataProvider(testConfiguration);
                ReaderMetadata readerMetadata = new ReaderMetadata(model, this.PayloadElement);

                // First use the input payload as the expected result.
                ODataPayloadElement expectedResultPayloadElement = this.PayloadElement;

                // If we have an override specifically for expected result, use that instead.
                if (this.ExpectedResultPayloadElement != null)
                {
                    expectedResultPayloadElement = this.ExpectedResultPayloadElement(testConfiguration);
                }

                if (expectedResultPayloadElement.ElementType == ODataPayloadElementType.BatchRequestPayload || expectedResultPayloadElement.ElementType == ODataPayloadElementType.BatchResponsePayload)
                {
                    if (this.ExpectedResultNormalizers.Count > 0)
                    {
                        expectedResultPayloadElement = new BatchPayloadExpectedResultNormalizer(
                            testConfiguration,
                            this.ApplyExpectedResultNormalizers).Normalize(expectedResultPayloadElement);
                    }

                    IEdmModel payloadModel = this.GetMetadataProvider(testConfiguration);
                    return new BatchReaderTestExpectedResult(this.settings.BatchExpectedResultSettings)
                    {
                        ExpectedBatchPayload = expectedResultPayloadElement,
                        PayloadModel = payloadModel,
                        ExpectedException = this.ExpectedException,
                    };
                }
                else
                {
                    expectedResultPayloadElement = this.ApplyExpectedResultNormalizers(expectedResultPayloadElement, testConfiguration);
                }

                return new PayloadReaderTestExpectedResult(this.settings.ExpectedResultSettings)
                {
                    ExpectedPayloadElement = expectedResultPayloadElement,
                    ExpectedException = this.ExpectedException,
                    ReaderMetadata = readerMetadata,
                    IgnorePropertyOrder = this.IgnorePropertyOrder,
                };
            }
            else
            {
                PayloadReaderTestExpectedResult payloadReaderTestExpectedResult = expectedResult as PayloadReaderTestExpectedResult;
                if (payloadReaderTestExpectedResult != null && payloadReaderTestExpectedResult.ReaderMetadata == null)
                {
                    IEdmModel model = this.GetMetadataProvider(testConfiguration);
                    payloadReaderTestExpectedResult.ReaderMetadata = new ReaderMetadata(model, this.PayloadElement);
                }

                return expectedResult;
            }
        }
Ejemplo n.º 51
0
 /// <summary>
 /// Applies the specified max protocol version to copy of the settings.
 /// </summary>
 /// <param name="maxProtocolVersion">The max protocol version to apply.</param>
 /// <returns>A copy of this configuration with the max protocol version applied.</returns>
 public ReaderTestConfiguration CloneAndApplyMaxProtocolVersion(ODataVersion maxProtocolVersion)
 {
     ReaderTestConfiguration testConfiguration = new ReaderTestConfiguration(this);
     testConfiguration.MessageReaderSettings.MaxProtocolVersion = maxProtocolVersion;
     return testConfiguration;
 }
        /// <summary>
        /// Gets The model to use for the specified test configuration.
        /// </summary>
        /// <param name="testConfiguration">The test configuration to use.</param>
        /// <returns>The model to use for the test.</returns>
        protected override IEdmModel GetMetadataProvider(ReaderTestConfiguration testConfiguration)
        {
            IEdmModel model = base.GetMetadataProvider(testConfiguration);

            if (model == null)
            {
                // Try to set the cached model if it is null. If the PayloadEdmModel is null cached model will stay null.
                if (this.cachedModel == null)
                {
                    this.cachedModel = this.PayloadEdmModel;
                }

                if (this.cachedModel != null)
                {
                    if (this.Annotations != null)
                    {
                        this.cachedModel = EdmModelBuilder.BuildAnnotationModel(this.Annotations, this.cachedModel);
                    }
                }

                model = this.cachedModel;
            }

            return model;
        }
 /// <summary>
 /// If overridden dumps the content of an input message which would be created for the specified test configuration
 /// into a string and returns it. This is used only for debugging purposes.
 /// </summary>
 /// <param name="testConfiguration">The test configuration to use.</param>
 /// <returns>The string content of the input message.</returns>
 protected override string DumpInputMessageContent(ReaderTestConfiguration testConfiguration)
 {
     byte[] payload = TestReaderUtils.GetPayload(testConfiguration, this.PayloadNormalizers, this.settings, this.PayloadElement);
     return Encoding.UTF8.GetString(payload, 0, payload.Length);
 }
        /// <summary>
        /// If overriden dumps additional description of the test descriptor for the specified testConfiguration.
        /// This is used only for debugging purposes.
        /// </summary>
        /// <param name="testConfiguration">The test configuration to use.</param>
        /// <returns>String description of the test.</returns>
        protected override string DumpAdditionalTestDescriptions(ReaderTestConfiguration testConfiguration)
        {
            StringBuilder result = new StringBuilder(base.DumpAdditionalTestDescriptions(testConfiguration));

            if (this.PayloadEdmModel != null)
            {
                result.AppendLine();
                result.AppendLine("PayloadModel CSDL:");

                List<StringBuilder> stringBuilders = new List<StringBuilder>();
                List<XmlWriter> xmlWriters = new List<XmlWriter>();
                IEnumerable<EdmError> errors;
                this.PayloadEdmModel.SetEdmVersion(Microsoft.OData.Edm.Library.EdmConstants.EdmVersionLatest);
                this.PayloadEdmModel.TryWriteCsdl(
                    s =>
                    {
                        stringBuilders.Add(new StringBuilder());
                        xmlWriters.Add(XmlWriter.Create(stringBuilders.Last()));

                        return xmlWriters.Last();
                    }, out errors);

                for (int i = 0; i < stringBuilders.Count; i++)
                {
                    xmlWriters[i].Close();
                }

                foreach (var sb in stringBuilders)
                {
                    result.AppendLine(sb.ToString());
                }

                if (this.Annotations != null)
                {
                    result.AppendLine();
                    result.AppendLine("Annotations:");
                    string annotationSchema =
                        "<Schema Namespace='TestModelStandardAnnotations' xmlns='http://docs.oasis-open.org/odata/ns/edm'>" +
                            this.Annotations +
                        "</Schema>";

                    result.AppendLine(XElement.Parse(annotationSchema).ToString());
                }
            }

            return result.ToString();
        }
Ejemplo n.º 55
0
        private static bool IgnoreTestCase(ODataPayloadKind payloadKind, ReaderTestConfiguration testConfiguration)
        {
            // TODO: enable unsupported payload kinds when implemented
            if (payloadKind == ODataPayloadKind.MetadataDocument)
            {
                return true;
            }

            // ignore some payloads in requests since they are not allowed
            if (testConfiguration.IsRequest)
            {
                if (payloadKind == ODataPayloadKind.ServiceDocument || payloadKind == ODataPayloadKind.Error || payloadKind == ODataPayloadKind.EntityReferenceLinks)
                {
                    // not allowed in requests
                    return true;
                }
            }
            else
            {
                if (payloadKind == ODataPayloadKind.Parameter)
                {
                    // not allowed in responses
                    return true;
                }
            }

            ODataFormat format = testConfiguration.Format;

            // ignore some payloads in some formats
            switch (payloadKind)
            {
                case ODataPayloadKind.Feed:
                    return format == null;
                case ODataPayloadKind.Entry:
                    return format == null;
                case ODataPayloadKind.Property:
                    return format == null;
                case ODataPayloadKind.EntityReferenceLink:
                    return format == null;
                case ODataPayloadKind.EntityReferenceLinks:
                    return format == null;
                case ODataPayloadKind.Value:
                    return format != null;
                case ODataPayloadKind.BinaryValue:
                    return format != null;
                case ODataPayloadKind.Collection:
                    return format == null;
                case ODataPayloadKind.ServiceDocument:
                    return format == null;
                case ODataPayloadKind.MetadataDocument:
                    return format != null;
                case ODataPayloadKind.Error:
                    return format == null;
                case ODataPayloadKind.Batch:
                    return format != null;
                case ODataPayloadKind.Parameter:
                    return format != ODataFormat.Json;
                case ODataPayloadKind.Unsupported:  // fall through
                default:
                    return true;
            }
        }
Ejemplo n.º 56
0
        /// <summary>
        /// Applies the specified behavior with default settings.
        /// </summary>
        /// <param name="behaviorKind">The behavior kind to apply.</param>
        /// <returns>A copy of this configuration with the new behavior applied.</returns>
        public ReaderTestConfiguration CloneAndApplyBehavior(TestODataBehaviorKind behaviorKind)
        {
            ReaderTestConfiguration testConfiguration = new ReaderTestConfiguration(this, behaviorKind);
            switch (behaviorKind)
            {
                case TestODataBehaviorKind.Default:
                    break;
                case TestODataBehaviorKind.WcfDataServicesClient:
                    testConfiguration.MessageReaderSettings.EnableWcfDataServicesClientBehavior(null);
                    break;
                case TestODataBehaviorKind.WcfDataServicesServer:
                    testConfiguration.MessageReaderSettings.EnableODataServerBehavior();
                    break;
            }

            return testConfiguration;
        }
Ejemplo n.º 57
0
        private static ODataPayloadElement CreatePayloadElement(IEdmModel model, ODataPayloadKind payloadKind, ReaderTestConfiguration testConfig)
        {
            IEdmEntitySet citySet = model.EntityContainer.FindEntitySet("Cities");
            IEdmEntityType cityType = model.EntityTypes().Single(e => e.Name == "CityType");
            IEdmProperty cityNameProperty = cityType.Properties().Single(e => e.Name == "Name");
            IEdmNavigationProperty policeStationNavProp = cityType.NavigationProperties().Single(e => e.Name == "PoliceStation");
            IEdmOperationImport primitiveCollectionResultOperation = model.EntityContainer.FindOperationImports("PrimitiveCollectionResultOperation").Single();
            IEdmOperationImport serviceOp1 = model.EntityContainer.FindOperationImports("ServiceOperation1").Single();

            bool isRequest = testConfig.IsRequest;
            bool isJsonLightRequest = isRequest && testConfig.Format == ODataFormat.Json;
            switch (payloadKind)
            {
                case ODataPayloadKind.Feed:
                    {
                        return PayloadBuilder.EntitySet().WithTypeAnnotation(cityType).ExpectedEntityType(cityType, citySet);
                    }
                case ODataPayloadKind.Entry:
                    {
                        return PayloadBuilder.Entity("TestModel.CityType").PrimitiveProperty("Id", 1).WithTypeAnnotation(cityType).ExpectedEntityType(cityType, citySet);
                    }
                case ODataPayloadKind.Property:
                    return PayloadBuilder.PrimitiveProperty(isJsonLightRequest ? string.Empty : null, "SomeCityValue").ExpectedProperty(cityType, "Name");
                case ODataPayloadKind.EntityReferenceLink:
                    return PayloadBuilder.DeferredLink("http://odata.org/entityreferencelink").ExpectedNavigationProperty(citySet, cityType, "PoliceStation");

                case ODataPayloadKind.EntityReferenceLinks:
                    return PayloadBuilder.LinkCollection().Item(PayloadBuilder.DeferredLink("http://odata.org/entityreferencelink")).ExpectedNavigationProperty((EdmEntitySet)citySet, (EdmEntityType)cityType, "CityHall");

                case ODataPayloadKind.Value:
                    return PayloadBuilder.PrimitiveValue("PrimitiveValue");
                case ODataPayloadKind.BinaryValue:
                    return PayloadBuilder.PrimitiveValue(new byte[] { 0, 0, 1, 1 });
                case ODataPayloadKind.Collection:
                    return PayloadBuilder.PrimitiveCollection().CollectionName(null).ExpectedFunctionImport((EdmOperationImport)primitiveCollectionResultOperation);

                case ODataPayloadKind.ServiceDocument:
                    Debug.Assert(!isRequest, "Not supported in requests.");
                    return new ServiceDocumentInstance().Workspace(PayloadBuilder.Workspace());

                case ODataPayloadKind.MetadataDocument:
                    Debug.Assert(!isRequest, "Not supported in requests.");
                    throw new NotImplementedException();
                case ODataPayloadKind.Error:
                    Debug.Assert(!isRequest, "Not supported in requests.");
                    return PayloadBuilder.Error("ErrorCode");

                case ODataPayloadKind.Parameter:
                    // build parameter payload based on model definition
                    var parameterPayload = new ComplexInstance(null, false);
                    ODataPayloadElement a = PayloadBuilder.PrimitiveValue(123).WithTypeAnnotation(EdmCoreModel.Instance.GetInt32(false));
                    ODataPayloadElement b = PayloadBuilder.PrimitiveValue("stringvalue").WithTypeAnnotation(EdmCoreModel.Instance.GetString(false));
                    PrimitiveProperty parametera = new PrimitiveProperty("a", "Edm.Integer", ((PrimitiveValue)a).ClrValue);
                    PrimitiveProperty parameterb = new PrimitiveProperty("b", "Edm.String", ((PrimitiveValue)b).ClrValue);
                    parameterPayload.Add(parametera);
                    parameterPayload.Add(parameterb);
                    parameterPayload.ExpectedFunctionImport((EdmOperationImport)serviceOp1);
                    return parameterPayload;

                case ODataPayloadKind.Unsupported:  // fall through
                default:
                    throw new NotSupportedException();
            }
        }
 /// <summary>
 /// Called to create the input message for the reader test.
 /// </summary>
 /// <param name="testConfiguration">The test configuration.</param>
 /// <returns>The newly created test message to use.</returns>
 protected override TestMessage CreateInputMessage(ReaderTestConfiguration testConfiguration)
 {
     return TestReaderUtils.CreateInputMessage(testConfiguration, this, this.settings, this.ApplyPayloadTransformations);
 }
 /// <summary>
 /// Called before the test is actually executed for the specified test configuration to determine if the test should be skipped.
 /// </summary>
 /// <param name="testConfiguration">The test configuration to use.</param>
 /// <returns>true if the test should be skipped for the <paramref name="testConfiguration"/> or false to run the test.</returns>
 /// <remarks>Derived classes should always call the base class and return true if the base class returned true.</remarks>
 protected override bool ShouldSkipForTestConfiguration(ReaderTestConfiguration testConfiguration)
 {
     if (this.PayloadDescriptor.SkipTestConfiguration != null && this.PayloadDescriptor.SkipTestConfiguration(testConfiguration))
     {
         return true;
     }
     else if (this.SkipTestConfiguration != null)
     {
         return this.SkipTestConfiguration(testConfiguration);
     }
     else
     {
         return false;
     }
 }
 /// <summary>
 /// Constructor.
 /// </summary>
 /// <param name="batchTestConfiguration">The test configuration for the entire batch payload.</param>
 /// <param name="applyExpectedResultNormalizers">The func which applies expected result normalizers to a payload element.</param>
 public BatchPayloadExpectedResultNormalizer(
     ReaderTestConfiguration batchTestConfiguration,
     Func<ODataPayloadElement, ReaderTestConfiguration, ODataPayloadElement> applyExpectedResultNormalizers)
 {
     this.batchTestConfiguration = batchTestConfiguration;
     this.applyExpectedResultNormalizers = applyExpectedResultNormalizers;
 }