Imported Upstream version 3.6.0

Former-commit-id: da6be194a6b1221998fc28233f2503bd61dd9d14

external/aspnetwebstack/test/System.Net.Http.Formatting.Test.Unit/Internal/DelegatingStreamTest.cs

@@ -0,0 +1,336 @@
+// Copyright (c) Microsoft Corporation. All rights reserved. See License.txt in the project root for license information.
+
+using System.IO;
+using System.Net.Http.Mocks;
+using Moq;
+using Moq.Protected;
+using Xunit;
+using Assert = Microsoft.TestCommon.AssertEx;
+
+namespace System.Net.Http.Internal
+{
+    public class DelegatingStreamTest
+    {
+        public void DelegatingStream_CtorThrowsOnNull()
+        {
+            Assert.ThrowsArgumentNull(() => new MockDelegatingStream(null), "innerStream");
+        }
+
+        [Fact]
+        public void DelegatingStream_CanRead()
+        {
+            // Arrange
+            Mock<Stream> mockInnerStream = new Mock<Stream>();
+            MockDelegatingStream mockStream = new MockDelegatingStream(mockInnerStream.Object);
+
+            // Act
+            bool canRead = mockStream.CanRead;
+
+            // Assert 
+            mockInnerStream.Verify(s => s.CanRead, Times.Once());
+        }
+
+        [Fact]
+        public void DelegatingStream_CanSeek()
+        {
+            // Arrange
+            Mock<Stream> mockInnerStream = new Mock<Stream>();
+            MockDelegatingStream mockStream = new MockDelegatingStream(mockInnerStream.Object);
+
+            // Act
+            bool canSeek = mockStream.CanSeek;
+
+            // Assert 
+            mockInnerStream.Verify(s => s.CanSeek, Times.Once());
+        }
+
+        [Fact]
+        public void DelegatingStream_CanWrite()
+        {
+            // Arrange
+            Mock<Stream> mockInnerStream = new Mock<Stream>();
+            MockDelegatingStream mockStream = new MockDelegatingStream(mockInnerStream.Object);
+
+            // Act
+            bool canWrite = mockStream.CanWrite;
+
+            // Assert 
+            mockInnerStream.Verify(s => s.CanWrite, Times.Once());
+        }
+
+        [Fact]
+        public void DelegatingStream_Length()
+        {
+            // Arrange
+            Mock<Stream> mockInnerStream = new Mock<Stream>();
+            MockDelegatingStream mockStream = new MockDelegatingStream(mockInnerStream.Object);
+
+            // Act
+            long length = mockStream.Length;
+
+            // Assert 
+            mockInnerStream.Verify(s => s.Length, Times.Once());
+        }
+
+        [Fact]
+        public void DelegatingStream_Position()
+        {
+            // Arrange
+            Mock<Stream> mockInnerStream = new Mock<Stream>();
+            MockDelegatingStream mockStream = new MockDelegatingStream(mockInnerStream.Object);
+
+            // Act
+            long position = mockStream.Position;
+
+            // Assert 
+            mockInnerStream.Verify(s => s.Position, Times.Once());
+        }
+
+        [Fact]
+        public void DelegatingStream_ReadTimeout()
+        {
+            // Arrange
+            Mock<Stream> mockInnerStream = new Mock<Stream>();
+            MockDelegatingStream mockStream = new MockDelegatingStream(mockInnerStream.Object);
+
+            // Act
+            int readTimeout = mockStream.ReadTimeout;
+
+            // Assert 
+            mockInnerStream.Verify(s => s.ReadTimeout, Times.Once());
+        }
+
+        [Fact]
+        public void DelegatingStream_CanTimeout()
+        {
+            // Arrange
+            Mock<Stream> mockInnerStream = new Mock<Stream>();
+            MockDelegatingStream mockStream = new MockDelegatingStream(mockInnerStream.Object);
+
+            // Act
+            bool canTimeout = mockStream.CanTimeout;
+
+            // Assert 
+            mockInnerStream.Verify(s => s.CanTimeout, Times.Once());
+        }
+
+        [Fact]
+        public void DelegatingStream_WriteTimeout()
+        {
+            // Arrange
+            Mock<Stream> mockInnerStream = new Mock<Stream>();
+            MockDelegatingStream mockStream = new MockDelegatingStream(mockInnerStream.Object);
+
+            // Act
+            int writeTimeout = mockStream.WriteTimeout;
+
+            // Assert 
+            mockInnerStream.Verify(s => s.WriteTimeout, Times.Once());
+        }
+
+        [Fact]
+        public void DelegatingStream_Dispose()
+        {
+            // Arrange
+            Mock<Stream> mockInnerStream = new Mock<Stream>() { CallBase = true };
+            MockDelegatingStream mockStream = new MockDelegatingStream(mockInnerStream.Object);
+
+            // Act
+            mockStream.Dispose();
+
+            // Assert 
+            mockInnerStream.Protected().Verify("Dispose", Times.Once(), true);
+            mockInnerStream.Verify(s => s.Close(), Times.Once());
+        }
+
+        [Fact]
+        public void DelegatingStream_Close()
+        {
+            // Arrange
+            Mock<Stream> mockInnerStream = new Mock<Stream>() { CallBase = true };
+            MockDelegatingStream mockStream = new MockDelegatingStream(mockInnerStream.Object);
+
+            // Act
+            mockStream.Close();
+
+            // Assert 
+            mockInnerStream.Protected().Verify("Dispose", Times.Once(), true);
+            mockInnerStream.Verify(s => s.Close(), Times.Once());
+        }
+
+        [Fact]
+        public void DelegatingStream_Seek()
+        {
+            // Arrange
+            Mock<Stream> mockInnerStream = new Mock<Stream>();
+            MockDelegatingStream mockStream = new MockDelegatingStream(mockInnerStream.Object);
+            long offset = 1;
+            SeekOrigin origin = SeekOrigin.End;
+
+            // Act
+            long seek = mockStream.Seek(offset, origin);
+
+            // Assert 
+            mockInnerStream.Verify(s => s.Seek(offset, origin), Times.Once());
+        }
+
+        [Fact]
+        public void DelegatingStream_Read()
+        {
+            // Arrange
+            Mock<Stream> mockInnerStream = new Mock<Stream>();
+            MockDelegatingStream mockStream = new MockDelegatingStream(mockInnerStream.Object);
+            byte[] buffer = new byte[2];
+            int offset = 1;
+            int count = 1;
+
+            // Act
+            mockStream.Read(buffer, offset, count);
+
+            // Assert 
+            mockInnerStream.Verify(s => s.Read(buffer, offset, count), Times.Once());
+        }
+
+        [Fact]
+        public void DelegatingStream_BeginRead()
+        {
+            // Arrange
+            Mock<Stream> mockInnerStream = new Mock<Stream>();
+            MockDelegatingStream mockStream = new MockDelegatingStream(mockInnerStream.Object);
+            byte[] buffer = new byte[2];
+            int offset = 1;
+            int count = 1;
+            AsyncCallback callback = new AsyncCallback((asyncResult) => { });
+            object state = new object();
+
+            // Act
+            mockStream.BeginRead(buffer, offset, count, callback, state);
+
+            // Assert 
+            mockInnerStream.Verify(s => s.BeginRead(buffer, offset, count, callback, state), Times.Once());
+        }
+
+        [Fact]
+        public void DelegatingStream_EndRead()
+        {
+            // Arrange
+            Mock<Stream> mockInnerStream = new Mock<Stream>();
+            MockDelegatingStream mockStream = new MockDelegatingStream(mockInnerStream.Object);
+            Mock<IAsyncResult> mockIAsyncResult = new Mock<IAsyncResult>();
+
+            // Act
+            int endRead = mockStream.EndRead(mockIAsyncResult.Object);
+
+            // Assert 
+            mockInnerStream.Verify(s => s.EndRead(mockIAsyncResult.Object), Times.Once());
+        }
+
+        [Fact]
+        public void DelegatingStream_ReadByte()
+        {
+            // Arrange
+            Mock<Stream> mockInnerStream = new Mock<Stream>();
+            MockDelegatingStream mockStream = new MockDelegatingStream(mockInnerStream.Object);
+
+            // Act
+            int readByte = mockStream.ReadByte();
+
+            // Assert 
+            mockInnerStream.Verify(s => s.ReadByte(), Times.Once());
+        }
+
+        [Fact]
+        public void DelegatingStream_Flush()
+        {
+            // Arrange
+            Mock<Stream> mockInnerStream = new Mock<Stream>();
+            MockDelegatingStream mockStream = new MockDelegatingStream(mockInnerStream.Object);
+
+            // Act
+            mockStream.Flush();
+
+            // Assert 
+            mockInnerStream.Verify(s => s.Flush(), Times.Once());
+        }
+
+        [Fact]
+        public void DelegatingStream_SetLength()
+        {
+            // Arrange
+            Mock<Stream> mockInnerStream = new Mock<Stream>();
+            MockDelegatingStream mockStream = new MockDelegatingStream(mockInnerStream.Object);
+
+            // Act
+            mockStream.SetLength(10L);
+
+            // Assert 
+            mockInnerStream.Verify(s => s.SetLength(10L), Times.Once());
+        }
+
+        [Fact]
+        public void DelegatingStream_Write()
+        {
+            // Arrange
+            Mock<Stream> mockInnerStream = new Mock<Stream>();
+            MockDelegatingStream mockStream = new MockDelegatingStream(mockInnerStream.Object);
+            byte[] buffer = new byte[2];
+            int offset = 1;
+            int count = 1;
+
+            // Act
+            mockStream.Write(buffer, offset, count);
+
+            // Assert 
+            mockInnerStream.Verify(s => s.Write(buffer, offset, count), Times.Once());
+        }
+
+        [Fact]
+        public void DelegatingStream_BeginWrite()
+        {
+            // Arrange
+            Mock<Stream> mockInnerStream = new Mock<Stream>();
+            MockDelegatingStream mockStream = new MockDelegatingStream(mockInnerStream.Object);
+            byte[] buffer = new byte[2];
+            int offset = 1;
+            int count = 1;
+            AsyncCallback callback = new AsyncCallback((asyncResult) => { });
+            object state = new object();
+
+            // Act
+            mockStream.BeginWrite(buffer, offset, count, callback, state);
+
+            // Assert 
+            mockInnerStream.Verify(s => s.BeginWrite(buffer, offset, count, callback, state), Times.Once());
+        }
+
+        [Fact]
+        public void DelegatingStream_EndWrite()
+        {
+            // Arrange
+            Mock<Stream> mockInnerStream = new Mock<Stream>();
+            MockDelegatingStream mockStream = new MockDelegatingStream(mockInnerStream.Object);
+            Mock<IAsyncResult> mockIAsyncResult = new Mock<IAsyncResult>();
+
+            // Act
+            mockStream.EndWrite(mockIAsyncResult.Object);
+
+            // Assert 
+            mockInnerStream.Verify(s => s.EndWrite(mockIAsyncResult.Object), Times.Once());
+        }
+
+        [Fact]
+        public void DelegatingStream_WriteByte()
+        {
+            // Arrange
+            Mock<Stream> mockInnerStream = new Mock<Stream>();
+            MockDelegatingStream mockStream = new MockDelegatingStream(mockInnerStream.Object);
+            byte data = new byte();
+
+            // Act
+            mockStream.WriteByte(data);
+
+            // Assert 
+            mockInnerStream.Verify(s => s.WriteByte(data), Times.Once());
+        }
+    }
+}

