AcceptanceTests.cs

// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License. See License.txt in the project root for license information.
// 

using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using AutoRest.CSharp.Tests.Utilities;
using Fixtures.AcceptanceTestsBodyArray;
using Fixtures.AcceptanceTestsBodyBoolean;
using Fixtures.AcceptanceTestsBodyByte;
using Fixtures.AcceptanceTestsBodyComplex;
using Fixtures.AcceptanceTestsBodyComplex.Models;
using Fixtures.AcceptanceTestsBodyDate;
using Fixtures.AcceptanceTestsBodyDateTime;
using Fixtures.AcceptanceTestsBodyDateTimeRfc1123;
using Fixtures.AcceptanceTestsBodyDictionary;
using Fixtures.AcceptanceTestsBodyDictionary.Models;
using Fixtures.AcceptanceTestsBodyDuration;
using Fixtures.AcceptanceTestsBodyFile;
using Fixtures.AcceptanceTestsBodyFormData;
using Fixtures.AcceptanceTestsBodyInteger;
using Fixtures.AcceptanceTestsBodyNumber;
using Fixtures.AcceptanceTestsBodyString;
using Fixtures.AcceptanceTestsBodyString.Models;
using Fixtures.AcceptanceTestsCompositeBoolIntClient;
using Fixtures.AcceptanceTestsCustomBaseUri;
using Fixtures.AcceptanceTestsCustomBaseUriMoreOptions;
using Fixtures.AcceptanceTestsHeader;
using Fixtures.AcceptanceTestsHeader.Models;
using Fixtures.AcceptanceTestsHttp;
using Fixtures.AcceptanceTestsHttp.Models;
using Fixtures.AcceptanceTestsModelFlattening;
using Fixtures.AcceptanceTestsModelFlattening.Models;
using Fixtures.AcceptanceTestsReport;
using Fixtures.AcceptanceTestsRequiredOptional;
using Fixtures.AcceptanceTestsUrl;
using Fixtures.AcceptanceTestsUrl.Models;
using Fixtures.AcceptanceTestsUrlMultiCollectionFormat;
using Fixtures.AcceptanceTestsValidation;
using Fixtures.AcceptanceTestsValidation.Models;
using Fixtures.InternalCtors;
using Fixtures.PetstoreV2;
using Microsoft.Extensions.Logging;
using Microsoft.Rest;
using Microsoft.Rest.Serialization;
using Newtonsoft.Json;
using Xunit;
using Error = Fixtures.AcceptanceTestsHttp.Models.Error;
using ErrorException = Fixtures.AcceptanceTestsHttp.Models.ErrorException;
using SwaggerPetstoreV2Extensions = Fixtures.PetstoreV2AllSync.SwaggerPetstoreV2Extensions;
using System.Net.Http.Headers;
using System.Reflection;

namespace AutoRest.CSharp.Tests
{
    [Collection("AutoRest Tests")]
    [TestCaseOrderer("AutoRest.CSharp.Tests.AcceptanceTestOrderer",
        "AutoRest.Generator.CSharp.Tests")]
    public class AcceptanceTests : IClassFixture<ServiceController>, IDisposable
    {
        private static readonly TestTracingInterceptor _interceptor;
        private readonly string dummyFile;

        static AcceptanceTests()
        {
            _interceptor = new TestTracingInterceptor();
            ServiceClientTracing.AddTracingInterceptor(_interceptor);
        }

        public AcceptanceTests(ServiceController data)
        {
            Fixture = data;
            Fixture.TearDown = EnsureTestCoverage;
            ServiceClientTracing.IsEnabled = false;
            dummyFile = Path.GetTempFileName();
            File.WriteAllText(dummyFile, "Test file");
        }

        public ServiceController Fixture { get; set; }

        private static string ExpectedPath(string file)
        {
            return Path.Combine("Expected", "AcceptanceTests", file);
        }

        private static string SwaggerPath(string file)
        {
            return Path.Combine("Swagger", file);
        }

        [Fact]
        public void ValidationTests()
        {
            SwaggerSpecRunner.RunTests(
                SwaggerPath("validation.json"),
                ExpectedPath("Validation"));
            var client = new AutoRestValidationTest(Fixture.Uri);
            client.SubscriptionId = "abc123";
            client.ApiVersion = "12-34-5678";
            var exception = Assert.Throws<ValidationException>(() => client.ValidationOfMethodParameters("1", 100));
            Assert.Equal(ValidationRules.MinLength, exception.Rule);
            Assert.Equal("resourceGroupName", exception.Target);
            exception = Assert.Throws<ValidationException>(() => client.ValidationOfMethodParameters("1234567890A", 100));
            Assert.Equal(ValidationRules.MaxLength, exception.Rule);
            Assert.Equal("resourceGroupName", exception.Target);
            exception = Assert.Throws<ValidationException>(() => client.ValidationOfMethodParameters("!@#$", 100));
            Assert.Equal(ValidationRules.Pattern, exception.Rule);
            Assert.Equal("resourceGroupName", exception.Target);
            exception = Assert.Throws<ValidationException>(() => client.ValidationOfMethodParameters("123", 105));
            Assert.Equal(ValidationRules.MultipleOf, exception.Rule);
            Assert.Equal("id", exception.Target);
            exception = Assert.Throws<ValidationException>(() => client.ValidationOfMethodParameters("123", 0));
            Assert.Equal(ValidationRules.InclusiveMinimum, exception.Rule);
            Assert.Equal("id", exception.Target);
            exception = Assert.Throws<ValidationException>(() => client.ValidationOfMethodParameters("123", 2000));
            Assert.Equal(ValidationRules.InclusiveMaximum, exception.Rule);
            Assert.Equal("id", exception.Target);

            exception = Assert.Throws<ValidationException>(() => client.ValidationOfBody("123", 150, new Product
            {
                Capacity = 0
            }));
            Assert.Equal(ValidationRules.ExclusiveMinimum, exception.Rule);
            Assert.Equal("Capacity", exception.Target);
            exception = Assert.Throws<ValidationException>(() => client.ValidationOfBody("123", 150, new Product
            {
                Capacity = 100
            }));
            Assert.Equal(ValidationRules.ExclusiveMaximum, exception.Rule);
            Assert.Equal("Capacity", exception.Target);
            exception = Assert.Throws<ValidationException>(() => client.ValidationOfBody("123", 150, new Product
            {
                DisplayNames = new List<string>
                {
                    "item1",
                    "item2",
                    "item3",
                    "item4",
                    "item5",
                    "item6",
                    "item7"
                }
            }));
            Assert.Equal(ValidationRules.MaxItems, exception.Rule);
            Assert.Equal("DisplayNames", exception.Target);

            var client2 = new AutoRestValidationTest(Fixture.Uri);
            client2.SubscriptionId = "abc123";
            client2.ApiVersion = "abc";
            exception = Assert.Throws<ValidationException>(() => client2.ValidationOfMethodParameters("123", 150));
            Assert.Equal(ValidationRules.Pattern, exception.Rule);
            Assert.Equal("ApiVersion", exception.Target);
        }

        [Fact]
        public void ConstantValuesTests()
        {
            SwaggerSpecRunner.RunTests(
                SwaggerPath("validation.json"),
                ExpectedPath("Validation"));

            var client = new AutoRestValidationTest(Fixture.Uri);
            client.SubscriptionId = "abc123";
            client.ApiVersion = "12-34-5678";
            client.GetWithConstantInPath();
            var product = client.PostWithConstantInBody(new Product());
            Assert.NotNull(product);
        }

        [Fact]
        public void ConstructorWithCredentialsTests()
        {
            var client = new SwaggerPetstoreV2(new TokenCredentials("123"));
            client.Dispose();
        }

        [Fact]
        public void BoolTests()
        {
            SwaggerSpecRunner.RunTests(
                SwaggerPath("body-boolean.json"),
                ExpectedPath("BodyBoolean"));
            var client = new AutoRestBoolTestService(Fixture.Uri);
            Assert.False(client.BoolModel.GetFalse());
            Assert.True(client.BoolModel.GetTrue());
            client.BoolModel.PutTrue(true);
            client.BoolModel.PutFalse(false);
            client.BoolModel.GetNull();
            Assert.Throws<SerializationException>(() => client.BoolModel.GetInvalid());
        }

        [Fact]
        public void IntegerTests()
        {
            SwaggerSpecRunner.RunTests(
                SwaggerPath("body-integer.json"),
                ExpectedPath("BodyInteger"));
            var client = new AutoRestIntegerTestService(Fixture.Uri);
            client.IntModel.PutMax32(int.MaxValue);
            client.IntModel.PutMin32(int.MinValue);
            client.IntModel.PutMax64(long.MaxValue);
            client.IntModel.PutMin64(long.MinValue);
            client.IntModel.PutUnixTimeDate(new DateTime(2016, 4, 13, 0, 0, 0));
            client.IntModel.GetNull();
            Assert.Throws<SerializationException>(() => client.IntModel.GetInvalid());
            Assert.Throws<SerializationException>(() => client.IntModel.GetOverflowInt32());
            Assert.Throws<SerializationException>(() => client.IntModel.GetOverflowInt64());
            Assert.Throws<SerializationException>(() => client.IntModel.GetUnderflowInt32());
            Assert.Throws<SerializationException>(() => client.IntModel.GetUnderflowInt64());
            Assert.Throws<SerializationException>(() => client.IntModel.GetInvalidUnixTime());
            Assert.Null(client.IntModel.GetNullUnixTime());
            Assert.Equal(new DateTime(2016, 4, 13, 0, 0, 0), client.IntModel.GetUnixTime());
        }

        [Fact]
        public void CompositeBoolIntTests()
        {
            SwaggerSpecRunner.RunTests(
                SwaggerPath("composite-swagger.json"),
                ExpectedPath("CompositeBoolIntClient"));
            var client = new CompositeBoolInt(Fixture.Uri);
            Assert.False(client.BoolModel.GetFalse());
            Assert.True(client.BoolModel.GetTrue());
            client.BoolModel.PutTrue(true);
            client.BoolModel.PutFalse(false);
            client.BoolModel.GetNull();
            Assert.Throws<SerializationException>(() => client.BoolModel.GetInvalid());

            client.IntModel.PutMax32(int.MaxValue);
            client.IntModel.PutMin32(int.MinValue);
            client.IntModel.PutMax64(long.MaxValue);
            client.IntModel.PutMin64(long.MinValue);
            client.IntModel.GetNull();
            Assert.Throws<SerializationException>(() => client.IntModel.GetInvalid());
            Assert.Throws<SerializationException>(() => client.IntModel.GetOverflowInt32());
            Assert.Throws<SerializationException>(() => client.IntModel.GetOverflowInt64());
            Assert.Throws<SerializationException>(() => client.IntModel.GetUnderflowInt32());
            Assert.Throws<SerializationException>(() => client.IntModel.GetUnderflowInt64());
        }

        [Fact]
        public void NumberTests()
        {
            SwaggerSpecRunner.RunTests(
                SwaggerPath("body-number.json"), ExpectedPath("BodyNumber"));
            var client = new AutoRestNumberTestService(Fixture.Uri);
            client.Number.PutBigFloat(3.402823e+20);
            client.Number.PutSmallFloat(3.402823e-20);
            client.Number.PutBigDouble(2.5976931e+101);
            client.Number.PutSmallDouble(2.5976931e-101);
            client.Number.PutBigDoubleNegativeDecimal(-99999999.99);
            client.Number.PutBigDoublePositiveDecimal(99999999.99);
            client.Number.GetNull();
            Assert.Equal(3.402823e+20, client.Number.GetBigFloat());
            Assert.Equal(3.402823e-20, client.Number.GetSmallFloat());
            Assert.Equal(2.5976931e+101, client.Number.GetBigDouble());
            Assert.Equal(2.5976931e-101, client.Number.GetSmallDouble());
            Assert.Equal(-99999999.99, client.Number.GetBigDoubleNegativeDecimal());
            Assert.Equal(99999999.99, client.Number.GetBigDoublePositiveDecimal());
            Assert.Throws<SerializationException>(() => client.Number.GetInvalidDouble());
            Assert.Throws<SerializationException>(() => client.Number.GetInvalidFloat());
        }

        [Fact]
        public void StringTests()
        {
            SwaggerSpecRunner.RunTests(
                SwaggerPath("body-string.json"), ExpectedPath("BodyString"));
            using (var client = new AutoRestSwaggerBATService(Fixture.Uri))
            {
                Assert.Null(client.StringModel.GetNull());
                client.StringModel.PutNull(null);
                Assert.Equal(string.Empty, client.StringModel.GetEmpty());
                client.StringModel.PutEmpty("");
                Assert.Equal("啊齄丂狛狜隣郎隣兀﨩ˊ〞〡￤℡㈱‐ー﹡﹢﹫、〓ⅰⅹ⒈€㈠㈩ⅠⅫ！￣ぁんァヶΑ︴АЯаяāɡㄅㄩ─╋︵﹄︻︱︳︴ⅰⅹɑɡ〇〾⿻⺁䜣€",
                    client.StringModel.GetMbcs());
                client.StringModel.PutMbcs("啊齄丂狛狜隣郎隣兀﨩ˊ〞〡￤℡㈱‐ー﹡﹢﹫、〓ⅰⅹ⒈€㈠㈩ⅠⅫ！￣ぁんァヶΑ︴АЯаяāɡㄅㄩ─╋︵﹄︻︱︳︴ⅰⅹɑɡ〇〾⿻⺁䜣€");
                Assert.Equal("    Now is the time for all good men to come to the aid of their country    ",
                    client.StringModel.GetWhitespace());
                client.StringModel.PutWhitespace(
                    "    Now is the time for all good men to come to the aid of their country    ");
                Assert.Null(client.StringModel.GetNotProvided());
                Assert.Equal(Colors.Redcolor, client.EnumModel.GetNotExpandable());
                client.EnumModel.PutNotExpandable(Colors.Redcolor);

                Assert.Equal(Colors.Redcolor, client.EnumModel.GetReferenced());
                client.EnumModel.PutReferenced(Colors.Redcolor);

                Assert.Equal(RefColorConstant.ColorConstant, "green-color");
                Assert.Equal("Sample String", client.EnumModel.GetReferencedConstant().Field1);
                client.EnumModel.PutReferencedConstant();

                var base64UrlEncodedString = client.StringModel.GetBase64UrlEncoded();
                var base64EncodedString = client.StringModel.GetBase64Encoded();
                Assert.Equal(Encoding.UTF8.GetString(base64UrlEncodedString),
                    "a string that gets encoded with base64url");
                Assert.Equal(Encoding.UTF8.GetString(base64EncodedString), "a string that gets encoded with base64");
                Assert.Null(client.StringModel.GetNullBase64UrlEncoded());
                client.StringModel.PutBase64UrlEncoded(
                    Encoding.UTF8.GetBytes("a string that gets encoded with base64url"));
            }
        }

        [Fact]
        public void ByteTests()
        {
            SwaggerSpecRunner.RunTests(
                SwaggerPath("body-byte.json"), ExpectedPath("BodyByte"));
            using (var client = new AutoRestSwaggerBATByteService(Fixture.Uri))
            {
                var bytes = new byte[] {0x0FF, 0x0FE, 0x0FD, 0x0FC, 0x0FB, 0x0FA, 0x0F9, 0x0F8, 0x0F7, 0x0F6};
                client.ByteModel.PutNonAscii(bytes);
                Assert.Equal(bytes, client.ByteModel.GetNonAscii());
                Assert.Null(client.ByteModel.GetNull());
                Assert.Empty(client.ByteModel.GetEmpty());
                Assert.Throws<FormatException>(() => client.ByteModel.GetInvalid());
            }
        }

