C# MockContent.CopyToAsync方法代码示例

        public void CopyToAsync_ThrowCustomExceptionInOverriddenAsyncMethod_ExceptionBubblesUp()
        {
            var content = new MockContent(new MockException(), MockOptions.ThrowInAsyncSerializeMethods);

            var m = new MemoryStream();
            Assert.Throws<MockException>(() => { Task t = content.CopyToAsync(m); });
        }

        public async Task CopyToAsync_ThrowCustomExceptionInOverriddenMethod_ThrowsMockException()
        {
            var content = new MockContent(new MockException(), MockOptions.ThrowInSerializeMethods);

            var m = new MemoryStream();
            await Assert.ThrowsAsync<MockException>(() => content.CopyToAsync(m));
        }

        public async Task CopyToAsync_ThrowObjectDisposedExceptionInOverriddenAsyncMethod_ThrowsWrappedHttpRequestException()
        {
            var content = new MockContent(new ObjectDisposedException(""), MockOptions.ThrowInAsyncSerializeMethods);

            var m = new MemoryStream();
            HttpRequestException ex = await Assert.ThrowsAsync<HttpRequestException>(() => content.CopyToAsync(m));
            Assert.IsType<ObjectDisposedException>(ex.InnerException);
        }

        public async Task CopyToAsync_ThrowIOExceptionInOverriddenMethod_ThrowsWrappedHttpRequestException()
        {
            var content = new MockContent(new IOException(), MockOptions.ThrowInSerializeMethods);

            Task t = content.CopyToAsync(new MemoryStream());
            HttpRequestException ex = await Assert.ThrowsAsync<HttpRequestException>(() => t);
            Assert.IsType<IOException>(ex.InnerException);
        }

        public async Task CopyToAsync_CallWithMockContent_MockContentMethodCalled()
        {
            var content = new MockContent(MockOptions.CanCalculateLength);
            var m = new MemoryStream();

            await content.CopyToAsync(m);

            Assert.Equal(1, content.SerializeToStreamAsyncCount);
            Assert.Equal(content.GetMockData(), m.ToArray());
        }

 public void CopyToAsync_MockContentReturnsNull_ThrowsInvalidOperationException()
 {
     // return 'null' when CopyToAsync() is called.
     var content = new MockContent(MockOptions.ReturnNullInCopyToAsync); 
     var m = new MemoryStream();
     
     // The HttpContent derived class (MockContent in our case) must return a Task object when WriteToAsync()
     // is called. If not, HttpContent will throw.
     Assert.Throws<InvalidOperationException>(() => { Task t = content.CopyToAsync(m); });
 }

        public async Task Dispose_DisposedObjectThenAccessMembers_ThrowsObjectDisposedException()
        {
            var content = new MockContent();
            content.Dispose();

            var m = new MemoryStream();

            await Assert.ThrowsAsync<ObjectDisposedException>(() => content.CopyToAsync(m));
            await Assert.ThrowsAsync<ObjectDisposedException>(() => content.ReadAsByteArrayAsync());
            await Assert.ThrowsAsync<ObjectDisposedException>(() => content.ReadAsStringAsync());
            await Assert.ThrowsAsync<ObjectDisposedException>(() => content.ReadAsStreamAsync());
            await Assert.ThrowsAsync<ObjectDisposedException>(() => content.LoadIntoBufferAsync());

            // Note that we don't throw when users access the Headers property. This is useful e.g. to be able to 
            // read the headers of a content, even though the content is already disposed. Note that the .NET guidelines
            // only require members to throw ObjectDisposedExcpetion for members "that cannot be used after the object 
            // has been disposed of".
            _output.WriteLine(content.Headers.ToString());
        }

        public async Task CopyToAsync_BufferContentFirst_UseBufferedStreamAsSource()
        {
            var data = new byte[10];
            var content = new MockContent(data);
            content.LoadIntoBufferAsync().Wait();

            Assert.Equal(1, content.SerializeToStreamAsyncCount);
            var destination = new MemoryStream();
            await content.CopyToAsync(destination);

            // Our MockContent should not be called for the CopyTo() operation since the buffered stream should be 
            // used.
            Assert.Equal(1, content.SerializeToStreamAsyncCount);
            Assert.Equal(data.Length, destination.Length);
        }