external/aspnetwebstack/test/System.Net.Http.Formatting.Test.Unit/Internal/HttpValueCollectionTest.cs

@@ -0,0 +1,138 @@
+// Copyright (c) Microsoft Corporation. All rights reserved. See License.txt in the project root for license information.
+
+using System.Collections.Generic;
+using System.Collections.Specialized;
+using System.Linq;
+using System.Net.Http.Formatting.Internal;
+using Microsoft.TestCommon;
+using Xunit;
+using Xunit.Extensions;
+using Assert = Microsoft.TestCommon.AssertEx;
+
+namespace System.Net.Http.Internal
+{
+    class HttpValueCollectionTest
+    {
+        public static TheoryDataSet<IEnumerable<KeyValuePair<string, string>>> KeyValuePairs
+        {
+            get
+            {
+                return new TheoryDataSet<IEnumerable<KeyValuePair<string, string>>>()
+                {
+                    new List<KeyValuePair<string, string>>
+                    {
+                        new KeyValuePair<string,string>(null, null),
+                        new KeyValuePair<string,string>("n0", ""),
+                        new KeyValuePair<string,string>("n1", "v1"),
+                        new KeyValuePair<string,string>("n@2", "v@2"),
+                        new KeyValuePair<string,string>("n 3", "v 3"),
+                        new KeyValuePair<string,string>("n+4", "v+4"),
+                        new KeyValuePair<string,string>("n;5", "v;5"),
+                    }
+                };
+            }
+        }
+
+        public static TheoryDataSet<NameValueCollection, string> ToStringTestData
+        {
+            get
+            {
+                TheoryDataSet<NameValueCollection, string> dataSet = new TheoryDataSet<NameValueCollection, string>();
+
+                NameValueCollection hvc1 = HttpValueCollection.Create();
+                hvc1.Add(null, null);
+                dataSet.Add(hvc1, "");
+
+                NameValueCollection hvc2 = HttpValueCollection.Create();
+                hvc2.Add("name", null);
+                dataSet.Add(hvc2, "name");
+
+                NameValueCollection hvc3 = HttpValueCollection.Create();
+                hvc3.Add("name", "");
+                dataSet.Add(hvc3, "name");
+
+                NameValueCollection hvc4 = HttpValueCollection.Create();
+                hvc4.Add("na me", "");
+                dataSet.Add(hvc4, "na+me");
+
+                NameValueCollection hvc5 = HttpValueCollection.Create();
+                hvc5.Add("n\",;\\n", "");
+                dataSet.Add(hvc5, "n%22%2c%3b%5cn");
+
+                NameValueCollection hvc6 = HttpValueCollection.Create();
+                hvc6.Add("", "v1");
+                hvc6.Add("", "v2");
+                hvc6.Add("", "v3");
+                hvc6.Add("", "v4");
+                dataSet.Add(hvc6, "=v1&=v2&=v3&=v4");
+
+                NameValueCollection hvc7 = HttpValueCollection.Create();
+                hvc7.Add("n1", "v1");
+                hvc7.Add("n2", "v2");
+                hvc7.Add("n3", "v3");
+                hvc7.Add("n4", "v4");
+                dataSet.Add(hvc7, "n1=v1&n2=v2&n3=v3&n4=v4");
+
+                NameValueCollection hvc8 = HttpValueCollection.Create();
+                hvc8.Add("n,1", "v,1");
+                hvc8.Add("n;2", "v;2");
+                dataSet.Add(hvc8, "n%2c1=v%2c1&n%3b2=v%3b2");
+
+                NameValueCollection hvc9 = HttpValueCollection.Create();
+                hvc9.Add("n1", "&");
+                hvc9.Add("n2", ";");
+                dataSet.Add(hvc9, "n1=%26&n2=%3b");
+
+                NameValueCollection hvc10 = HttpValueCollection.Create();
+                hvc10.Add("n1", "&");
+                hvc10.Add("n2", null);
+                hvc10.Add("n3", "null");
+                dataSet.Add(hvc10, "n1=%26&n2&n3=null");
+
+                return dataSet;
+            }
+        }
+
+        [Fact]
+        public void Create_CreatesEmptyCollection()
+        {
+            NameValueCollection nvc = HttpValueCollection.Create();
+
+            Assert.IsType<HttpValueCollection>(nvc);
+            Assert.Equal(0, nvc.Count);
+        }
+
+        [Theory]
+        [PropertyData("KeyValuePairs")]
+        public void Create_InitializesCorrectly(IEnumerable<KeyValuePair<string, string>> input)
+        {
+            NameValueCollection nvc = HttpValueCollection.Create(input);
+
+            int count = input.Count();
+            Assert.IsType<HttpValueCollection>(nvc);
+            Assert.Equal(count, nvc.Count);
+
+            int index = 0;
+            foreach (KeyValuePair<string, string> kvp in input)
+            {
+                string expectedKey = kvp.Key ?? String.Empty;
+                string expectedValue = kvp.Value ?? String.Empty;
+
+                string actualKey = nvc.AllKeys[index];
+                string actualValue = nvc[index];
+                index++;
+
+                Assert.Equal(expectedKey, actualKey);
+                Assert.Equal(expectedValue, actualValue);
+            }
+        }
+
+        [Theory]
+        [PropertyData("ToStringTestData")]
+        public void ToString_GeneratesCorrectOutput(NameValueCollection input, string expectedOutput)
+        {
+            string actualOutput = input.ToString();
+            Assert.Equal(expectedOutput, actualOutput);
+        }
+    }
+}