        [Fact]
        public void FileTests()
        {
            SwaggerSpecRunner.RunTests(
                SwaggerPath("body-file.json"), ExpectedPath("BodyFile"));
            using (var client = new AutoRestSwaggerBATFileService(Fixture.Uri))
            {
                using (var stream = client.Files.GetFile())
                using (var ms = new MemoryStream())
                {
                    stream.CopyTo(ms);
                    Assert.Equal(8725, ms.Length);
                }

                using (var emptyStream = client.Files.GetEmptyFile())
                using (var ms = new MemoryStream())
                {
                    emptyStream.CopyTo(ms);
                    Assert.Equal(0, ms.Length);
                }

                using (var largeFileStream = client.Files.GetFileLarge())
                {
                    //Read the stream into memory a bit at a time to avoid OOM
                    var bytesRead = 0;
                    long totalBytesRead = 0;
                    var buffer = new byte[1024*1024];
                    while ((bytesRead = largeFileStream.Read(buffer, 0, buffer.Length)) > 0)
                    {
                        totalBytesRead += bytesRead;
                    }
                    Assert.Equal(3000L*1024*1024, totalBytesRead);
                }
            }
        }

        [Fact(Skip = "Travis: Cannot access a closed Stream.")]
        public void FormDataFileUploadStreamTests()
        {
            SwaggerSpecRunner.RunTests(
                SwaggerPath("body-formdata.json"), ExpectedPath("BodyFormData"));
            using (var client = new AutoRestSwaggerBATFormDataService(Fixture.Uri))
            {
                const string testString = "Upload file test case";
                var testBytes = new UnicodeEncoding().GetBytes(testString);
                using (Stream memStream = new MemoryStream(100))
                {
                    memStream.Write(testBytes, 0, testBytes.Length);
                    memStream.Seek(0, SeekOrigin.Begin);
                    using (
                        var reader = new StreamReader(client.Formdata.UploadFile(memStream, "UploadFile.txt"),
                            Encoding.Unicode))
                    {
                        var actual = reader.ReadToEnd();
                        Assert.Equal(testString, actual);
                    }
                }
            }
        }

        [Fact(Skip = "Travis: Cannot access a closed Stream.")]
        public void FormDataFileUploadFileStreamTests()
        {
            SwaggerSpecRunner.RunTests(
                SwaggerPath("body-formdata.json"), ExpectedPath("BodyFormData"));

            using (var client = new AutoRestSwaggerBATFormDataService(Fixture.Uri))
            {
                var testString = "Upload file test case";
                var testBytes = new UnicodeEncoding().GetBytes(testString);
                using (var fileStream = File.OpenRead(dummyFile))
                using (var serverStream = new StreamReader(client.Formdata.UploadFile(fileStream, dummyFile)))
                {
                    Assert.Equal(File.ReadAllText(dummyFile), serverStream.ReadToEnd());
                }
            }
        }

        [Fact]
        public void BodyFileUploadTests()
        {
            SwaggerSpecRunner.RunTests(
                SwaggerPath("body-formdata.json"), ExpectedPath("BodyFormData"));
            using (var client = new AutoRestSwaggerBATFormDataService(Fixture.Uri))
            {
                const string testString = "Upload file test case";
                var testBytes = new UnicodeEncoding().GetBytes(testString);
                using (Stream memStream = new MemoryStream(100))
                {
                    memStream.Write(testBytes, 0, testBytes.Length);
                    memStream.Seek(0, SeekOrigin.Begin);
                    using (var reader = new StreamReader(client.Formdata.UploadFileViaBody(memStream), Encoding.Unicode)
                        )
                    {
                        var actual = reader.ReadToEnd();
                        Assert.Equal(testString, actual);
                    }
                }
            }
        }

        [Fact]
        public void DateTests()
        {
            SwaggerSpecRunner.RunTests(
                SwaggerPath("body-date.json"), ExpectedPath("BodyDate"));
            using (var client = new AutoRestDateTestService(Fixture.Uri))
            {
                //We need to configure the Json.net serializer to only send date on the wire. This can be done
                //by setting the {DateFormatString = "yyyy-MM-dd"} of the serializer. The tricky part is to
                //do this only for parameters/properties of format "date" but not "date-time".
                client.Date.PutMaxDate(DateTime.MaxValue);
                client.Date.PutMinDate(DateTime.MinValue);
                client.Date.GetMaxDate();
                client.Date.GetMinDate();
                client.Date.GetNull();
                Assert.Throws<SerializationException>(() => client.Date.GetInvalidDate());
                Assert.Throws<SerializationException>(() => client.Date.GetOverflowDate());
                Assert.Throws<SerializationException>(() => client.Date.GetUnderflowDate());
            }
        }

        [Fact]
        public void DateTimeTests()
        {
            SwaggerSpecRunner.RunTests(
                SwaggerPath("body-datetime.json"), ExpectedPath("BodyDateTime"));
            using (var client = new AutoRestDateTimeTestService(Fixture.Uri))
            {
                client.Datetime.GetUtcLowercaseMaxDateTime();
                client.Datetime.GetUtcUppercaseMaxDateTime();
                client.Datetime.GetUtcMinDateTime();
                client.Datetime.GetLocalNegativeOffsetMinDateTime();
                //overflow-for-dotnet
                Assert.Throws<SerializationException>(() => client.Datetime.GetLocalNegativeOffsetLowercaseMaxDateTime());
                client.Datetime.GetLocalNegativeOffsetUppercaseMaxDateTime();
                //underflow-for-dotnet
                client.Datetime.GetLocalPositiveOffsetMinDateTime();
                client.Datetime.GetLocalPositiveOffsetLowercaseMaxDateTime();
                client.Datetime.GetLocalPositiveOffsetUppercaseMaxDateTime();
                client.Datetime.GetNull();
                client.Datetime.GetOverflow();
                Assert.Throws<SerializationException>(() => client.Datetime.GetInvalid());
                Assert.Throws<SerializationException>(() => client.Datetime.GetUnderflow());
                //The following two calls fail as datetimeoffset are always sent as local time i.e (+00:00) and not Z
                client.Datetime.PutUtcMaxDateTime(DateTime.MaxValue.ToUniversalTime());
                client.Datetime.PutUtcMinDateTime(DateTime.Parse("0001-01-01T00:00:00Z",
                    CultureInfo.InvariantCulture, DateTimeStyles.AdjustToUniversal));
                //underflow-for-dotnet
                client.Datetime.PutLocalPositiveOffsetMinDateTime(DateTime.Parse("0001-01-01T00:00:00+14:00",
                    CultureInfo.InvariantCulture));
                client.Datetime.PutLocalNegativeOffsetMinDateTime(DateTime.Parse("0001-01-01T00:00:00-14:00",
                    CultureInfo.InvariantCulture));
                //overflow-for-dotnet
                Assert.Throws<FormatException>(
                    () =>
                        client.Datetime.PutLocalNegativeOffsetMaxDateTime(
                            DateTime.Parse("9999-12-31T23:59:59.9999999-14:00",
                                CultureInfo.InvariantCulture)));
            }
        }

        [Fact]
        public void DateTimeRfc1123Tests()
        {
            SwaggerSpecRunner.RunTests(
                SwaggerPath("body-datetime-rfc1123.json"), ExpectedPath("BodyDateTimeRfc1123"));
            using (var client = new AutoRestRFC1123DateTimeTestService(Fixture.Uri))
            {
                Assert.Null(client.Datetimerfc1123.GetNull());
                Assert.Throws<SerializationException>(() => client.Datetimerfc1123.GetInvalid());
                Assert.Throws<SerializationException>(() => client.Datetimerfc1123.GetUnderflow());
                Assert.Throws<SerializationException>(() => client.Datetimerfc1123.GetOverflow());
                var d = client.Datetimerfc1123.GetUtcLowercaseMaxDateTime();
                Assert.Equal(DateTimeKind.Utc, d.Value.Kind);

                client.Datetimerfc1123.GetUtcUppercaseMaxDateTime();
                client.Datetimerfc1123.GetUtcMinDateTime();

                client.Datetimerfc1123.PutUtcMaxDateTime(DateTime.MaxValue.ToUniversalTime());
                client.Datetimerfc1123.PutUtcMinDateTime(DateTime.Parse("0001-01-01T00:00:00Z",
                    CultureInfo.InvariantCulture, DateTimeStyles.AdjustToUniversal));
            }
        }

        [Fact]
        public void DurationTests()
        {
            SwaggerSpecRunner.RunTests(
                SwaggerPath("body-duration.json"), ExpectedPath("BodyDuration"));
            using (var client = new AutoRestDurationTestService(Fixture.Uri))
            {
                Assert.Null(client.Duration.GetNull());
                Assert.Throws<FormatException>(() => client.Duration.GetInvalid());

                client.Duration.GetPositiveDuration();
                client.Duration.PutPositiveDuration(new TimeSpan(123, 22, 14, 12, 11));
            }
        }

        [Fact]
        public void ArrayTests()
        {
            SwaggerSpecRunner.RunTests(
                SwaggerPath("body-array.json"), ExpectedPath("BodyArray"));
            using (var client =
                new AutoRestSwaggerBATArrayService(Fixture.Uri))
            {
                Assert.Empty(client.Array.GetEmpty());
                Assert.Null(client.Array.GetNull());
                client.Array.PutEmpty(new List<string>());
                Assert.True(new List<bool?> {true, false, false, true}.SequenceEqual(client.Array.GetBooleanTfft()));
                client.Array.PutBooleanTfft(new List<bool?> {true, false, false, true});
                Assert.True(new List<int?> {1, -1, 3, 300}.SequenceEqual(client.Array.GetIntegerValid()));
                client.Array.PutIntegerValid(new List<int?> {1, -1, 3, 300});
                Assert.True(new List<long?> {1L, -1, 3, 300}.SequenceEqual(client.Array.GetLongValid()));
                client.Array.PutLongValid(new List<long?> {1, -1, 3, 300});
                Assert.True(new List<double?> {0, -0.01, -1.2e20}.SequenceEqual(client.Array.GetFloatValid()));
                client.Array.PutFloatValid(new List<double?> {0, -0.01, -1.2e20});
                Assert.True(new List<double?> {0, -0.01, -1.2e20}.SequenceEqual(client.Array.GetDoubleValid()));
                client.Array.PutDoubleValid(new List<double?> {0, -0.01, -1.2e20});
                Assert.True(new List<string> {"foo1", "foo2", "foo3"}.SequenceEqual(client.Array.GetStringValid()));
                client.Array.PutStringValid(new List<string> {"foo1", "foo2", "foo3"});
                Assert.True(new List<string> {"foo", null, "foo2"}.SequenceEqual(client.Array.GetStringWithNull()));
                Assert.True(new List<string> {"foo", "123", "foo2"}.SequenceEqual(client.Array.GetStringWithInvalid()));
                var date1 = new DateTimeOffset(2000, 12, 01, 0, 0, 0, TimeSpan.Zero).UtcDateTime;
                var date2 = new DateTimeOffset(1980, 1, 2, 0, 0, 0, TimeSpan.Zero).UtcDateTime;
                var date3 = new DateTimeOffset(1492, 10, 12, 0, 0, 0, TimeSpan.Zero).UtcDateTime;
                var datetime1 = new DateTimeOffset(2000, 12, 01, 0, 0, 1, TimeSpan.Zero).UtcDateTime;
                var datetime2 = new DateTimeOffset(1980, 1, 2, 0, 11, 35, TimeSpan.Zero).UtcDateTime;
                var datetime3 = new DateTimeOffset(1492, 10, 12, 10, 15, 1, TimeSpan.Zero).UtcDateTime;
                var dateArray = client.Array.GetDateValid();
                var duration1 = new TimeSpan(123, 22, 14, 12, 11);
                var duration2 = new TimeSpan(5, 1, 0, 0, 0);

                Assert.Equal(new List<DateTime?> {date1, date2, date3}, dateArray);
                client.Array.PutDateValid(new List<DateTime?> {date1, date2, date3});
                Assert.Equal(
                    new List<DateTime?> {datetime1, datetime2, datetime3}, client.Array.GetDateTimeValid());
                client.Array.PutDateTimeValid(new List<DateTime?> {datetime1, datetime2, datetime3});
                dateArray = client.Array.GetDateTimeRfc1123Valid();
                Assert.Equal(new List<DateTime?> {datetime1, datetime2, datetime3}, dateArray);
                client.Array.PutDateTimeRfc1123Valid(dateArray);
                Assert.Equal(new List<TimeSpan?> {duration1, duration2}, client.Array.GetDurationValid());
                client.Array.PutDurationValid(new List<TimeSpan?> {duration1, duration2});
                var bytes1 = new byte[] {0x0FF, 0x0FF, 0x0FF, 0x0FA};
                var bytes2 = new byte[] {0x01, 0x02, 0x03};
                var bytes3 = new byte[] {0x025, 0x029, 0x043};
                var bytes4 = new byte[] {0x0AB, 0x0AC, 0x0AD};
                client.Array.PutByteValid(new List<byte[]> {bytes1, bytes2, bytes3});
                var bytesResult = client.Array.GetByteValid();
                Assert.True(new List<byte[]> {bytes1, bytes2, bytes3}.SequenceEqual(bytesResult,
                    new ByteArrayEqualityComparer()));
                bytesResult = client.Array.GetByteInvalidNull();
                Assert.True(new List<byte[]> {bytes4, null}.SequenceEqual(bytesResult, new ByteArrayEqualityComparer()));
                var testProduct1 = new Fixtures.AcceptanceTestsBodyArray.Models.Product
                {
                    Integer = 1,
                    StringProperty = "2"
                };
                var testProduct2 = new Fixtures.AcceptanceTestsBodyArray.Models.Product
                {
                    Integer = 3,
                    StringProperty = "4"
                };
                var testProduct3 = new Fixtures.AcceptanceTestsBodyArray.Models.Product
                {
                    Integer = 5,
                    StringProperty = "6"
                };
                var testList1 = new List<Fixtures.AcceptanceTestsBodyArray.Models.Product>
                {
                    testProduct1,
                    testProduct2,
                    testProduct3
                };
                Assert.Null(client.Array.GetComplexNull());
                Assert.Empty(client.Array.GetComplexEmpty());
                client.Array.PutComplexValid(testList1);
                Assert.True(testList1.SequenceEqual(client.Array.GetComplexValid(), new ProductEqualityComparer()));
                var listList = new List<IList<string>>
                {
                    new List<string> {"1", "2", "3"},
                    new List<string> {"4", "5", "6"},
                    new List<string> {"7", "8", "9"}
                };

                client.Array.PutArrayValid(listList);
                Assert.True(listList.SequenceEqual(client.Array.GetArrayValid(), new ListEqualityComparer<string>()));
                var listDictionary = new List<IDictionary<string, string>>
                {
                    new Dictionary<string, string> {{"1", "one"}, {"2", "two"}, {"3", "three"}},
                    new Dictionary<string, string> {{"4", "four"}, {"5", "five"}, {"6", "six"}},
                    new Dictionary<string, string> {{"7", "seven"}, {"8", "eight"}, {"9", "nine"}}
                };
                client.Array.PutDictionaryValid(listDictionary);
                Assert.True(listDictionary.SequenceEqual(client.Array.GetDictionaryValid(),
                    new DictionaryEqualityComparer<string>()));
                Assert.Null(client.Array.GetComplexNull());
                Assert.Empty(client.Array.GetComplexEmpty());
                var productList2 = new List<Fixtures.AcceptanceTestsBodyArray.Models.Product>
                {
                    testProduct1,
                    null,
                    testProduct3
                };
                Assert.True(productList2.SequenceEqual(client.Array.GetComplexItemNull(), new ProductEqualityComparer()));
                var productList3 = new List<Fixtures.AcceptanceTestsBodyArray.Models.Product>
                {
                    testProduct1,
                    new Fixtures.AcceptanceTestsBodyArray.Models.Product(),
                    testProduct3
                };
                var emptyComplex = client.Array.GetComplexItemEmpty();
                Assert.True(productList3.SequenceEqual(emptyComplex, new ProductEqualityComparer()));
                Assert.Null(client.Array.GetArrayNull());
                Assert.Empty(client.Array.GetArrayEmpty());
                var listList2 = new List<List<string>>
                {
                    new List<string> {"1", "2", "3"},
                    null,
                    new List<string> {"7", "8", "9"}
                };
                Assert.True(listList2.SequenceEqual(client.Array.GetArrayItemNull(), new ListEqualityComparer<string>()));
                var listList3 = new List<List<string>>
                {
                    new List<string> {"1", "2", "3"},
                    new List<string>(0),
                    new List<string> {"7", "8", "9"}
                };
                Assert.True(listList3.SequenceEqual(client.Array.GetArrayItemEmpty(), new ListEqualityComparer<string>()));
                Assert.Null(client.Array.GetDictionaryNull());
                Assert.Empty(client.Array.GetDictionaryEmpty());
                var listDictionary2 = new List<Dictionary<string, string>>
                {
                    new Dictionary<string, string> {{"1", "one"}, {"2", "two"}, {"3", "three"}},
                    null,
                    new Dictionary<string, string> {{"7", "seven"}, {"8", "eight"}, {"9", "nine"}}
                };
                Assert.True(listDictionary2.SequenceEqual(client.Array.GetDictionaryItemNull(),
                    new DictionaryEqualityComparer<string>()));
                var listDictionary3 = new List<Dictionary<string, string>>
                {
                    new Dictionary<string, string> {{"1", "one"}, {"2", "two"}, {"3", "three"}},
                    new Dictionary<string, string>(0),
                    new Dictionary<string, string> {{"7", "seven"}, {"8", "eight"}, {"9", "nine"}}
                };
                Assert.True(listDictionary3.SequenceEqual(client.Array.GetDictionaryItemEmpty(),
                    new DictionaryEqualityComparer<string>()));

                Assert.Null(client.Array.GetArrayNull());
                Assert.Throws<SerializationException>(() => client.Array.GetInvalid());
                Assert.True(client.Array.GetBooleanInvalidNull().SequenceEqual(new List<bool?> {true, null, false}));
                Assert.Throws<SerializationException>(() => client.Array.GetBooleanInvalidString());
                Assert.True(client.Array.GetIntInvalidNull().SequenceEqual(new List<int?> {1, null, 0}));
                Assert.Throws<SerializationException>(() => client.Array.GetIntInvalidString());
                Assert.True(client.Array.GetLongInvalidNull().SequenceEqual(new List<long?> {1, null, 0}));
                Assert.Throws<SerializationException>(() => client.Array.GetLongInvalidString());
                Assert.True(client.Array.GetFloatInvalidNull().SequenceEqual(new List<double?> {0.0, null, -1.2e20}));
                Assert.Throws<SerializationException>(() => client.Array.GetFloatInvalidString());
                Assert.True(client.Array.GetDoubleInvalidNull().SequenceEqual(new List<double?> {0.0, null, -1.2e20}));
                Assert.Throws<SerializationException>(() => client.Array.GetDoubleInvalidString());
                Assert.True(client.Array.GetStringWithInvalid().SequenceEqual(new List<string> {"foo", "123", "foo2"}));
                var dateNullArray = client.Array.GetDateInvalidNull();
                Assert.True(dateNullArray.SequenceEqual(new List<DateTime?>
                {
                    DateTime.Parse("2012-01-01",
                        CultureInfo.InvariantCulture),
                    null,
                    DateTime.Parse("1776-07-04", CultureInfo.InvariantCulture)
                }));
                Assert.Throws<SerializationException>(() => client.Array.GetDateInvalidChars());
                var dateTimeNullArray = client.Array.GetDateTimeInvalidNull();
                Assert.True(dateTimeNullArray.SequenceEqual(new List<DateTime?>
                {
                    DateTime.Parse("2000-12-01t00:00:01z",
                        CultureInfo.InvariantCulture).ToUniversalTime(),
                    null
                }));
                Assert.Throws<SerializationException>(() => client.Array.GetDateTimeInvalidChars());

                var guid1 = new Guid("6DCC7237-45FE-45C4-8A6B-3A8A3F625652");
                var guid2 = new Guid("D1399005-30F7-40D6-8DA6-DD7C89AD34DB");
                var guid3 = new Guid("F42F6AA1-A5BC-4DDF-907E-5F915DE43205");
                Assert.Equal(new List<Guid?> {guid1, guid2, guid3}, client.Array.GetUuidValid());
                client.Array.PutUuidValid(new List<Guid?> {guid1, guid2, guid3});
                Assert.Throws<SerializationException>(() => client.Array.GetUuidInvalidChars());

                var base64Url1 = Encoding.UTF8.GetBytes("a string that gets encoded with base64url");
                var base64Url2 = Encoding.UTF8.GetBytes("test string");
                var base64Url3 = Encoding.UTF8.GetBytes("Lorem ipsum");
                Assert.Equal(new List<byte[]> {base64Url1, base64Url2, base64Url3}, client.Array.GetBase64Url());
            }
        }

        [Fact]
        public void DictionaryTests()
        {
            SwaggerSpecRunner.RunTests(
                SwaggerPath("body-dictionary.json"), ExpectedPath("BodyDictionary"));
            using (var client =
                new AutoRestSwaggerBATdictionaryService(Fixture.Uri))
            {
                TestBasicDictionaryParsing(client);
                TestDictionaryPrimitiveTypes(client);
                TestDictionaryComposedTypes(client);
            }
        }

        private static void TestDictionaryComposedTypes(AutoRestSwaggerBATdictionaryService client)
        {
            var testProduct1 = new Widget {Integer = 1, StringProperty = "2"};
            var testProduct2 = new Widget {Integer = 3, StringProperty = "4"};
            var testProduct3 = new Widget {Integer = 5, StringProperty = "6"};
            var testDictionary1 = new Dictionary<string, Widget>
            {
                {"0", testProduct1},
                {"1", testProduct2},
                {"2", testProduct3}
            };
            // GET complex/null
            Assert.Null(client.Dictionary.GetComplexNull());
            // GET complex/empty
            Assert.Empty(client.Dictionary.GetComplexEmpty());
            // PUT complex/valid
            client.Dictionary.PutComplexValid(testDictionary1);
            // GET complex/valid
            var complexResult = client.Dictionary.GetComplexValid();
            foreach (var key in testDictionary1.Keys)
            {
                Assert.True(complexResult.ContainsKey(key));
                Assert.Equal(testDictionary1[key], complexResult[key], new WidgetEqualityComparer());
            }
            var listDictionary = new Dictionary<string, IList<string>>
            {
                {"0", new List<string> {"1", "2", "3"}},
                {"1", new List<string> {"4", "5", "6"}},
                {"2", new List<string> {"7", "8", "9"}}
            };
            // PUT array/valid
            client.Dictionary.PutArrayValid(listDictionary);
            // GET array/valid
            var arrayResult = client.Dictionary.GetArrayValid();
            foreach (var key in listDictionary.Keys)
            {
                Assert.True(arrayResult.ContainsKey(key));
                Assert.Equal(listDictionary[key], arrayResult[key], new ListEqualityComparer<string>());
            }
            var dictionaryDictionary = new Dictionary<string, IDictionary<string, string>>
            {
                {"0", new Dictionary<string, string> {{"1", "one"}, {"2", "two"}, {"3", "three"}}},
                {"1", new Dictionary<string, string> {{"4", "four"}, {"5", "five"}, {"6", "six"}}},
                {"2", new Dictionary<string, string> {{"7", "seven"}, {"8", "eight"}, {"9", "nine"}}}
            };
            // PUT dictionary/valid
            client.Dictionary.PutDictionaryValid(dictionaryDictionary);
            // GET dictionary/valid
            var dictionaryResult = client.Dictionary.GetDictionaryValid();
            foreach (var key in dictionaryDictionary.Keys)
            {
                Assert.True(dictionaryResult.ContainsKey(key));
                Assert.Equal(dictionaryDictionary[key], dictionaryResult[key],
                    new DictionaryEqualityComparer<string>());
            }
            // GET dictionary/null
            Assert.Null(client.Dictionary.GetComplexNull());
            // GET dictionary/empty
            Assert.Empty(client.Dictionary.GetComplexEmpty());
            var productDictionary2 = new Dictionary<string, Widget>
            {
                {"0", testProduct1},
                {"1", null},
                {"2", testProduct3}
            };
            // GET complex/itemnull
            complexResult = client.Dictionary.GetComplexItemNull();
            foreach (var key in productDictionary2.Keys)
            {
                Assert.True(complexResult.ContainsKey(key));
                Assert.Equal(productDictionary2[key], complexResult[key], new WidgetEqualityComparer());
            }
            // GET complex/itemempty
            var productList3 = new Dictionary<string, Widget>
            {
                {"0", testProduct1},
                {"1", new Widget()},
                {"2", testProduct3}
            };
            complexResult = client.Dictionary.GetComplexItemEmpty();
            foreach (var key in productList3.Keys)
            {
                Assert.True(complexResult.ContainsKey(key));
                Assert.Equal(productList3[key], complexResult[key], new WidgetEqualityComparer());
            }
            // GET array/null
            Assert.Null(client.Dictionary.GetArrayNull());
            // GET array/empty
            Assert.Empty(client.Dictionary.GetArrayEmpty());
            listDictionary = new Dictionary<string, IList<string>>
            {
                {"0", new List<string> {"1", "2", "3"}},
                {"1", null},
                {"2", new List<string> {"7", "8", "9"}}
            };
            // GET array/itemnull
            arrayResult = client.Dictionary.GetArrayItemNull();
            foreach (var key in listDictionary.Keys)
            {
                Assert.True(arrayResult.ContainsKey(key));
                Assert.Equal(listDictionary[key], arrayResult[key], new ListEqualityComparer<string>());
            }
            listDictionary = new Dictionary<string, IList<string>>
            {
                {"0", new List<string> {"1", "2", "3"}},
                {"1", new List<string>(0)},
                {"2", new List<string> {"7", "8", "9"}}
            };
            // GET array/itemempty
            arrayResult = client.Dictionary.GetArrayItemEmpty();
            foreach (var key in listDictionary.Keys)
            {
                Assert.True(arrayResult.ContainsKey(key));
                Assert.Equal(listDictionary[key], arrayResult[key], new ListEqualityComparer<string>());
            }
            // GET dictionary/null
            Assert.Null(client.Dictionary.GetDictionaryNull());
            // GET dictionary/empty
            Assert.Empty(client.Dictionary.GetDictionaryEmpty());
            dictionaryDictionary = new Dictionary<string, IDictionary<string, string>>
            {
                {"0", new Dictionary<string, string> {{"1", "one"}, {"2", "two"}, {"3", "three"}}},
                {"1", null},
                {"2", new Dictionary<string, string> {{"7", "seven"}, {"8", "eight"}, {"9", "nine"}}}
            };
            // GET dictionary/itemnull
            dictionaryResult = client.Dictionary.GetDictionaryItemNull();
            foreach (var key in dictionaryDictionary.Keys)
            {
                Assert.True(dictionaryResult.ContainsKey(key));
                Assert.Equal(dictionaryDictionary[key], dictionaryResult[key],
                    new DictionaryEqualityComparer<string>());
            }
            dictionaryDictionary = new Dictionary<string, IDictionary<string, string>>
            {
                {"0", new Dictionary<string, string> {{"1", "one"}, {"2", "two"}, {"3", "three"}}},
                {"1", new Dictionary<string, string>(0)},
                {"2", new Dictionary<string, string> {{"7", "seven"}, {"8", "eight"}, {"9", "nine"}}}
            };
            // GET dictionary/itemempty
            dictionaryResult = client.Dictionary.GetDictionaryItemEmpty();
            foreach (var key in dictionaryDictionary.Keys)
            {
                Assert.True(dictionaryResult.ContainsKey(key));
                Assert.Equal(dictionaryDictionary[key], dictionaryResult[key],
                    new DictionaryEqualityComparer<string>());
            }
        }