external/aspnetwebstack/test/System.Net.Http.Formatting.Test.Unit/Internal/NonClosingDelegatingStreamTest.cs

@@ -0,0 +1,44 @@
+// Copyright (c) Microsoft Corporation. All rights reserved. See License.txt in the project root for license information.
+
+using System.IO;
+using System.Net.Http.Mocks;
+using Moq;
+using Moq.Protected;
+using Xunit;
+using Assert = Microsoft.TestCommon.AssertEx;
+
+namespace System.Net.Http.Internal
+{
+    public class NonClosingDelegatingStreamTest
+    {
+        [Fact]
+        public void NonClosingDelegatingStream_Dispose()
+        {
+            // Arrange
+            Mock<Stream> mockInnerStream = new Mock<Stream>() { CallBase = true };
+            MockNonClosingDelegatingStream mockStream = new MockNonClosingDelegatingStream(mockInnerStream.Object);
+
+            // Act
+            mockStream.Dispose();
+
+            // Assert 
+            mockInnerStream.Protected().Verify("Dispose", Times.Never(), true);
+            mockInnerStream.Verify(s => s.Close(), Times.Never());
+        }
+
+        [Fact]
+        public void NonClosingDelegatingStream_Close()
+        {
+            // Arrange
+            Mock<Stream> mockInnerStream = new Mock<Stream>() { CallBase = true };
+            MockNonClosingDelegatingStream mockStream = new MockNonClosingDelegatingStream(mockInnerStream.Object);
+
+            // Act
+            mockStream.Close();
+
+            // Assert 
+            mockInnerStream.Protected().Verify("Dispose", Times.Never(), true);
+            mockInnerStream.Verify(s => s.Close(), Times.Never());
+        }
+    }
+}