        private static void TestDictionaryPrimitiveTypes(AutoRestSwaggerBATdictionaryService client)
        {
            var tfft = new Dictionary<string, bool?> {{"0", true}, {"1", false}, {"2", false}, {"3", true}};
            // GET prim/boolean/tfft
            Assert.Equal(tfft, client.Dictionary.GetBooleanTfft());
            // PUT prim/boolean/tfft
            client.Dictionary.PutBooleanTfft(tfft);
            var invalidNullDict = new Dictionary<string, bool?>
            {
                {"0", true},
                {"1", null},
                {"2", false}
            };

            Assert.Equal(invalidNullDict, client.Dictionary.GetBooleanInvalidNull());
            Assert.Throws<SerializationException>(() => client.Dictionary.GetBooleanInvalidString());
            var intValid = new Dictionary<string, int?> {{"0", 1}, {"1", -1}, {"2", 3}, {"3", 300}};
            // GET prim/integer/1.-1.3.300
            Assert.Equal(intValid, client.Dictionary.GetIntegerValid());
            // PUT prim/integer/1.-1.3.300
            client.Dictionary.PutIntegerValid(intValid);
            var intNullDict = new Dictionary<string, int?> {{"0", 1}, {"1", null}, {"2", 0}};
            Assert.Equal(intNullDict, client.Dictionary.GetIntInvalidNull());
            Assert.Throws<SerializationException>(() => client.Dictionary.GetIntInvalidString());

            var longValid = new Dictionary<string, long?> {{"0", 1L}, {"1", -1}, {"2", 3}, {"3", 300}};
            // GET prim/long/1.-1.3.300
            Assert.Equal(longValid, client.Dictionary.GetLongValid());
            // PUT prim/long/1.-1.3.300
            client.Dictionary.PutLongValid(longValid);
            var longNullDict = new Dictionary<string, long?> {{"0", 1}, {"1", null}, {"2", 0}};
            Assert.Equal(longNullDict, client.Dictionary.GetLongInvalidNull());
            Assert.Throws<SerializationException>(() => client.Dictionary.GetLongInvalidString());

            var floatValid = new Dictionary<string, double?> {{"0", 0}, {"1", -0.01}, {"2", -1.2e20}};
            // GET prim/float/0--0.01-1.2e20
            Assert.Equal(floatValid, client.Dictionary.GetFloatValid());
            // PUT prim/float/0--0.01-1.2e20
            client.Dictionary.PutFloatValid(floatValid);
            var floatNullDict = new Dictionary<string, double?> {{"0", 0.0}, {"1", null}, {"2", -1.2e20}};
            Assert.Equal(floatNullDict, client.Dictionary.GetFloatInvalidNull());
            Assert.Throws<SerializationException>(() => client.Dictionary.GetFloatInvalidString());
            var doubleValid = new Dictionary<string, double?> {{"0", 0}, {"1", -0.01}, {"2", -1.2e20}};
            // GET prim/double/0--0.01-1.2e20
            Assert.Equal(doubleValid, client.Dictionary.GetDoubleValid());
            // PUT prim/double/0--0.01-1.2e20
            client.Dictionary.PutDoubleValid(doubleValid);
            floatNullDict = new Dictionary<string, double?> {{"0", 0.0}, {"1", null}, {"2", -1.2e20}};
            Assert.Equal(floatNullDict, client.Dictionary.GetDoubleInvalidNull());
            Assert.Throws<SerializationException>(() => client.Dictionary.GetDoubleInvalidString());
            var stringValid = new Dictionary<string, string> {{"0", "foo1"}, {"1", "foo2"}, {"2", "foo3"}};
            // GET prim/string/foo1.foo2.foo3
            Assert.Equal(stringValid, client.Dictionary.GetStringValid());
            // PUT prim/string/foo1.foo2.foo3
            client.Dictionary.PutStringValid(stringValid);
            var stringNullDict = new Dictionary<string, string> {{"0", "foo"}, {"1", null}, {"2", "foo2"}};
            var stringInvalidDict = new Dictionary<string, string> {{"0", "foo"}, {"1", "123"}, {"2", "foo2"}};
            Assert.Equal(stringNullDict, client.Dictionary.GetStringWithNull());
            Assert.Equal(stringInvalidDict, client.Dictionary.GetStringWithInvalid());
            var date1 = new DateTimeOffset(2000, 12, 01, 0, 0, 0, TimeSpan.FromHours(0)).UtcDateTime;
            var date2 = new DateTimeOffset(1980, 1, 2, 0, 0, 0, TimeSpan.FromHours(0)).UtcDateTime;
            var date3 = new DateTimeOffset(1492, 10, 12, 0, 0, 0, TimeSpan.FromHours(0)).UtcDateTime;
            var datetime1 = new DateTimeOffset(2000, 12, 01, 0, 0, 1, TimeSpan.Zero).UtcDateTime;
            var datetime2 = new DateTimeOffset(1980, 1, 2, 0, 11, 35, TimeSpan.FromHours(1)).UtcDateTime;
            var datetime3 = new DateTimeOffset(1492, 10, 12, 10, 15, 1, TimeSpan.FromHours(-8)).UtcDateTime;
            var rfcDatetime1 = new DateTimeOffset(2000, 12, 01, 0, 0, 1, TimeSpan.Zero).UtcDateTime;
            var rfcDatetime2 = new DateTimeOffset(1980, 1, 2, 0, 11, 35, TimeSpan.Zero).UtcDateTime;
            var rfcDatetime3 = new DateTimeOffset(1492, 10, 12, 10, 15, 1, TimeSpan.Zero).UtcDateTime;
            var duration1 = new TimeSpan(123, 22, 14, 12, 11);
            var duration2 = new TimeSpan(5, 1, 0, 0, 0);

            // GET prim/date/valid
            var dateDictionary = client.Dictionary.GetDateValid();
            Assert.Equal(new Dictionary<string, DateTime?> {{"0", date1}, {"1", date2}, {"2", date3}},
                dateDictionary);
            client.Dictionary.PutDateValid(new Dictionary<string, DateTime?>
            {
                {"0", date1},
                {"1", date2},
                {"2", date3}
            });
            var dateNullDict = new Dictionary<string, DateTime?>
            {
                {"0", new DateTime(2012, 1, 1, 0, 0, 0, DateTimeKind.Utc)},
                {"1", null},
                {"2", new DateTime(1776, 7, 4, 0, 0, 0, DateTimeKind.Utc)}
            };
            Assert.Equal(dateNullDict, client.Dictionary.GetDateInvalidNull());
            Assert.Throws<SerializationException>(() => client.Dictionary.GetDateInvalidChars());
            // GET prim/datetime/valid
            Assert.Equal(new Dictionary<string, DateTime?> {{"0", datetime1}, {"1", datetime2}, {"2", datetime3}},
                client.Dictionary.GetDateTimeValid());
            client.Dictionary.PutDateTimeValid(new Dictionary<string, DateTime?>
            {
                {"0", datetime1},
                {"1", datetime2},
                {"2", datetime3}
            });
            var datetimeNullDict = new Dictionary<string, DateTime?>
            {
                {"0", new DateTime(2000, 12, 1, 0, 0, 1, DateTimeKind.Utc)},
                {"1", null}
            };
            Assert.Equal(datetimeNullDict, client.Dictionary.GetDateTimeInvalidNull());
            Assert.Throws<SerializationException>(() => client.Dictionary.GetDateTimeInvalidChars());
            // GET prim/datetimerfc1123/valid
            Assert.Equal(
                new Dictionary<string, DateTime?> {{"0", rfcDatetime1}, {"1", rfcDatetime2}, {"2", rfcDatetime3}},
                client.Dictionary.GetDateTimeRfc1123Valid());
            client.Dictionary.PutDateTimeRfc1123Valid(new Dictionary<string, DateTime?>
            {
                {"0", rfcDatetime1},
                {"1", rfcDatetime2},
                {"2", rfcDatetime3}
            });
            // GET prim/duration/valid
            Assert.Equal(new Dictionary<string, TimeSpan?> {{"0", duration1}, {"1", duration2}},
                client.Dictionary.GetDurationValid());
            client.Dictionary.PutDurationValid(new Dictionary<string, TimeSpan?>
            {
                {"0", duration1},
                {"1", duration2}
            });
            var bytes1 = new byte[] {0x0FF, 0x0FF, 0x0FF, 0x0FA};
            var bytes2 = new byte[] {0x01, 0x02, 0x03};
            var bytes3 = new byte[] {0x025, 0x029, 0x043};
            var bytes4 = new byte[] {0x0AB, 0x0AC, 0x0AD};
            // PUT prim/byte/valid
            var bytesValid = new Dictionary<string, byte[]> {{"0", bytes1}, {"1", bytes2}, {"2", bytes3}};
            client.Dictionary.PutByteValid(bytesValid);
            // GET prim/byte/valid
            var bytesResult = client.Dictionary.GetByteValid();
            foreach (var key in bytesValid.Keys)
            {
                Assert.True(bytesResult.ContainsKey(key));
                Assert.Equal(bytesValid[key], bytesResult[key], new ByteArrayEqualityComparer());
            }
            // GET prim/byte/invalidnull
            var bytesNull = new Dictionary<string, byte[]> {{"0", bytes4}, {"1", null}};
            bytesResult = client.Dictionary.GetByteInvalidNull();
            foreach (var key in bytesNull.Keys)
            {
                Assert.True(bytesResult.ContainsKey(key));
                Assert.Equal(bytesNull[key], bytesResult[key], new ByteArrayEqualityComparer());
            }
            // GET prim/base64url/valid
            var base64UrlString1 = Encoding.UTF8.GetBytes("a string that gets encoded with base64url");
            var base64UrlString2 = Encoding.UTF8.GetBytes("test string");
            var base64UrlString3 = Encoding.UTF8.GetBytes("Lorem ipsum");
            var base64UrlStringValid = new Dictionary<string, byte[]>
            {
                {"0", base64UrlString1},
                {"1", base64UrlString2},
                {"2", base64UrlString3}
            };
            var base64UrlStringResult = client.Dictionary.GetBase64Url();
            Assert.Equal(base64UrlStringValid, base64UrlStringResult);
        }

        private static void TestBasicDictionaryParsing(AutoRestSwaggerBATdictionaryService client)
        {
// GET empty
            Assert.Empty(client.Dictionary.GetEmpty());
            // PUT empty
            client.Dictionary.PutEmpty(new Dictionary<string, string>());
            // GET null
            Assert.Null(client.Dictionary.GetNull());
            // GET invalid
            Assert.Throws<SerializationException>(() => client.Dictionary.GetInvalid());
            // GET nullkey
            Assert.Equal(new Dictionary<string, string> {{"null", "val1"}}, client.Dictionary.GetNullKey());
            // GET nullvalue
            Assert.Equal(new Dictionary<string, string> {{"key1", null}}, client.Dictionary.GetNullValue());
            // GET keyemptyString
            Assert.Equal(new Dictionary<string, string> {{"", "val1"}}, client.Dictionary.GetEmptyStringKey());
        }

        [Fact]
        public void ComplexTests()
        {
            SwaggerSpecRunner.RunTests(
                SwaggerPath("body-complex.json"), ExpectedPath("BodyComplex"));
            using (var client = new AutoRestComplexTestService(Fixture.Uri))
            {
                /* BASIC COMPLEX TYPE TESTS */
                // GET basic/valid
                var basicResult = client.Basic.GetValid();
                Assert.Equal(2, basicResult.Id);
                Assert.Equal("abc", basicResult.Name);
                Assert.Equal(CMYKColors.YELLOW, basicResult.Color);
                // PUT basic/valid
                var basicRequest = new Basic {Id = 2, Name = "abc", Color = CMYKColors.Magenta};
                client.Basic.PutValid(basicRequest);
                // GET basic/empty
                basicResult = client.Basic.GetEmpty();
                Assert.Equal(null, basicResult.Id);
                Assert.Equal(null, basicResult.Name);
                // GET basic/null
                client.Basic.GetNull();
                Assert.Equal(null, basicResult.Id);
                Assert.Equal(null, basicResult.Name);
                // GET basic/notprovided
                client.Basic.GetNotProvided();
                Assert.Equal(null, basicResult.Id);
                Assert.Equal(null, basicResult.Name);
                // GET basic/invalid
                Assert.Throws<SerializationException>(() => client.Basic.GetInvalid());

                /* COMPLEX TYPE WITH PRIMITIVE PROPERTIES */
                // GET primitive/integer
                var intResult = client.Primitive.GetInt();
                Assert.Equal(-1, intResult.Field1);
                Assert.Equal(2, intResult.Field2);
                // PUT primitive/integer
                var intRequest = new IntWrapper {Field1 = -1, Field2 = 2};
                client.Primitive.PutInt(intRequest);
                // GET primitive/long
                var longResult = client.Primitive.GetLong();
                Assert.Equal(1099511627775, longResult.Field1);
                Assert.Equal(-999511627788, longResult.Field2);
                // PUT primitive/long
                var longRequest = new LongWrapper {Field1 = 1099511627775, Field2 = -999511627788};
                client.Primitive.PutLong(longRequest);
                // GET primitive/float
                var floatResult = client.Primitive.GetFloat();
                Assert.Equal(1.05, floatResult.Field1);
                Assert.Equal(-0.003, floatResult.Field2);
                // PUT primitive/float
                var floatRequest = new FloatWrapper {Field1 = 1.05, Field2 = -0.003};
                client.Primitive.PutFloat(floatRequest);
                // GET primitive/double
                var doubleResult = client.Primitive.GetDouble();
                Assert.Equal(3e-100, doubleResult.Field1);
                Assert.Equal(-0.000000000000000000000000000000000000000000000000000000005,
                    doubleResult.Field56ZerosAfterTheDotAndNegativeZeroBeforeDotAndThisIsALongFieldNameOnPurpose);
                // PUT primitive/double
                var doubleRequest = new DoubleWrapper
                {
                    Field1 = 3e-100,
                    Field56ZerosAfterTheDotAndNegativeZeroBeforeDotAndThisIsALongFieldNameOnPurpose
                        = -0.000000000000000000000000000000000000000000000000000000005
                };
                client.Primitive.PutDouble(doubleRequest);
                // GET primitive/bool
                var boolResult = client.Primitive.GetBool();
                Assert.Equal(true, boolResult.FieldTrue);
                Assert.Equal(false, boolResult.FieldFalse);
                // PUT primitive/bool
                var boolRequest = new BooleanWrapper {FieldFalse = false, FieldTrue = true};
                client.Primitive.PutBool(boolRequest);
                // GET primitive/string
                var stringResult = client.Primitive.GetString();
                Assert.Equal("goodrequest", stringResult.Field);
                Assert.Equal("", stringResult.Empty);
                Assert.Equal(null, stringResult.NullProperty);
                // PUT primitive/string
                var stringRequest = new StringWrapper {NullProperty = null, Empty = "", Field = "goodrequest"};
                client.Primitive.PutString(stringRequest);
                // GET primitive/date
                client.Primitive.GetDate();
                client.Primitive.PutDate(new DateWrapper
                {
                    Field = new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc),
                    Leap = new DateTime(2016, 2, 29, 0, 0, 0, 0, DateTimeKind.Utc)
                });
                // GET primitive/datetime
                var datetimeResult = client.Primitive.GetDateTime();
                Assert.Equal(DateTime.MinValue, datetimeResult.Field);
                client.Primitive.PutDateTime(new DatetimeWrapper
                {
                    Field = new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc),
                    Now = new DateTime(2015, 05, 18, 18, 38, 0, DateTimeKind.Utc)
                });
                // GET primitive/datetimerfc1123
                var datetimeRfc1123Result = client.Primitive.GetDateTimeRfc1123();
                Assert.Equal(DateTime.MinValue, datetimeRfc1123Result.Field);
                client.Primitive.PutDateTimeRfc1123(new Datetimerfc1123Wrapper
                {
                    Field = new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc),
                    Now = new DateTime(2015, 05, 18, 11, 38, 0, DateTimeKind.Utc)
                });
                //GET primitive/duration
                var expectedDuration = new TimeSpan(123, 22, 14, 12, 11);
                var durationResult = client.Primitive.GetDuration();
                Assert.Equal(expectedDuration, durationResult.Field);
                client.Primitive.PutDuration(expectedDuration);

                // GET primitive/byte
                var byteResult = client.Primitive.GetByte();
                var bytes = new byte[] {0x0FF, 0x0FE, 0x0FD, 0x0FC, 0x000, 0x0FA, 0x0F9, 0x0F8, 0x0F7, 0x0F6};
                Assert.Equal(bytes, byteResult.Field);
                // PUT primitive/byte
                client.Primitive.PutByte(bytes);

                /* COMPLEX TYPE WITH ARRAY PROPERTIES */
                // GET array/valid
                var arrayResult = client.Array.GetValid();
                Assert.Equal(5, arrayResult.Array.Count);
                var arrayValue = new List<string>
                {
                    "1, 2, 3, 4",
                    "",
                    null,
                    "&S#$(*Y",
                    "The quick brown fox jumps over the lazy dog"
                };
                for (var i = 0; i < 5; i++)
                {
                    Assert.Equal(arrayValue[i], arrayResult.Array[i]);
                }
                // PUT array/valid
                client.Array.PutValid(arrayValue);
                // GET array/empty
                arrayResult = client.Array.GetEmpty();
                Assert.Equal(0, arrayResult.Array.Count);
                // PUT array/empty
                arrayValue.Clear();
                client.Array.PutEmpty(arrayValue);
                // Get array/notprovided
                arrayResult = client.Array.GetNotProvided();
                Assert.Null(arrayResult.Array);

                /* COMPLEX TYPE WITH DICTIONARY PROPERTIES */
                // GET dictionary/valid
                var dictionaryResult = client.Dictionary.GetValid();
                Assert.Equal(5, dictionaryResult.DefaultProgram.Count);
                var dictionaryValue = new Dictionary<string, string>
                {
                    {"txt", "notepad"},
                    {"bmp", "mspaint"},
                    {"xls", "excel"},
                    {"exe", ""},
                    {"", null}
                };
                Assert.Equal(dictionaryValue, dictionaryResult.DefaultProgram);
                // PUT dictionary/valid
                client.Dictionary.PutValid(dictionaryValue);
                // GET dictionary/empty
                dictionaryResult = client.Dictionary.GetEmpty();
                Assert.Equal(0, dictionaryResult.DefaultProgram.Count);
                // PUT dictionary/empty
                client.Dictionary.PutEmpty(new Dictionary<string, string>());
                // GET dictionary/null
                Assert.Null(client.Dictionary.GetNull().DefaultProgram);
                // GET dictionary/notprovided
                Assert.Null(client.Dictionary.GetNotProvided().DefaultProgram);

                /* COMPLEX TYPES THAT INVOLVE INHERITANCE */
                // GET inheritance/valid
                var inheritanceResult = client.Inheritance.GetValid();
                Assert.Equal(2, inheritanceResult.Id);
                Assert.Equal("Siameeee", inheritanceResult.Name);
                Assert.Equal(-1, inheritanceResult.Hates[1].Id);
                Assert.Equal("Tomato", inheritanceResult.Hates[1].Name);
                // PUT inheritance/valid
                var inheritanceRequest = new Siamese
                {
                    Id = 2,
                    Name = "Siameeee",
                    Color = "green",
                    Breed = "persian",
                    Hates = new List<Dog>
                    {
                        new Dog {Id = 1, Name = "Potato", Food = "tomato"},
                        new Dog {Id = -1, Name = "Tomato", Food = "french fries"}
                    }
                };
                client.Inheritance.PutValid(inheritanceRequest);

                /* COMPLEX TYPES THAT INVOLVE POLYMORPHISM */
                // GET polymorphism/valid
                var polymorphismResult = client.Polymorphism.GetValid() as Salmon;
                Assert.NotNull(polymorphismResult);
                Assert.Equal("alaska", polymorphismResult.Location);
                Assert.Equal(3, polymorphismResult.Siblings.Count);
                Assert.IsType(typeof(Shark), polymorphismResult.Siblings[0]);
                Assert.IsType(typeof(Sawshark), polymorphismResult.Siblings[1]);
                Assert.IsType(typeof(Goblinshark), polymorphismResult.Siblings[2]);
                Assert.Equal(6, ((Shark) polymorphismResult.Siblings[0]).Age);
                Assert.Equal(105, ((Sawshark) polymorphismResult.Siblings[1]).Age);
                Assert.Equal(1, ((Goblinshark) polymorphismResult.Siblings[2]).Age);
                // PUT polymorphism/valid
                var polymorphismRequest = new Salmon
                {
                    Iswild = true,
                    Length = 1,
                    Location = "alaska",
                    Species = "king",
                    Siblings = new List<Fish>
                    {
                        new Shark
                        {
                            Age = 6,
                            Length = 20,
                            Species = "predator",
                            Birthday = new DateTime(2012, 1, 5, 1, 0, 0, DateTimeKind.Utc)
                        },
                        new Sawshark
                        {
                            Age = 105,
                            Length = 10,
                            Species = "dangerous",
                            Birthday = new DateTime(1900, 1, 5, 1, 0, 0, DateTimeKind.Utc),
                            Picture = new byte[] {255, 255, 255, 255, 254}
                        },
                        new Goblinshark
                        {
                            Age = 1,
                            Length = 30,
                            Species = "scary",
                            Birthday = new DateTime(2015, 8, 8, 0, 0, 0, DateTimeKind.Utc),
                            Jawsize = 5
                        }
                    }
                };
                client.Polymorphism.PutValid(polymorphismRequest);

                /* COMPLEX TYPES THAT INVOLVE RECURSIVE REFERENCE */
                // GET polymorphicrecursive/valid
                var recursiveResult = client.Polymorphicrecursive.GetValid();
                Assert.True(recursiveResult is Salmon);
                Assert.True(recursiveResult.Siblings[0] is Shark);
                Assert.True(recursiveResult.Siblings[0].Siblings[0] is Salmon);
                Assert.Equal("atlantic", ((Salmon) recursiveResult.Siblings[0].Siblings[0]).Location);
                // PUT polymorphicrecursive/valid
                var recursiveRequest = new Salmon
                {
                    Iswild = true,
                    Length = 1,
                    Species = "king",
                    Location = "alaska",
                    Siblings = new List<Fish>
                    {
                        new Shark
                        {
                            Age = 6,
                            Length = 20,
                            Species = "predator",
                            Siblings = new List<Fish>
                            {
                                new Salmon
                                {
                                    Iswild = true,
                                    Length = 2,
                                    Location = "atlantic",
                                    Species = "coho",
                                    Siblings = new List<Fish>
                                    {
                                        new Shark
                                        {
                                            Age = 6,
                                            Length = 20,
                                            Species = "predator",
                                            Birthday = new DateTime(2012, 1, 5, 1, 0, 0, DateTimeKind.Utc)
                                        },
                                        new Sawshark
                                        {
                                            Age = 105,
                                            Length = 10,
                                            Species = "dangerous",
                                            Birthday = new DateTime(1900, 1, 5, 1, 0, 0, DateTimeKind.Utc),
                                            Picture = new byte[] {255, 255, 255, 255, 254}
                                        }
                                    }
                                },
                                new Sawshark
                                {
                                    Age = 105,
                                    Length = 10,
                                    Species = "dangerous",
                                    Siblings = new List<Fish>(),
                                    Birthday = new DateTime(1900, 1, 5, 1, 0, 0, DateTimeKind.Utc),
                                    Picture = new byte[] {255, 255, 255, 255, 254}
                                }
                            },
                            Birthday = new DateTime(2012, 1, 5, 1, 0, 0, DateTimeKind.Utc)
                        },
                        new Sawshark
                        {
                            Age = 105,
                            Length = 10,
                            Species = "dangerous",
                            Siblings = new List<Fish>(),
                            Birthday = new DateTime(1900, 1, 5, 1, 0, 0, DateTimeKind.Utc),
                            Picture = new byte[] {255, 255, 255, 255, 254}
                        }
                    }
                };
                client.Polymorphicrecursive.PutValid(recursiveRequest);

                /* COMPLEX TYPE WITH READ ONLY PROPERTIES TESTS */
                // PUT /readonlyproperty/valid
                var o = client.Readonlyproperty.GetValid();
                client.Readonlyproperty.PutValid(2);
            }
        }

        [Fact]
        public void UrlPathTests()
        {
            SwaggerSpecRunner.RunTests(
                SwaggerPath("url.json"), ExpectedPath("Url"));
            using (var client = new AutoRestUrlTestService(Fixture.Uri))
            {
                client.Paths.ByteEmpty();
                Assert.Throws<ValidationException>(() => client.Paths.ByteNull(null));
                client.Paths.ByteMultiByte(Encoding.UTF8.GetBytes("啊齄丂狛狜隣郎隣兀﨩"));
                // appropriately disallowed:client.Paths.DateNull(null);
                // appropriately disallowed: client.Paths.DateTimeNull(null);
                client.Paths.DateTimeValid();
                client.Paths.DateValid();
                client.Paths.DoubleDecimalNegative();
                client.Paths.DoubleDecimalPositive();
                client.Paths.FloatScientificNegative();
                client.Paths.FloatScientificPositive();
                client.Paths.GetBooleanFalse();
                client.Paths.GetBooleanTrue();
                client.Paths.GetIntNegativeOneMillion();
                client.Paths.GetIntOneMillion();
                client.Paths.GetNegativeTenBillion();
                client.Paths.GetTenBillion();
                client.Paths.StringEmpty();
                Assert.Throws<ValidationException>(() => client.Paths.StringNull(null));
                client.Paths.StringUrlEncoded();
                client.Paths.EnumValid(UriColor.Greencolor);
                client.Paths.Base64Url(Encoding.UTF8.GetBytes("lorem"));
                var testArray = new List<string> {"ArrayPath1", @"begin!*'();:@ &=+$,/?#[]end", null, ""};
                client.Paths.ArrayCsvInPath(testArray);
                client.Paths.UnixTimeUrl(new DateTime(2016, 4, 13, 0, 0, 0));
            }
        }

        [Fact(Skip = "TEMP")]
        public void HeaderTests()
        {
            SwaggerSpecRunner.RunTests(
                SwaggerPath("header.json"), ExpectedPath("Header"));
            using (var client = new AutoRestSwaggerBATHeaderService(Fixture.Uri))
            {
                //Set ProductInfoHeaderValue
                // Now by default, ServiceClient will add additional information to UserAgents for telemetry purpose (e.g. OS Info, FxVersion etc)
                client.SetUserAgent(this.GetType().FullName);

                // Check the UserAgent ProductInfoHeaderValue
                ProductInfoHeaderValue defaultProduct = client.UserAgent.Where<ProductInfoHeaderValue>(c => c.Product.Name.Equals(this.GetType().FullName)).FirstOrDefault<ProductInfoHeaderValue>();
                Assert.Equal("1.5.0.1", defaultProduct.Product.Version);

                // POST param/prim/integer
                client.Header.ParamInteger("positive", 1);
                client.Header.ParamInteger("negative", -2);

                // POST response/prim/integer
                var responseInteger = client.Header.ResponseIntegerWithHttpMessagesAsync("positive").Result;
                Assert.Equal(1, int.Parse(responseInteger.Response.Headers.GetValues("value").FirstOrDefault(),
                    CultureInfo.InvariantCulture));
                Assert.Equal(1, responseInteger.Headers.Value);

                responseInteger = client.Header.ResponseIntegerWithHttpMessagesAsync("negative").Result;
                Assert.Equal(-2, int.Parse(responseInteger.Response.Headers.GetValues("value").FirstOrDefault(),
                    CultureInfo.InvariantCulture));
                Assert.Equal(-2, responseInteger.Headers.Value);

                // POST param/prim/long
                client.Header.ParamLong("positive", 105);
                client.Header.ParamLong("negative", -2);

                // POST response/prim/long
                var responseLong = client.Header.ResponseLongWithHttpMessagesAsync("positive").Result;
                Assert.Equal(105, long.Parse(responseLong.Response.Headers.GetValues("value").FirstOrDefault(),
                    CultureInfo.InvariantCulture));
                Assert.Equal(105, responseLong.Headers.Value);

                responseLong = client.Header.ResponseLongWithHttpMessagesAsync("negative").Result;
                Assert.Equal(-2, long.Parse(responseLong.Response.Headers.GetValues("value").FirstOrDefault(),
                    CultureInfo.InvariantCulture));
                Assert.Equal(-2, responseLong.Headers.Value);

                // POST param/prim/float
                client.Header.ParamFloat("positive", 0.07);
                client.Header.ParamFloat("negative", -3.0);

                // POST response/prim/float
                var responseFloat = client.Header.ResponseFloatWithHttpMessagesAsync("positive").Result;
                Assert.True(Math.Abs(0.07 -
                                     float.Parse(responseFloat.Response.Headers.GetValues("value").FirstOrDefault(),
                                         CultureInfo.InvariantCulture)) < 0.00001);
                Assert.True(Math.Abs(0.07 - responseFloat.Headers.Value.Value) < 0.00001);

                responseFloat = client.Header.ResponseFloatWithHttpMessagesAsync("negative").Result;
                Assert.True(Math.Abs(-3 -
                                     float.Parse(responseFloat.Response.Headers.GetValues("value").FirstOrDefault(),
                                         CultureInfo.InvariantCulture)) < 0.00001);
                Assert.True(Math.Abs(-3 - responseFloat.Headers.Value.Value) < 0.00001);

                // POST param/prim/double
                client.Header.ParamDouble("positive", 7e120);
                client.Header.ParamDouble("negative", -3.0);

                // POST response/prim/double
                var responseDouble = client.Header.ResponseDoubleWithHttpMessagesAsync("positive").Result;
                Assert.Equal(7e120, double.Parse(responseDouble.Response.Headers.GetValues("value").FirstOrDefault(),
                    CultureInfo.InvariantCulture));
                Assert.Equal(7e120, responseDouble.Headers.Value);

                responseDouble = client.Header.ResponseDoubleWithHttpMessagesAsync("negative").Result;
                Assert.Equal(-3, double.Parse(responseDouble.Response.Headers.GetValues("value").FirstOrDefault(),
                    CultureInfo.InvariantCulture));
                Assert.Equal(-3, responseDouble.Headers.Value);

                // POST param/prim/bool
                client.Header.ParamBool("true", true);
                client.Header.ParamBool("false", false);

                // POST response/prim/bool
                var responseBool = client.Header.ResponseBoolWithHttpMessagesAsync("true").Result;
                Assert.Equal(true, bool.Parse(responseBool.Response.Headers.GetValues("value").FirstOrDefault()));
                Assert.Equal(true, responseBool.Headers.Value);

                responseBool = client.Header.ResponseBoolWithHttpMessagesAsync("false").Result;
                Assert.Equal(false, bool.Parse(responseBool.Response.Headers.GetValues("value").FirstOrDefault()));
                Assert.Equal(false, responseBool.Headers.Value);

                // POST param/prim/string
                client.Header.ParamString("valid", "The quick brown fox jumps over the lazy dog");
                client.Header.ParamString("null", null);
                client.Header.ParamString("empty", "");

                // POST response/prim/string
                var responseString = client.Header.ResponseStringWithHttpMessagesAsync("valid").Result;
                Assert.Equal("The quick brown fox jumps over the lazy dog",
                    responseString.Response.Headers.GetValues("value").FirstOrDefault());
                Assert.Equal("The quick brown fox jumps over the lazy dog", responseString.Headers.Value);

                responseString = client.Header.ResponseStringWithHttpMessagesAsync("null").Result;
                Assert.Equal("null", responseString.Response.Headers.GetValues("value").FirstOrDefault());
                Assert.Equal("null", responseString.Headers.Value);

                responseString = client.Header.ResponseStringWithHttpMessagesAsync("empty").Result;
                Assert.Equal("", responseString.Response.Headers.GetValues("value").FirstOrDefault());
                Assert.Equal("", responseString.Headers.Value);

                // POST param/prim/enum
                client.Header.ParamEnum("valid", GreyscaleColors.GREY);
                client.Header.ParamEnum("null", null);

                // POST response/prim/enum
                var responseEnum = client.Header.ResponseEnumWithHttpMessagesAsync("valid").Result;
                Assert.Equal("GREY", responseEnum.Response.Headers.GetValues("value").FirstOrDefault());
                Assert.Equal(GreyscaleColors.GREY, responseEnum.Headers.Value);

                responseEnum = client.Header.ResponseEnumWithHttpMessagesAsync("null").Result;

                Assert.Equal("", responseEnum.Response.Headers.GetValues("value").FirstOrDefault());
                Assert.Equal(null, responseEnum.Headers.Value);

                // POST param/prim/date
                client.Header.ParamDate("valid", new DateTime(2010, 1, 1, 0, 0, 0, DateTimeKind.Utc));
                client.Header.ParamDate("min", DateTime.MinValue);

                // POST response/prim/date
                var responseDate = client.Header.ResponseDateWithHttpMessagesAsync("valid").Result;
                Assert.Equal(new DateTimeOffset(new DateTime(2010, 1, 1, 0, 0, 0, DateTimeKind.Local)),
                    JsonConvert.DeserializeObject<DateTimeOffset>(
                        "\"" + responseDate.Response.Headers.GetValues("value").FirstOrDefault() + "\""));
                Assert.Equal(new DateTime(2010, 1, 1, 0, 0, 0, DateTimeKind.Local), responseDate.Headers.Value);

                responseDate = client.Header.ResponseDateWithHttpMessagesAsync("min").Result;
                Assert.Equal(DateTime.MinValue,
                    JsonConvert.DeserializeObject<DateTime>(
                        "\"" + responseDate.Response.Headers.GetValues("value").FirstOrDefault() + "\""));
                Assert.Equal(DateTime.MinValue, responseDate.Headers.Value);

                // POST param/prim/datetime
                client.Header.ParamDatetime("valid", new DateTime(2010, 1, 1, 12, 34, 56, DateTimeKind.Utc));
                client.Header.ParamDatetime("min", DateTime.MinValue);

                // POST response/prim/datetime
                var responseDateTime = client.Header.ResponseDatetimeWithHttpMessagesAsync("valid").Result;
                Assert.Equal(new DateTimeOffset(new DateTime(2010, 1, 1, 12, 34, 56, DateTimeKind.Utc)),
                    JsonConvert.DeserializeObject<DateTimeOffset>(
                        "\"" + responseDateTime.Response.Headers.GetValues("value").FirstOrDefault() + "\""));
                Assert.Equal(new DateTime(2010, 1, 1, 12, 34, 56, DateTimeKind.Utc), responseDateTime.Headers.Value);

                responseDateTime = client.Header.ResponseDatetimeWithHttpMessagesAsync("min").Result;
                Assert.Equal(DateTimeOffset.MinValue,
                    JsonConvert.DeserializeObject<DateTimeOffset>(
                        "\"" + responseDateTime.Response.Headers.GetValues("value").FirstOrDefault() + "\""));
                Assert.Equal(DateTime.MinValue, responseDateTime.Headers.Value);

                // POST param/prim/datetimerfc1123
                client.Header.ParamDatetimeRfc1123("valid", new DateTime(2010, 1, 1, 12, 34, 56, DateTimeKind.Utc));
                client.Header.ParamDatetimeRfc1123("min", DateTime.MinValue);

                //POST response/prim/datetimerfc1123
                var responseDateTimeRfc1123 = client.Header.ResponseDatetimeRfc1123WithHttpMessagesAsync("valid").Result;
                Assert.Equal(new DateTimeOffset(new DateTime(2010, 1, 1, 12, 34, 56, DateTimeKind.Utc)),
                    JsonConvert.DeserializeObject<DateTimeOffset>(
                        "\"" + responseDateTimeRfc1123.Response.Headers.GetValues("value").FirstOrDefault() + "\""));
                Assert.Equal(new DateTime(2010, 1, 1, 12, 34, 56, DateTimeKind.Utc),
                    responseDateTimeRfc1123.Headers.Value);
                Assert.Equal(DateTimeKind.Utc, responseDateTimeRfc1123.Headers.Value.Value.Kind);

                responseDateTimeRfc1123 = client.Header.ResponseDatetimeRfc1123WithHttpMessagesAsync("min").Result;
                Assert.Equal(DateTimeOffset.MinValue,
                    JsonConvert.DeserializeObject<DateTimeOffset>(
                        "\"" + responseDateTimeRfc1123.Response.Headers.GetValues("value").FirstOrDefault() + "\""));
                Assert.Equal(DateTime.MinValue,
                    responseDateTimeRfc1123.Headers.Value);
                Assert.Equal(DateTimeKind.Utc, responseDateTimeRfc1123.Headers.Value.Value.Kind);

                // POST param/prim/duration
                client.Header.ParamDuration("valid", new TimeSpan(123, 22, 14, 12, 11));

                // POST response/prim/duration
                var responseDuration = client.Header.ResponseDurationWithHttpMessagesAsync("valid").Result;
                Assert.Equal(new TimeSpan(123, 22, 14, 12, 11),
                    JsonConvert.DeserializeObject<TimeSpan?>(
                        "\"" + responseDuration.Response.Headers.GetValues("value").FirstOrDefault() + "\"",
                        new Iso8601TimeSpanConverter()));
                Assert.Equal(new TimeSpan(123, 22, 14, 12, 11),
                    responseDuration.Headers.Value);

                // POST param/prim/string
                client.Header.ParamByte("valid", Encoding.UTF8.GetBytes("啊齄丂狛狜隣郎隣兀﨩"));

                // POST response/prim/byte
                var responseByte = client.Header.ResponseByteWithHttpMessagesAsync("valid").Result;
                Assert.Equal(Encoding.UTF8.GetBytes("啊齄丂狛狜隣郎隣兀﨩"),
                    JsonConvert.DeserializeObject<byte[]>(
                        "\"" + responseByte.Response.Headers.GetValues("value").FirstOrDefault() + "\""));
                Assert.Equal(Encoding.UTF8.GetBytes("啊齄丂狛狜隣郎隣兀﨩"),
                    responseByte.Headers.Value);

                // POST param/existingkey
                client.Header.ParamExistingKey("overwrite");

                // POST response/existingkey
                var responseExistingKey = client.Header.ResponseExistingKeyWithHttpMessagesAsync().Result;
                Assert.Equal("overwrite", responseExistingKey.Response.Headers.GetValues("User-Agent").FirstOrDefault());
                Assert.Equal("overwrite", responseExistingKey.Headers.UserAgent);

                // POST param/existingkey
                Assert.Throws<InvalidOperationException>(() => client.Header.ParamProtectedKey("text/html"));

                // POST response/protectedkey
                var responseProtectedKey = client.Header.ResponseProtectedKeyWithHttpMessagesAsync().Result;
                Assert.False(responseProtectedKey.Response.Headers.Any(header => header.Key == "Content-Type"));

                var customHeader = new Dictionary<string, List<string>>
                {
                    {
                        "x-ms-client-request-id", new List<string> {"9C4D50EE-2D56-4CD3-8152-34347DC9F2B0"}
                    }
                };

                Assert.Equal(HttpStatusCode.OK,
                    client.Header.CustomRequestIdWithHttpMessagesAsync(customHeader).Result.Response.StatusCode);
            }
        }

        [Fact]
        public void UrlQueryTests()
        {
            SwaggerSpecRunner.RunTests(
                SwaggerPath("url.json"), ExpectedPath("Url"));
            using (var client = new AutoRestUrlTestService(Fixture.Uri))
            {
                client.Queries.ByteEmpty();
                client.Queries.ByteMultiByte(Encoding.UTF8.GetBytes("啊齄丂狛狜隣郎隣兀﨩"));
                client.Queries.ByteNull();
                client.Queries.DateNull();
                client.Queries.DateTimeNull();
                client.Queries.DateTimeValid();
                client.Queries.DateValid();
                client.Queries.DoubleNull();
                client.Queries.DoubleDecimalNegative();
                client.Queries.DoubleDecimalPositive();
                client.Queries.FloatScientificNegative();
                client.Queries.FloatScientificPositive();
                client.Queries.FloatNull();
                client.Queries.GetBooleanFalse();
                client.Queries.GetBooleanTrue();
                client.Queries.GetBooleanNull();
                client.Queries.GetIntNegativeOneMillion();
                client.Queries.GetIntOneMillion();
                client.Queries.GetIntNull();
                client.Queries.GetNegativeTenBillion();
                client.Queries.GetTenBillion();
                client.Queries.GetLongNull();
                client.Queries.StringEmpty();
                client.Queries.StringNull();
                client.Queries.StringUrlEncoded();
                client.Queries.EnumValid(UriColor.Greencolor);
                client.Queries.EnumNull();
                client.Queries.ArrayStringCsvEmpty(new List<string>(0));
                client.Queries.ArrayStringCsvNull();
                var testArray = new List<string> {"ArrayQuery1", @"begin!*'();:@ &=+$,/?#[]end", null, ""};
                client.Queries.ArrayStringCsvValid(testArray);
                client.Queries.ArrayStringPipesValid(testArray);
                client.Queries.ArrayStringSsvValid(testArray);
                client.Queries.ArrayStringTsvValid(testArray);
            }
        }

        [Fact]
        public void UrlQueryMultiCollectionFormatTests()
        {
            SwaggerSpecRunner.RunTests(
                SwaggerPath("url-multi-collectionFormat.json"), ExpectedPath("UrlMultiCollectionFormat"));
            using (var client = new AutoRestUrlMutliCollectionFormatTestService(Fixture.Uri))
            {
                client.Queries.ArrayStringMultiEmpty(new List<string>(0));
                client.Queries.ArrayStringMultiNull();
                var testArray = new List<string> { "ArrayQuery1", @"begin!*'();:@ &=+$,/?#[]end", null, "" };
                client.Queries.ArrayStringMultiValid(testArray);
            }
        }
        [Fact]
        public void UrlMixedTests()
        {
            SwaggerSpecRunner.RunTests(
                SwaggerPath("url.json"), ExpectedPath("Url"));
            using (var client = new AutoRestUrlTestService(Fixture.Uri))
            {
                client.GlobalStringPath = "globalStringPath";
                client.GlobalStringQuery = "globalStringQuery";
                client.PathItems.GetAllWithValues("localStringPath", "pathItemStringPath",
                    "localStringQuery", "pathItemStringQuery");
                client.GlobalStringQuery = null;
                client.PathItems.GetGlobalAndLocalQueryNull("localStringPath", "pathItemStringPath",
                    null, "pathItemStringQuery");
                client.PathItems.GetGlobalQueryNull("localStringPath", "pathItemStringPath",
                    "localStringQuery", "pathItemStringQuery");
                client.GlobalStringQuery = "globalStringQuery";
                client.PathItems.GetLocalPathItemQueryNull("localStringPath", "pathItemStringPath",
                    null, null);
            }
        }

        [Fact]
        public void HttpInfrastructureTests()
        {
            SwaggerSpecRunner.RunTests(
                SwaggerPath("httpInfrastructure.json"), ExpectedPath("Http"));
            using (var client = new AutoRestHttpInfrastructureTestService(Fixture.Uri))
            {
                TestSuccessStatusCodes(client);
                TestRedirectStatusCodes(client);
                TestClientErrorStatusCodes(client);
                TestServerErrorStatusCodes(client);
                TestResponseModeling(client);
            }
        }

        private static void TestResponseModeling(AutoRestHttpInfrastructureTestService client)
        {
            Assert.Equal<string>("200", client.MultipleResponses.Get200Model204NoModelDefaultError200Valid().StatusCode);
            EnsureThrowsWithStatusCode(HttpStatusCode.Created,
                () => client.MultipleResponses.Get200Model204NoModelDefaultError201Invalid());
            EnsureThrowsWithStatusCode(HttpStatusCode.Accepted,
                () => client.MultipleResponses.Get200Model204NoModelDefaultError202None());
            Assert.Null(client.MultipleResponses.Get200Model204NoModelDefaultError204Valid());
            EnsureThrowsWithStatusCodeAndError(HttpStatusCode.BadRequest,
                () => client.MultipleResponses.Get200Model204NoModelDefaultError400Valid(), "client error");
            Assert.Equal("200", client.MultipleResponses.Get200Model201ModelDefaultError200Valid().StatusCode);
            var bModel = client.MultipleResponses.Get200Model201ModelDefaultError201Valid() as B;
            Assert.NotNull(bModel);
            Assert.Equal(bModel.StatusCode, "201");
            Assert.Equal(bModel.TextStatusCode, "Created");
            EnsureThrowsWithStatusCodeAndError(HttpStatusCode.BadRequest,
                () => client.MultipleResponses.Get200Model201ModelDefaultError400Valid(), "client error");
            var aModel = client.MultipleResponses.Get200ModelA201ModelC404ModelDDefaultError200Valid() as A;
            Assert.NotNull(aModel);
            Assert.Equal("200", aModel.StatusCode);
            var cModel = client.MultipleResponses.Get200ModelA201ModelC404ModelDDefaultError201Valid() as C;
            Assert.NotNull(cModel);
            Assert.Equal("201", cModel.HttpCode);
            var dModel = client.MultipleResponses.Get200ModelA201ModelC404ModelDDefaultError404Valid() as D;
            Assert.NotNull(dModel);
            Assert.Equal("404", dModel.HttpStatusCode);
            EnsureThrowsWithStatusCodeAndError(HttpStatusCode.BadRequest,
                () => client.MultipleResponses.Get200ModelA201ModelC404ModelDDefaultError400Valid(), "client error");
            client.MultipleResponses.Get202None204NoneDefaultError202None();
            client.MultipleResponses.Get202None204NoneDefaultError204None();
            EnsureThrowsWithStatusCodeAndError(HttpStatusCode.BadRequest,
                () => client.MultipleResponses.Get202None204NoneDefaultError400Valid(), "client error");
            client.MultipleResponses.Get202None204NoneDefaultNone202Invalid();
            client.MultipleResponses.Get202None204NoneDefaultNone204None();
            EnsureThrowsWithStatusCode(HttpStatusCode.BadRequest,
                () => client.MultipleResponses.Get202None204NoneDefaultNone400None());
            EnsureThrowsWithStatusCode(HttpStatusCode.BadRequest,
                () => client.MultipleResponses.Get202None204NoneDefaultNone400Invalid());
            Assert.Equal("200", client.MultipleResponses.GetDefaultModelA200Valid().StatusCode);
            Assert.Null(client.MultipleResponses.GetDefaultModelA200None());
            client.MultipleResponses.GetDefaultModelA200Valid();
            client.MultipleResponses.GetDefaultModelA200None();
            EnsureThrowsWithErrorModel<A>(HttpStatusCode.BadRequest,
                () => client.MultipleResponses.GetDefaultModelA400Valid(), e => Assert.Equal("400", e.StatusCode));
            EnsureThrowsWithErrorModel<A>(HttpStatusCode.BadRequest,
                () => client.MultipleResponses.GetDefaultModelA400None(), Assert.Null);
            client.MultipleResponses.GetDefaultNone200Invalid();
            client.MultipleResponses.GetDefaultNone200None();
            EnsureThrowsWithStatusCode(HttpStatusCode.BadRequest, client.MultipleResponses.GetDefaultNone400Invalid);
            EnsureThrowsWithStatusCode(HttpStatusCode.BadRequest, client.MultipleResponses.GetDefaultNone400None);
            Assert.Null(client.MultipleResponses.Get200ModelA200None());
            Assert.Equal("200", client.MultipleResponses.Get200ModelA200Valid().StatusCode);
            Assert.Null(client.MultipleResponses.Get200ModelA200Invalid().StatusCode);
            EnsureThrowsWithStatusCode(HttpStatusCode.BadRequest, () => client.MultipleResponses.Get200ModelA400None());
            EnsureThrowsWithStatusCode(HttpStatusCode.BadRequest, () => client.MultipleResponses.Get200ModelA400Valid());
            EnsureThrowsWithStatusCode(HttpStatusCode.BadRequest,
                () => client.MultipleResponses.Get200ModelA400Invalid());
            EnsureThrowsWithStatusCode(HttpStatusCode.Accepted, () => client.MultipleResponses.Get200ModelA202Valid());
        }

        private static void TestServerErrorStatusCodes(AutoRestHttpInfrastructureTestService client)
        {
            EnsureThrowsWithStatusCode(HttpStatusCode.NotImplemented, () => client.HttpServerFailure.Head501());
            EnsureThrowsWithStatusCode(HttpStatusCode.NotImplemented, () => client.HttpServerFailure.Get501());
            EnsureThrowsWithStatusCode(HttpStatusCode.HttpVersionNotSupported,
                () => client.HttpServerFailure.Post505(true));
            EnsureThrowsWithStatusCode(HttpStatusCode.HttpVersionNotSupported,
                () => client.HttpServerFailure.Delete505(true));
            client.HttpRetry.Head408();
            //TODO: Retry logic is flakey on Unix under DNX
            client.HttpRetry.Get502();
            client.HttpRetry.Get502();
            client.HttpRetry.Put500(true);
            //TODO, 4042586: Support options operations in swagger modeler
            //client.HttpRetry.Options429();
            client.HttpRetry.Patch500(true);
            client.HttpRetry.Post503(true);
            client.HttpRetry.Delete503(true);
            client.HttpRetry.Put504(true);
            client.HttpRetry.Patch504(true);
        }

        private static void TestClientErrorStatusCodes(AutoRestHttpInfrastructureTestService client)
        {
            EnsureThrowsWithStatusCode(HttpStatusCode.BadRequest, () => client.HttpClientFailure.Head400());
            EnsureThrowsWithStatusCode(HttpStatusCode.BadRequest, () => client.HttpClientFailure.Get400());
            //TODO, 4042586: Support options operations in swagger modeler
            //EnsureThrowsWithStatusCode(HttpStatusCode.BadRequest, () => client.HttpClientFailure.Options400());
            EnsureThrowsWithStatusCode(HttpStatusCode.BadRequest, () => client.HttpClientFailure.Put400(true));
            EnsureThrowsWithStatusCode(HttpStatusCode.BadRequest, () => client.HttpClientFailure.Patch400(true));
            EnsureThrowsWithStatusCode(HttpStatusCode.BadRequest, () => client.HttpClientFailure.Post400(true));
            EnsureThrowsWithStatusCode(HttpStatusCode.BadRequest, () => client.HttpClientFailure.Delete400(true));
            EnsureThrowsWithStatusCode(HttpStatusCode.Unauthorized, () => client.HttpClientFailure.Head401());
            EnsureThrowsWithStatusCode(HttpStatusCode.PaymentRequired, () => client.HttpClientFailure.Get402());
            //TODO, 4042586: Support options operations in swagger modeler
            //EnsureThrowsWithStatusCode(HttpStatusCode.Forbidden, () => client.HttpClientFailure.Options403());
            EnsureThrowsWithStatusCode(HttpStatusCode.Forbidden, () => client.HttpClientFailure.Get403());
            EnsureThrowsWithStatusCode(HttpStatusCode.NotFound, () => client.HttpClientFailure.Put404(true));
            EnsureThrowsWithStatusCode(HttpStatusCode.MethodNotAllowed, () => client.HttpClientFailure.Patch405(true));
            EnsureThrowsWithStatusCode(HttpStatusCode.NotAcceptable, () => client.HttpClientFailure.Post406(true));
            EnsureThrowsWithStatusCode(HttpStatusCode.Conflict, () => client.HttpClientFailure.Put409(true));
            EnsureThrowsWithStatusCode(HttpStatusCode.Gone, () => client.HttpClientFailure.Head410());
            EnsureThrowsWithStatusCode(HttpStatusCode.LengthRequired, () => client.HttpClientFailure.Get411());
            //TODO, 4042586: Support options operations in swagger modeler
            //EnsureThrowsWithStatusCode(HttpStatusCode.PreconditionFailed, () => client.HttpClientFailure.Options412());
            EnsureThrowsWithStatusCode(HttpStatusCode.PreconditionFailed, () => client.HttpClientFailure.Get412());
            EnsureThrowsWithStatusCode(HttpStatusCode.RequestEntityTooLarge, () => client.HttpClientFailure.Put413(true));
            EnsureThrowsWithStatusCode(HttpStatusCode.RequestUriTooLong, () => client.HttpClientFailure.Patch414(true));
            EnsureThrowsWithStatusCode(HttpStatusCode.UnsupportedMediaType, () => client.HttpClientFailure.Post415(true));
            EnsureThrowsWithStatusCode(HttpStatusCode.RequestedRangeNotSatisfiable,
                () => client.HttpClientFailure.Get416());
            EnsureThrowsWithStatusCode(HttpStatusCode.ExpectationFailed, () => client.HttpClientFailure.Delete417(true));
            EnsureThrowsWithStatusCode((HttpStatusCode) 429, () => client.HttpClientFailure.Head429());
        }

        private static void TestRedirectStatusCodes(AutoRestHttpInfrastructureTestService client)
        {
            EnsureStatusCode(HttpStatusCode.OK, () => client.HttpRedirects.Head300WithHttpMessagesAsync());
            EnsureStatusCode(HttpStatusCode.OK, () => client.HttpRedirects.Get300WithHttpMessagesAsync());
            EnsureStatusCode(HttpStatusCode.OK, () => client.HttpRedirects.Head302WithHttpMessagesAsync());
            EnsureStatusCode(HttpStatusCode.OK, () => client.HttpRedirects.Head301WithHttpMessagesAsync());
            EnsureStatusCode(HttpStatusCode.OK, () => client.HttpRedirects.Get301WithHttpMessagesAsync());
            //TODO, 4048201: http client incorrectly redirects non-get/head requests when receiving a 301 or 302 response
            //EnsureStatusCode(HttpStatusCode.MovedPermanently, () => client.HttpRedirects.Put301WithHttpMessagesAsync(true));
            EnsureStatusCode(HttpStatusCode.OK, () => client.HttpRedirects.Get302WithHttpMessagesAsync());
            //TODO, 4048201: http client incorrectly redirects non-get/head requests when receiving a 301 or 302 response
            // EnsureStatusCode(HttpStatusCode.Found, () => client.HttpRedirects.Patch302WithHttpMessagesAsync(true));
#if !LEGACY
            //TODO, Fix this test on PORTABLE
#else
            EnsureStatusCode(HttpStatusCode.OK, () => client.HttpRedirects.Post303WithHttpMessagesAsync(true));
#endif
            EnsureStatusCode(HttpStatusCode.OK, () => client.HttpRedirects.Head307WithHttpMessagesAsync());
            EnsureStatusCode(HttpStatusCode.OK, () => client.HttpRedirects.Get307WithHttpMessagesAsync());
            //TODO, 4042586: Support options operations in swagger modeler
            //EnsureStatusCode(HttpStatusCode.OK, () => client.HttpRedirects.Options307WithHttpMessagesAsync());
            EnsureStatusCode(HttpStatusCode.OK, () => client.HttpRedirects.Put307WithHttpMessagesAsync(true));
            EnsureStatusCode(HttpStatusCode.OK, () => client.HttpRedirects.Post307WithHttpMessagesAsync(true));
            EnsureStatusCode(HttpStatusCode.OK, () => client.HttpRedirects.Patch307WithHttpMessagesAsync(true));
            EnsureStatusCode(HttpStatusCode.OK, () => client.HttpRedirects.Delete307WithHttpMessagesAsync(true));
        }

        private static void TestSuccessStatusCodes(AutoRestHttpInfrastructureTestService client)
        {
            var ex = Assert.Throws<ErrorException>(() => client.HttpFailure.GetEmptyError());
            Assert.Equal("Operation returned an invalid status code 'BadRequest'", ex.Message);

            var ex2 = Assert.Throws<HttpOperationException>(() => client.HttpFailure.GetNoModelError());
            Assert.Equal("{\"message\":\"NoErrorModel\",\"status\":400}", ex2.Response.Content);

            var ex3 = Assert.Throws<HttpOperationException>(() => client.HttpFailure.GetNoModelEmpty());
            Assert.Equal(string.Empty, ex3.Response.Content);

            client.HttpSuccess.Head200();
            Assert.True(client.HttpSuccess.Get200());
            client.HttpSuccess.Put200(true);
            client.HttpSuccess.Post200(true);
            client.HttpSuccess.Patch200(true);
            client.HttpSuccess.Delete200(true);
            //TODO, 4042586: Support options operations in swagger modeler
            //Assert.True(client.HttpSuccess.Options200();
            client.HttpSuccess.Put201(true);
            client.HttpSuccess.Post201(true);
            client.HttpSuccess.Put202(true);
            client.HttpSuccess.Post202(true);
            client.HttpSuccess.Patch202(true);
            client.HttpSuccess.Delete202(true);
            client.HttpSuccess.Head204();
            client.HttpSuccess.Put204(true);
            client.HttpSuccess.Post204(true);
            client.HttpSuccess.Delete204(true);
            client.HttpSuccess.Head404();
            client.HttpSuccess.Patch204(true);
        }

        [Fact]
        public void RequiredOptionalNegativeTests()
        {
            SwaggerSpecRunner.RunTests(
                SwaggerPath("required-optional.json"), ExpectedPath("RequiredOptional"));
            using (var client = new AutoRestRequiredOptionalTestService(Fixture.Uri))
            {
                Assert.Throws<ValidationException>(() =>
                    client.ImplicitModel.GetRequiredPath(null));
                Assert.Throws<ValidationException>(() =>
                    client.ExplicitModel.PostRequiredStringHeader(null));
                Assert.Throws<ValidationException>(() =>
                    client.ExplicitModel.PostRequiredStringParameter(null));
                Assert.Throws<ValidationException>(() =>
                    client.ExplicitModel.PostRequiredStringProperty(null));
                Assert.Throws<ValidationException>(() =>
                    client.ExplicitModel.PostRequiredArrayHeader(null));
                Assert.Throws<ValidationException>(() =>
                    client.ExplicitModel.PostRequiredArrayParameter(null));
                Assert.Throws<ValidationException>(() =>
                    client.ExplicitModel.PostRequiredArrayProperty(null));
                Assert.Throws<ValidationException>(() =>
                    client.ExplicitModel.PostRequiredClassParameter(null));
                Assert.Throws<ValidationException>(() =>
                    client.ExplicitModel.PostRequiredClassProperty(null));
                Assert.Throws<ValidationException>(() =>
                    client.ImplicitModel.GetRequiredGlobalPath());
                Assert.Throws<ValidationException>(() =>
                    client.ImplicitModel.GetRequiredGlobalQuery());
            }
        }

        [Fact]
        public void InternalCtorTest()
        {
            var client = new InternalClient("foo", new Uri("http://test/"));
            Assert.Equal("http://test/foo", client.BaseUri.AbsoluteUri);
        }

        [Fact]
        public void UseDateTimeOffsetInModelTest()
        {
            var productType = typeof(Fixtures.DateTimeOffset.Models.Product);

            //DateTime should be modeled as DateTimeOffset
            Assert.Equal(typeof(DateTimeOffset?), productType.GetProperty("DateTime").PropertyType);
            Assert.Equal(typeof(DateTimeOffset?),
                productType.GetProperty("DateTimeArray").PropertyType.GetGenericArguments()[0]);

            //Dates should be modeled as DateTime
            Assert.Equal(typeof(DateTime?), productType.GetProperty("Date").PropertyType);
            Assert.Equal(typeof(DateTime?), productType.GetProperty("DateArray").PropertyType.GetGenericArguments()[0]);
        }

        [Fact]
        public void FormatUuidModeledAsGuidTest()
        {
            var productType = typeof(Fixtures.MirrorPrimitives.Models.Product);
            Assert.Equal(typeof(Guid?), productType.GetProperty("Uuid").PropertyType);
            Assert.Equal(typeof(IList<Guid?>), productType.GetProperty("UuidArray").PropertyType);
        }

        [Fact]
        public void RequiredOptionalTests()
        {
            SwaggerSpecRunner.RunTests(
                SwaggerPath("required-optional.json"), ExpectedPath("RequiredOptional"));
            using (var client = new AutoRestRequiredOptionalTestService(Fixture.Uri))
            {
                Assert.Equal(HttpStatusCode.OK,
                    client.ImplicitModel.PutOptionalQueryWithHttpMessagesAsync(null).Result.Response.StatusCode);
                Assert.Equal(HttpStatusCode.OK,
                    client.ImplicitModel.PutOptionalBodyWithHttpMessagesAsync(null).Result.Response.StatusCode);
                Assert.Equal(HttpStatusCode.OK,
                    client.ImplicitModel.PutOptionalHeaderWithHttpMessagesAsync(null).Result.Response.StatusCode);
                // This is wrong! Global parameters not working...
                Assert.Equal(HttpStatusCode.OK,
                    client.ImplicitModel.GetOptionalGlobalQueryWithHttpMessagesAsync(null)
                        .Result.Response.StatusCode);

                Assert.Equal(HttpStatusCode.OK,
                    client.ExplicitModel.PostOptionalIntegerParameterWithHttpMessagesAsync(null)
                        .Result.Response.StatusCode);
                Assert.Equal(HttpStatusCode.OK,
                    client.ExplicitModel.PostOptionalIntegerPropertyWithHttpMessagesAsync(null)
                        .Result.Response.StatusCode);
                Assert.Equal(HttpStatusCode.OK,
                    client.ExplicitModel.PostOptionalIntegerHeaderWithHttpMessagesAsync(null)
                        .Result.Response.StatusCode);
                Assert.Equal(HttpStatusCode.OK,
                    client.ExplicitModel.PostOptionalStringParameterWithHttpMessagesAsync(null)
                        .Result.Response.StatusCode);
                Assert.Equal(HttpStatusCode.OK,
                    client.ExplicitModel.PostOptionalStringPropertyWithHttpMessagesAsync(null)
                        .Result.Response.StatusCode);
                Assert.Equal(HttpStatusCode.OK,
                    client.ExplicitModel.PostOptionalStringHeaderWithHttpMessagesAsync(null)
                        .Result.Response.StatusCode);
                Assert.Equal(HttpStatusCode.OK,
                    client.ExplicitModel.PostOptionalClassParameterWithHttpMessagesAsync(null)
                        .Result.Response.StatusCode);
                Assert.Equal(HttpStatusCode.OK,
                    client.ExplicitModel.PostOptionalClassPropertyWithHttpMessagesAsync(null)
                        .Result.Response.StatusCode);
                Assert.Equal(HttpStatusCode.OK,
                    client.ExplicitModel.PostOptionalArrayParameterWithHttpMessagesAsync(null)
                        .Result.Response.StatusCode);
                Assert.Equal(HttpStatusCode.OK,
                    client.ExplicitModel.PostOptionalArrayPropertyWithHttpMessagesAsync(null)
                        .Result.Response.StatusCode);
                Assert.Equal(HttpStatusCode.OK,
                    client.ExplicitModel.PostOptionalArrayHeaderWithHttpMessagesAsync(null)
                        .Result.Response.StatusCode);
            }
        }

        [Fact]
        public void CustomBaseUriTests()
        {
            SwaggerSpecRunner.RunTests(
                SwaggerPath("custom-baseUrl.json"), ExpectedPath("CustomBaseUri"));
            using (var client = new AutoRestParameterizedHostTestClient())
            {
                // small modification to the "host" portion to include the port and the '.'
                client.Host = string.Format(CultureInfo.InvariantCulture, "{0}:{1}", client.Host, Fixture.Port);
                Assert.Equal(HttpStatusCode.OK,
                    client.Paths.GetEmptyWithHttpMessagesAsync("local").Result.Response.StatusCode);
            }
        }

        [Fact]
        public void CustomBaseUriMoreOptionsTests()
        {
            SwaggerSpecRunner.RunTests(
                SwaggerPath("custom-baseUrl-more-options.json"), ExpectedPath("CustomBaseUriMoreOptions"));
            using (var client = new AutoRestParameterizedCustomHostTestClient())
            {
                client.SubscriptionId = "test12";
                // small modification to the "host" portion to include the port and the '.'
                client.DnsSuffix = string.Format(CultureInfo.InvariantCulture, "{0}:{1}", "host", Fixture.Port);
                Assert.Equal(HttpStatusCode.OK,
                    client.Paths.GetEmptyWithHttpMessagesAsync("http://lo", "cal", "key1").Result.Response.StatusCode);
            }
        }

        [Fact]
        public void CustomBaseUriNegativeTests()
        {
            SwaggerSpecRunner.RunTests(
                SwaggerPath("custom-baseUrl.json"), ExpectedPath("CustomBaseUri"));
            using (var client = new AutoRestParameterizedHostTestClient())
            {
                // use a bad acct name
                Assert.Throws<HttpRequestException>(() =>
                    client.Paths.GetEmpty("bad"));

                // pass in null
                Assert.Throws<ValidationException>(() => client.Paths.GetEmpty(null));

                // set the global parameter incorrectly
                client.Host = "badSuffix";
                Assert.Throws<HttpRequestException>(() =>
                    client.Paths.GetEmpty("local"));
            }
        }

        [Fact]
        public void ResourceFlatteningArrayTests()
        {
            using (var client = new AutoRestResourceFlatteningTestService(Fixture.Uri))
            {
                //Array
                var result = client.GetArray();
                Assert.Equal(3, result.Count);
                // Resource 1
                Assert.Equal("1", result[0].Id);
                Assert.Equal("OK", result[0].ProvisioningStateValues);
                Assert.Equal("Product1", result[0].Pname);
                Assert.Equal("Flat", result[0].FlattenedProductType);
                Assert.Equal("Building 44", result[0].Location);
                Assert.Equal("Resource1", result[0].Name);
                Assert.Equal("Succeeded", result[0].ProvisioningState);
                Assert.Equal("Microsoft.Web/sites", result[0].Type);
                Assert.Equal("value1", result[0].Tags["tag1"]);
                Assert.Equal("value3", result[0].Tags["tag2"]);
                // Resource 2
                Assert.Equal("2", result[1].Id);
                Assert.Equal("Resource2", result[1].Name);
                Assert.Equal("Building 44", result[1].Location);
                // Resource 3
                Assert.Equal("3", result[2].Id);
                Assert.Equal("Resource3", result[2].Name);

                var resourceArray = new List<Resource>();
                resourceArray.Add(new FlattenedProduct
                {
                    Location = "West US",
                    Tags = new Dictionary<string, string>
                    {
                        {"tag1", "value1"},
                        {"tag2", "value3"}
                    }
                });
                resourceArray.Add(new FlattenedProduct
                {
                    Location = "Building 44"
                });

                client.PutArray(resourceArray);
            }
        }

        [Fact]
        public void ResourceFlatteningDictionaryTests()
        {
            using (var client = new AutoRestResourceFlatteningTestService(Fixture.Uri))
            {
                //Dictionary
                var resultDictionary = client.GetDictionary();
                Assert.Equal(3, resultDictionary.Count);
                // Resource 1
                Assert.Equal("1", resultDictionary["Product1"].Id);
                Assert.Equal("OK", resultDictionary["Product1"].ProvisioningStateValues);
                Assert.Equal("Product1", resultDictionary["Product1"].Pname);
                Assert.Equal("Flat", resultDictionary["Product1"].FlattenedProductType);
                Assert.Equal("Building 44", resultDictionary["Product1"].Location);
                Assert.Equal("Resource1", resultDictionary["Product1"].Name);
                Assert.Equal("Succeeded", resultDictionary["Product1"].ProvisioningState);
                Assert.Equal("Microsoft.Web/sites", resultDictionary["Product1"].Type);
                Assert.Equal("value1", resultDictionary["Product1"].Tags["tag1"]);
                Assert.Equal("value3", resultDictionary["Product1"].Tags["tag2"]);
                // Resource 2
                Assert.Equal("2", resultDictionary["Product2"].Id);
                Assert.Equal("Resource2", resultDictionary["Product2"].Name);
                Assert.Equal("Building 44", resultDictionary["Product2"].Location);
                // Resource 3
                Assert.Equal("3", resultDictionary["Product3"].Id);
                Assert.Equal("Resource3", resultDictionary["Product3"].Name);

                var resourceDictionary = new Dictionary<string, FlattenedProduct>();
                resourceDictionary.Add("Resource1", new FlattenedProduct
                {
                    Location = "West US",
                    Tags = new Dictionary<string, string>
                    {
                        {"tag1", "value1"},
                        {"tag2", "value3"}
                    },
                    Pname = "Product1",
                    FlattenedProductType = "Flat"
                });
                resourceDictionary.Add("Resource2", new FlattenedProduct
                {
                    Location = "Building 44",
                    Pname = "Product2",
                    FlattenedProductType = "Flat"
                });

                client.PutDictionary(resourceDictionary);
            }
        }

        [Fact]
        public void ResourceFlatteningComplexObjectTests()
        {
            using (var client = new AutoRestResourceFlatteningTestService(Fixture.Uri))
            {
                //ResourceCollection
                var resultResource = client.GetResourceCollection();

                //Dictionaryofresources
                Assert.Equal(3, resultResource.Dictionaryofresources.Count);
                // Resource 1
                Assert.Equal("1", resultResource.Dictionaryofresources["Product1"].Id);
                Assert.Equal("OK", resultResource.Dictionaryofresources["Product1"].ProvisioningStateValues);
                Assert.Equal("Product1", resultResource.Dictionaryofresources["Product1"].Pname);
                Assert.Equal("Flat", resultResource.Dictionaryofresources["Product1"].FlattenedProductType);
                Assert.Equal("Building 44", resultResource.Dictionaryofresources["Product1"].Location);
                Assert.Equal("Resource1", resultResource.Dictionaryofresources["Product1"].Name);
                Assert.Equal("Succeeded", resultResource.Dictionaryofresources["Product1"].ProvisioningState);
                Assert.Equal("Microsoft.Web/sites", resultResource.Dictionaryofresources["Product1"].Type);
                Assert.Equal("value1", resultResource.Dictionaryofresources["Product1"].Tags["tag1"]);
                Assert.Equal("value3", resultResource.Dictionaryofresources["Product1"].Tags["tag2"]);
                // Resource 2
                Assert.Equal("2", resultResource.Dictionaryofresources["Product2"].Id);
                Assert.Equal("Resource2", resultResource.Dictionaryofresources["Product2"].Name);
                Assert.Equal("Building 44", resultResource.Dictionaryofresources["Product2"].Location);
                // Resource 3
                Assert.Equal("3", resultResource.Dictionaryofresources["Product3"].Id);
                Assert.Equal("Resource3", resultResource.Dictionaryofresources["Product3"].Name);

                //Arrayofresources
                Assert.Equal(3, resultResource.Arrayofresources.Count);
                // Resource 1
                Assert.Equal("4", resultResource.Arrayofresources[0].Id);
                Assert.Equal("OK", resultResource.Arrayofresources[0].ProvisioningStateValues);
                Assert.Equal("Product4", resultResource.Arrayofresources[0].Pname);
                Assert.Equal("Flat", resultResource.Arrayofresources[0].FlattenedProductType);
                Assert.Equal("Building 44", resultResource.Arrayofresources[0].Location);
                Assert.Equal("Resource4", resultResource.Arrayofresources[0].Name);
                Assert.Equal("Succeeded", resultResource.Arrayofresources[0].ProvisioningState);
                Assert.Equal("Microsoft.Web/sites", resultResource.Arrayofresources[0].Type);
                Assert.Equal("value1", resultResource.Arrayofresources[0].Tags["tag1"]);
                Assert.Equal("value3", resultResource.Arrayofresources[0].Tags["tag2"]);
                // Resource 2
                Assert.Equal("5", resultResource.Arrayofresources[1].Id);
                Assert.Equal("Resource5", resultResource.Arrayofresources[1].Name);
                Assert.Equal("Building 44", resultResource.Arrayofresources[1].Location);
                // Resource 3
                Assert.Equal("6", resultResource.Arrayofresources[2].Id);
                Assert.Equal("Resource6", resultResource.Arrayofresources[2].Name);

                //productresource
                Assert.Equal("7", resultResource.Productresource.Id);
                Assert.Equal("Resource7", resultResource.Productresource.Name);

                var resourceDictionary = new Dictionary<string, FlattenedProduct>();
                resourceDictionary.Add("Resource1", new FlattenedProduct
                {
                    Location = "West US",
                    Tags = new Dictionary<string, string>
                    {
                        {"tag1", "value1"},
                        {"tag2", "value3"}
                    },
                    Pname = "Product1",
                    FlattenedProductType = "Flat"
                });
                resourceDictionary.Add("Resource2", new FlattenedProduct
                {
                    Location = "Building 44",
                    Pname = "Product2",
                    FlattenedProductType = "Flat"
                });

                var resourceComplexObject = new ResourceCollection
                {
                    Dictionaryofresources = resourceDictionary,
                    Arrayofresources = new List<FlattenedProduct>
                    {
                        new FlattenedProduct
                        {
                            Location = "West US",
                            Tags = new Dictionary<string, string>
                            {
                                {"tag1", "value1"},
                                {"tag2", "value3"}
                            },
                            Pname = "Product1",
                            FlattenedProductType = "Flat"
                        },
                        new FlattenedProduct
                        {
                            Location = "East US",
                            Pname = "Product2",
                            FlattenedProductType = "Flat"
                        }
                    },
                    Productresource = new FlattenedProduct
                    {
                        Location = "India",
                        Pname = "Azure",
                        FlattenedProductType = "Flat"
                    }
                };
                client.PutResourceCollection(resourceComplexObject);
            }
        }

        [Fact]
        public void ModelFlatteningSimpleTest()
        {
            using (var client = new AutoRestResourceFlatteningTestService(Fixture.Uri))
            {
                //Dictionary
                var simpleProduct = new SimpleProduct
                {
                    Description = "product description",
                    ProductId = "123",
                    MaxProductDisplayName = "max name",
                    Odatavalue = "http://foo",
                    GenericValue = "https://generic"
                };
                var resultProduct = client.PutSimpleProduct(simpleProduct);
                Assert.Equal(JsonConvert.SerializeObject(resultProduct), JsonConvert.SerializeObject(simpleProduct));
            }
        }

        [Fact]
        public void ModelFlatteningWithParameterFlatteningTest()
        {
            using (var client = new AutoRestResourceFlatteningTestService(Fixture.Uri))
            {
                //Dictionary
                var simpleProduct = new SimpleProduct
                {
                    Description = "product description",
                    ProductId = "123",
                    MaxProductDisplayName = "max name",
                    Odatavalue = "http://foo"
                };
                var resultProduct = client.PostFlattenedSimpleProduct("123", "max name", "product description", null,
                    "http://foo");
                Assert.Equal(JsonConvert.SerializeObject(resultProduct), JsonConvert.SerializeObject(simpleProduct));
            }
        }

        [Fact]
        public void ModelFlatteningWithGroupingTest()
        {
            using (var client = new AutoRestResourceFlatteningTestService(Fixture.Uri))
            {
                //Dictionary
                var simpleProduct = new SimpleProduct
                {
                    Description = "product description",
                    ProductId = "123",
                    MaxProductDisplayName = "max name",
                    Odatavalue = "http://foo"
                };
                var flattenParameterGroup = new FlattenParameterGroup
                {
                    Description = "product description",
                    ProductId = "123",
                    MaxProductDisplayName = "max name",
                    Odatavalue = "http://foo",
                    Name = "groupproduct"
                };
                var resultProduct = client.PutSimpleProductWithGrouping(flattenParameterGroup);
                Assert.Equal(JsonConvert.SerializeObject(resultProduct), JsonConvert.SerializeObject(simpleProduct));
            }
        }

        [Fact]
        public void SyncMethodsValidation()
        {
            var petstoreWithAllSyncMethods = typeof(SwaggerPetstoreV2Extensions);
            Assert.NotNull(petstoreWithAllSyncMethods.GetMethod("AddPet"));
            Assert.NotNull(petstoreWithAllSyncMethods.GetMethod("AddPetWithHttpMessages"));

            var petstoreWithNoSyncMethods = typeof(Fixtures.PetstoreV2NoSync.SwaggerPetstoreV2Extensions);
            Assert.Null(petstoreWithNoSyncMethods.GetMethod("AddPet"));
            Assert.Null(petstoreWithNoSyncMethods.GetMethod("AddPetWithHttpMessages"));

            var petstoreWithEssentialSyncMethods = typeof(Fixtures.PetstoreV2.SwaggerPetstoreV2Extensions);
            Assert.NotNull(petstoreWithEssentialSyncMethods.GetMethod("AddPet"));
            Assert.Null(petstoreWithEssentialSyncMethods.GetMethod("AddPetWithHttpMessages"));
        }

        public void EnsureTestCoverage()
        {
            SwaggerSpecRunner.RunTests(
                SwaggerPath("report.json"), ExpectedPath("Report"));
            using (var client =
                new AutoRestReportService(Fixture.Uri))
            {
                var factory = new LoggerFactory();
                var logger = factory.CreateLogger<AcceptanceTests>();
                factory.AddConsole();

                var report = client.GetReport();
                //TODO, 4048201: http client incorrectly redirects non-get/head requests when receiving a 301 or 302 response
                var skipped = report.Where(p => p.Value == 0).Select(p => p.Key);
                foreach (var item in skipped)
                {
                    logger.LogInformation(string.Format(CultureInfo.CurrentCulture, "SKIPPED {0}.", item));
                }
#if !LEGACY
                int totalTests = report.Count - 54;
#else
                // TODO: This is fudging some numbers. Fixing the actual problem is a priority.
                int totalTests = report.Count - 3; // there are three tests that fail 
                logger.LogInformation("TODO: FYI, there are three tests that are not actually running.");
#endif
                int executedTests = report.Values.Count(v => v > 0);

                var nullValued = report.Where(p => p.Value == null).Select(p => p.Key);
                foreach (var item in nullValued)
                {
                    logger.LogInformation(string.Format(CultureInfo.CurrentCulture, "MISSING: {0}", item));
                }
                Assert.Equal(totalTests, executedTests);
            }
        }

        private static void EnsureStatusCode(HttpStatusCode expectedStatusCode,
            Func<Task<HttpOperationResponse>> operation)
        {
            var response = operation().GetAwaiter().GetResult();
            Assert.Equal(response.Response.StatusCode, expectedStatusCode);
        }

        private static void EnsureStatusCode<TBody, THeader>(HttpStatusCode expectedStatusCode,
            Func<Task<HttpOperationResponse<TBody, THeader>>> operation)
        {
            var response = operation().GetAwaiter().GetResult();
            Assert.Equal(response.Response.StatusCode, expectedStatusCode);
        }

        private static void EnsureStatusCode<THeader>(HttpStatusCode expectedStatusCode,
            Func<Task<HttpOperationHeaderResponse<THeader>>> operation)
        {
            // Adding retry because of flakiness of TestServer on Travis runs
            HttpRequestException ex = null;
            for (var i = 0; i < 3; i++)
            {
                HttpOperationHeaderResponse<THeader> response;
                try
                {
                    response = operation().GetAwaiter().GetResult();
                }
                catch (HttpRequestException x)
                {
                    Thread.Sleep(10);
                    ex = x;
                    continue;
                }
                Assert.Equal(response.Response.StatusCode, expectedStatusCode);
                return;
            }
            Assert.True(
                false,
                string.Format("EnsureStatusCode for '{0}' failed 3 times in a row. Last failure message: {1}",
                    expectedStatusCode, ex));
        }

        private static void EnsureThrowsWithStatusCode(HttpStatusCode expectedStatusCode,
            Action operation, Action<Error> errorValidator = null)
        {
            EnsureThrowsWithErrorModel(expectedStatusCode, operation, errorValidator);
        }


        private static void EnsureThrowsWithErrorModel<T>(HttpStatusCode expectedStatusCode,
            Action operation, Action<T> errorValidator = null) where T : class
        {
            try
            {
                operation();
                throw new InvalidOperationException("Operation did not throw as expected");
            }
            catch (ErrorException exception)
            {
                Assert.Equal(expectedStatusCode, exception.Response.StatusCode);
                if (errorValidator != null)
                {
                    errorValidator(exception.Body as T);
                }
            }
            catch (MyException exception1)
            {
                Assert.Equal(expectedStatusCode, exception1.Response.StatusCode);
                if (errorValidator != null)
                {
                    errorValidator(exception1.Body as T);
                }
            }
            catch (HttpOperationException exception2)
            {
                Assert.Equal(expectedStatusCode, exception2.Response.StatusCode);
                if (errorValidator != null)
                {
                    errorValidator(exception2.Body as T);
                }
            }
        }

        private static Action<Error> GetDefaultErrorValidator(int code, string message)
        {
            return e =>
            {
                Assert.Equal(code, e.Status);
                Assert.Equal(message, e.Message);
            };
        }

        private static void EnsureThrowsWithStatusCodeAndError(HttpStatusCode expectedStatusCode,
            Action operation, string expectedMessage)
        {
            EnsureThrowsWithStatusCode(expectedStatusCode, operation,
                GetDefaultErrorValidator((int) expectedStatusCode, expectedMessage));
        }

        public void Dispose()
        {
            if (File.Exists(dummyFile))
            {
                File.Delete(dummyFile);
            }
        }
    }
}