diff --git a/test/AutoRest.TestServer.Tests/body-dictionary.cs b/test/AutoRest.TestServer.Tests/body-dictionary.cs new file mode 100644 index 00000000..13dc208f --- /dev/null +++ b/test/AutoRest.TestServer.Tests/body-dictionary.cs @@ -0,0 +1,735 @@ +// Copyright (c) Microsoft Corporation. All rights reserved. +// Licensed under the MIT License. + +using System; +using System.Collections.Generic; +using System.Text.Json; +using System.Threading.Tasks; +using System.Xml; +using AutoRest.TestServer.Tests.Infrastructure; +using body_dictionary; +using body_dictionary.Models.V100; +using NUnit.Framework; + +namespace AutoRest.TestServer.Tests +{ + public class BodyDictionary : TestServerTestBase + { + public BodyDictionary(TestServerVersion version) : base(version, "dictionary") { } + + [Test] + public Task GetDictionaryArrayEmpty() => Test(async (host, pipeline) => + { + var result = await new DictionaryOperations(ClientDiagnostics, pipeline, host).GetArrayEmptyAsync(); + CollectionAssert.IsEmpty(result.Value); + }); + + [Test] + public Task GetDictionaryArrayItemEmpty() => Test(async (host, pipeline) => + { + var result = await new DictionaryOperations(ClientDiagnostics, pipeline, host).GetArrayItemEmptyAsync(); + CollectionAssert.AreEqual(new Dictionary> + { + { "0", new[] { "1", "2", "3" } }, + { "1", new string[] { } }, + { "2", new[] { "7", "8", "9" } } + }, result.Value); + }); + + [Test] + [Ignore("Null collection items: https://github.com/Azure/autorest.csharp/issues/366")] + public Task GetDictionaryArrayItemNull() => Test(async (host, pipeline) => + { + var result = await new DictionaryOperations(ClientDiagnostics, pipeline, host).GetArrayItemNullAsync(); + CollectionAssert.AreEqual(new Dictionary> + { + { "0", new[] { "1", "2", "3" } }, + { "1", null }, + { "2", new[] { "7", "8", "9" } } + }, result.Value); + }); + + [Test] + [Ignore("Null responses: https://github.com/Azure/autorest.csharp/issues/289")] + public Task GetDictionaryArrayNull() => Test(async (host, pipeline) => + { + var result = await new DictionaryOperations(ClientDiagnostics, pipeline, host).GetArrayNullAsync(); + Assert.IsNull(result.Value); + }); + + [Test] + public Task GetDictionaryArrayValid() => Test(async (host, pipeline) => + { + var result = await new DictionaryOperations(ClientDiagnostics, pipeline, host).GetArrayValidAsync(); + CollectionAssert.AreEqual(new Dictionary> + { + { "0", new[] { "1", "2", "3" } }, + { "1", new[] { "4", "5", "6" } }, + { "2", new[] { "7", "8", "9" } } + }, result.Value); + }); + + [Test] + public Task GetDictionaryBase64Url() => Test(async (host, pipeline) => + { + var result = await new DictionaryOperations(ClientDiagnostics, pipeline, host).GetBase64UrlAsync(); + CollectionAssert.AreEqual(new Dictionary + { + //https://stackoverflow.com/a/50525594/294804 + { "0", Convert.FromBase64String("YSBzdHJpbmcgdGhhdCBnZXRzIGVuY29kZWQgd2l0aCBiYXNlNjR1cmw=") }, + { "1", Convert.FromBase64String("dGVzdCBzdHJpbmc=") }, + { "2", Convert.FromBase64String("TG9yZW0gaXBzdW0=") } + }, result.Value); + }); + + [Test] + public Task GetDictionaryBooleanValid() => Test(async (host, pipeline) => + { + var result = await new DictionaryOperations(ClientDiagnostics, pipeline, host).GetBooleanTfftAsync(); + CollectionAssert.AreEqual(new Dictionary + { + { "0", true }, + { "1", false }, + { "2", false }, + { "3", true } + }, result.Value); + }); + + [Test] + [Ignore("Null collection items: https://github.com/Azure/autorest.csharp/issues/366")] + public Task GetDictionaryBooleanWithNull() => Test(async (host, pipeline) => + { + var result = await new DictionaryOperations(ClientDiagnostics, pipeline, host).GetBooleanInvalidNullAsync(); + CollectionAssert.AreEqual(new Dictionary + { + { "0", true }, + { "1", null }, + { "2", false } + }, result.Value); + }); + + [Test] + public Task GetDictionaryBooleanWithString() => Test((host, pipeline) => + { + Assert.ThrowsAsync(async () => await new DictionaryOperations(ClientDiagnostics, pipeline, host).GetBooleanInvalidStringAsync()); + }); + + [Test] + public Task GetDictionaryByteValid() => Test(async (host, pipeline) => + { + var result = await new DictionaryOperations(ClientDiagnostics, pipeline, host).GetByteValidAsync(); + CollectionAssert.AreEqual(new Dictionary + { + { "0", new byte[] { 255, 255, 255, 250 } }, + { "1", new byte[] { 1, 2, 3 } }, + { "2", new byte[] { 37, 41, 67 } } + }, result.Value); + }); + + [Test] + [Ignore("Null collection items: https://github.com/Azure/autorest.csharp/issues/366")] + public Task GetDictionaryByteWithNull() => Test(async (host, pipeline) => + { + var result = await new DictionaryOperations(ClientDiagnostics, pipeline, host).GetByteInvalidNullAsync(); + CollectionAssert.AreEqual(new Dictionary + { + { "0", new byte[] { 171, 172, 173 } }, + { "1", null } + }, result.Value); + }); + + [Test] + public Task GetDictionaryComplexEmpty() => Test(async (host, pipeline) => + { + var result = await new DictionaryOperations(ClientDiagnostics, pipeline, host).GetComplexEmptyAsync(); + CollectionAssert.IsEmpty(result.Value); + }); + + [Test] + public Task GetDictionaryComplexItemEmpty() => Test(async (host, pipeline) => + { + var value = new Dictionary + { + { "0", new Widget { Integer = 1, String = "2" } }, + { "1", new Widget() }, + { "2", new Widget { Integer = 5, String = "6" } } + }; + var result = await new DictionaryOperations(ClientDiagnostics, pipeline, host).GetComplexItemEmptyAsync(); + CollectionAssert.AreEqual(value.Keys, result.Value.Keys); + Assert.AreEqual(value["0"].Integer, result.Value["0"].Integer); + Assert.AreEqual(value["0"].String, result.Value["0"].String); + Assert.AreEqual(value["1"].Integer, result.Value["1"].Integer); + Assert.AreEqual(value["1"].String, result.Value["1"].String); + Assert.AreEqual(value["2"].Integer, result.Value["2"].Integer); + Assert.AreEqual(value["2"].String, result.Value["2"].String); + }); + + [Test] + [Ignore("Null collection items: https://github.com/Azure/autorest.csharp/issues/366")] + public Task GetDictionaryComplexItemNull() => Test(async (host, pipeline) => + { + var value = new Dictionary + { + { "0", new Widget { Integer = 1, String = "2" } }, + { "1", null }, + { "2", new Widget { Integer = 5, String = "6" } } + }; + var result = await new DictionaryOperations(ClientDiagnostics, pipeline, host).GetComplexItemNullAsync(); + CollectionAssert.AreEqual(value.Keys, result.Value.Keys); + Assert.AreEqual(value["0"].Integer, result.Value["0"].Integer); + Assert.AreEqual(value["0"].String, result.Value["0"].String); + Assert.IsNull(result.Value["1"]); + Assert.AreEqual(value["2"].Integer, result.Value["2"].Integer); + Assert.AreEqual(value["2"].String, result.Value["2"].String); + }); + + [Test] + [Ignore("Null responses: https://github.com/Azure/autorest.csharp/issues/289")] + public Task GetDictionaryComplexNull() => Test(async (host, pipeline) => + { + var result = await new DictionaryOperations(ClientDiagnostics, pipeline, host).GetComplexNullAsync(); + Assert.IsNull(result.Value); + }); + + [Test] + public Task GetDictionaryComplexValid() => Test(async (host, pipeline) => + { + var value = new Dictionary + { + { "0", new Widget { Integer = 1, String = "2" } }, + { "1", new Widget { Integer = 3, String = "4" } }, + { "2", new Widget { Integer = 5, String = "6" } } + }; + var result = await new DictionaryOperations(ClientDiagnostics, pipeline, host).GetComplexValidAsync(); + CollectionAssert.AreEqual(value.Keys, result.Value.Keys); + Assert.AreEqual(value["0"].Integer, result.Value["0"].Integer); + Assert.AreEqual(value["0"].String, result.Value["0"].String); + Assert.AreEqual(value["1"].Integer, result.Value["1"].Integer); + Assert.AreEqual(value["1"].String, result.Value["1"].String); + Assert.AreEqual(value["2"].Integer, result.Value["2"].Integer); + Assert.AreEqual(value["2"].String, result.Value["2"].String); + }); + + [Test] + public Task GetDictionaryDateTimeRfc1123Valid() => Test(async (host, pipeline) => + { + var result = await new DictionaryOperations(ClientDiagnostics, pipeline, host).GetDateTimeRfc1123ValidAsync(); + CollectionAssert.AreEqual(new Dictionary + { + { "0", DateTimeOffset.Parse("Fri, 01 Dec 2000 00:00:01 GMT") }, + { "1", DateTimeOffset.Parse("Wed, 02 Jan 1980 00:11:35 GMT") }, + { "2", DateTimeOffset.Parse("Wed, 12 Oct 1492 10:15:01 GMT") } + }, result.Value); + }); + + [Test] + public Task GetDictionaryDateTimeValid() => Test(async (host, pipeline) => + { + var result = await new DictionaryOperations(ClientDiagnostics, pipeline, host).GetDateTimeValidAsync(); + CollectionAssert.AreEqual(new Dictionary + { + { "0", DateTimeOffset.Parse("2000-12-01t00:00:01z") }, + { "1", DateTimeOffset.Parse("1980-01-02T00:11:35+01:00") }, + { "2", DateTimeOffset.Parse("1492-10-12T10:15:01-08:00") } + }, result.Value); + }); + + [Test] + public Task GetDictionaryDateTimeWithInvalidChars() => Test((host, pipeline) => + { + Assert.ThrowsAsync(async () => await new DictionaryOperations(ClientDiagnostics, pipeline, host).GetDateTimeInvalidCharsAsync()); + }); + + [Test] + [Ignore("Null collection items: https://github.com/Azure/autorest.csharp/issues/366")] + public Task GetDictionaryDateTimeWithNull() => Test(async (host, pipeline) => + { + var result = await new DictionaryOperations(ClientDiagnostics, pipeline, host).GetDateTimeInvalidNullAsync(); + CollectionAssert.AreEqual(new Dictionary + { + { "0", DateTimeOffset.Parse("2000-12-01t00:00:01z") }, + { "1", null } + }, result.Value); + }); + + [Test] + public Task GetDictionaryDateValid() => Test(async (host, pipeline) => + { + var result = await new DictionaryOperations(ClientDiagnostics, pipeline, host).GetDateValidAsync(); + CollectionAssert.AreEqual(new Dictionary + { + { "0", DateTimeOffset.Parse("2000-12-01") }, + { "1", DateTimeOffset.Parse("1980-01-02") }, + { "2", DateTimeOffset.Parse("1492-10-12") } + }, result.Value); + }); + + [Test] + public Task GetDictionaryDateWithInvalidChars() => Test((host, pipeline) => + { + Assert.ThrowsAsync(async () => await new DictionaryOperations(ClientDiagnostics, pipeline, host).GetDateInvalidCharsAsync()); + }); + + [Test] + [Ignore("Null collection items: https://github.com/Azure/autorest.csharp/issues/366")] + public Task GetDictionaryDateWithNull() => Test(async (host, pipeline) => + { + var result = await new DictionaryOperations(ClientDiagnostics, pipeline, host).GetDateInvalidNullAsync(); + CollectionAssert.AreEqual(new Dictionary + { + { "0", DateTimeOffset.Parse("2012-01-01") }, + { "1", null }, + { "2", DateTimeOffset.Parse("1776-07-04") } + }, result.Value); + }); + + [Test] + public Task GetDictionaryDictionaryEmpty() => Test(async (host, pipeline) => + { + var result = await new DictionaryOperations(ClientDiagnostics, pipeline, host).GetDictionaryEmptyAsync(); + CollectionAssert.IsEmpty(result.Value); + }); + + [Test] + //TODO: Passes but has a bug: https://github.com/Azure/autorest.modelerfour/issues/106 + public Task GetDictionaryDictionaryItemEmpty() => Test(async (host, pipeline) => + { + var result = await new DictionaryOperations(ClientDiagnostics, pipeline, host).GetDictionaryItemEmptyAsync(); + CollectionAssert.AreEqual(new Dictionary> + { + { "0", new Dictionary { { "1", "one" }, { "2", "two" }, { "3", "three" } } }, + { "1", new Dictionary() }, + { "2", new Dictionary { { "7", "seven" }, { "8", "eight" }, { "9", "nine" } } } + }, result.Value); + }); + + [Test] + [Ignore("Passes because of this bug: https://github.com/Azure/autorest.modelerfour/issues/106, but should fail because of null collection items: https://github.com/Azure/autorest.csharp/issues/366")] + public Task GetDictionaryDictionaryItemNull() => Test(async (host, pipeline) => + { + var result = await new DictionaryOperations(ClientDiagnostics, pipeline, host).GetDictionaryItemNullAsync(); + CollectionAssert.AreEqual(new Dictionary> + { + { "0", new Dictionary { { "1", "one" }, { "2", "two" }, { "3", "three" } } }, + { "1", null }, + { "2", new Dictionary { { "7", "seven" }, { "8", "eight" }, { "9", "nine" } } } + }, result.Value); + }); + + [Test] + [Ignore("Null responses: https://github.com/Azure/autorest.csharp/issues/289")] + public Task GetDictionaryDictionaryNull() => Test(async (host, pipeline) => + { + var result = await new DictionaryOperations(ClientDiagnostics, pipeline, host).GetDictionaryNullAsync(); + Assert.IsNull(result.Value); + }); + + [Test] + //TODO: Passes but has a bug: https://github.com/Azure/autorest.modelerfour/issues/106 + public Task GetDictionaryDictionaryValid() => Test(async (host, pipeline) => + { + var result = await new DictionaryOperations(ClientDiagnostics, pipeline, host).GetDictionaryValidAsync(); + CollectionAssert.AreEqual(new Dictionary> + { + { "0", new Dictionary { { "1", "one" }, { "2", "two" }, { "3", "three" } } }, + { "1", new Dictionary { { "4", "four" }, { "5", "five" }, { "6", "six" } } }, + { "2", new Dictionary { { "7", "seven" }, { "8", "eight" }, { "9", "nine" } } } + }, result.Value); + }); + + [Test] + public Task GetDictionaryDoubleValid() => Test(async (host, pipeline) => + { + var result = await new DictionaryOperations(ClientDiagnostics, pipeline, host).GetDoubleValidAsync(); + CollectionAssert.AreEqual(new Dictionary + { + { "0", 0d }, + { "1", -0.01d }, + { "2", -1.2e20d } + }, result.Value); + }); + + [Test] + [Ignore("Null collection items: https://github.com/Azure/autorest.csharp/issues/366")] + public Task GetDictionaryDoubleWithNull() => Test(async (host, pipeline) => + { + var result = await new DictionaryOperations(ClientDiagnostics, pipeline, host).GetDoubleInvalidNullAsync(); + CollectionAssert.AreEqual(new Dictionary + { + { "0", 0d }, + { "1", null }, + { "2", -1.2e20d } + }, result.Value); + }); + + [Test] + public Task GetDictionaryDoubleWithString() => Test((host, pipeline) => + { + Assert.ThrowsAsync(async () => await new DictionaryOperations(ClientDiagnostics, pipeline, host).GetDoubleInvalidStringAsync()); + }); + + [Test] + public Task GetDictionaryDurationValid() => Test(async (host, pipeline) => + { + var result = await new DictionaryOperations(ClientDiagnostics, pipeline, host).GetDurationValidAsync(); + CollectionAssert.AreEqual(new Dictionary + { + { "0", XmlConvert.ToTimeSpan("P123DT22H14M12.011S") }, + { "1", XmlConvert.ToTimeSpan("P5DT1H") } + }, result.Value); + }); + + [Test] + public Task GetDictionaryEmpty() => Test(async (host, pipeline) => + { + var result = await new DictionaryOperations(ClientDiagnostics, pipeline, host).GetEmptyAsync(); + CollectionAssert.IsEmpty(result.Value); + }); + + [Test] + public Task GetDictionaryFloatValid() => Test(async (host, pipeline) => + { + var result = await new DictionaryOperations(ClientDiagnostics, pipeline, host).GetFloatValidAsync(); + CollectionAssert.AreEqual(new Dictionary + { + { "0", 0f }, + { "1", -0.01f }, + { "2", -1.2e20f } + }, result.Value); + }); + + [Test] + [Ignore("Null collection items: https://github.com/Azure/autorest.csharp/issues/366")] + public Task GetDictionaryFloatWithNull() => Test(async (host, pipeline) => + { + var result = await new DictionaryOperations(ClientDiagnostics, pipeline, host).GetFloatInvalidNullAsync(); + CollectionAssert.AreEqual(new Dictionary + { + { "0", 0f }, + { "1", null }, + { "2", -1.2e20f } + }, result.Value); + }); + + [Test] + public Task GetDictionaryFloatWithString() => Test((host, pipeline) => + { + Assert.ThrowsAsync(async () => await new DictionaryOperations(ClientDiagnostics, pipeline, host).GetFloatInvalidStringAsync()); + }); + + [Test] + public Task GetDictionaryIntegerValid() => Test(async (host, pipeline) => + { + var result = await new DictionaryOperations(ClientDiagnostics, pipeline, host).GetIntegerValidAsync(); + CollectionAssert.AreEqual(new Dictionary + { + { "0", 1 }, + { "1", -1 }, + { "2", 3 }, + { "3", 300 } + }, result.Value); + }); + + [Test] + [Ignore("Null collection items: https://github.com/Azure/autorest.csharp/issues/366")] + public Task GetDictionaryIntegerWithNull() => Test(async (host, pipeline) => + { + var result = await new DictionaryOperations(ClientDiagnostics, pipeline, host).GetIntInvalidNullAsync(); + CollectionAssert.AreEqual(new Dictionary + { + { "0", 1 }, + { "1", null }, + { "2", 0 } + }, result.Value); + }); + + [Test] + public Task GetDictionaryIntegerWithString() => Test((host, pipeline) => + { + Assert.ThrowsAsync(async () => await new DictionaryOperations(ClientDiagnostics, pipeline, host).GetIntInvalidStringAsync()); + }); + + [Test] + public Task GetDictionaryInvalid() => Test((host, pipeline) => + { + Assert.ThrowsAsync(Is.InstanceOf(), async () => await new DictionaryOperations(ClientDiagnostics, pipeline, host).GetInvalidAsync()); + }); + + [Test] + public Task GetDictionaryKeyEmptyString() => Test(async (host, pipeline) => + { + var result = await new DictionaryOperations(ClientDiagnostics, pipeline, host).GetEmptyStringKeyAsync(); + CollectionAssert.AreEqual(new Dictionary + { + { "", "val1" } + }, result.Value); + }); + + [Test] + public Task GetDictionaryLongValid() => Test(async (host, pipeline) => + { + var result = await new DictionaryOperations(ClientDiagnostics, pipeline, host).GetLongValidAsync(); + CollectionAssert.AreEqual(new Dictionary + { + { "0", 1L }, + { "1", -1L }, + { "2", 3L }, + { "3", 300L } + }, result.Value); + }); + + [Test] + [Ignore("Null collection items: https://github.com/Azure/autorest.csharp/issues/366")] + public Task GetDictionaryLongWithNull() => Test(async (host, pipeline) => + { + var result = await new DictionaryOperations(ClientDiagnostics, pipeline, host).GetLongInvalidNullAsync(); + CollectionAssert.AreEqual(new Dictionary + { + { "0", 1L }, + { "1", null }, + { "2", 0L } + }, result.Value); + }); + + [Test] + public Task GetDictionaryLongWithString() => Test((host, pipeline) => + { + Assert.ThrowsAsync(async () => await new DictionaryOperations(ClientDiagnostics, pipeline, host).GetLongInvalidStringAsync()); + }); + + [Test] + [Ignore("Null responses: https://github.com/Azure/autorest.csharp/issues/289")] + public Task GetDictionaryNull() => Test(async (host, pipeline) => + { + var result = await new DictionaryOperations(ClientDiagnostics, pipeline, host).GetNullAsync(); + Assert.IsNull(result.Value); + }); + + [Test] + public Task GetDictionaryNullkey() => Test((host, pipeline) => + { + Assert.ThrowsAsync(Is.InstanceOf(), async () => await new DictionaryOperations(ClientDiagnostics, pipeline, host).GetNullKeyAsync()); + }); + + [Test] + public Task GetDictionaryNullValue() => Test(async (host, pipeline) => + { + var result = await new DictionaryOperations(ClientDiagnostics, pipeline, host).GetNullValueAsync(); + CollectionAssert.AreEqual(new Dictionary + { + { "key1", null } + }, result.Value); + }); + + [Test] + public Task GetDictionaryStringValid() => Test(async (host, pipeline) => + { + var result = await new DictionaryOperations(ClientDiagnostics, pipeline, host).GetStringValidAsync(); + CollectionAssert.AreEqual(new Dictionary + { + { "0", "foo1" }, + { "1", "foo2" }, + { "2", "foo3" } + }, result.Value); + }); + + [Test] + public Task GetDictionaryStringWithNull() => Test(async (host, pipeline) => + { + var result = await new DictionaryOperations(ClientDiagnostics, pipeline, host).GetStringWithNullAsync(); + CollectionAssert.AreEqual(new Dictionary + { + { "0", "foo" }, + { "1", null }, + { "2", "foo2" } + }, result.Value); + }); + + [Test] + public Task GetDictionaryStringWithNumber() => Test((host, pipeline) => + { + Assert.ThrowsAsync(async () => await new DictionaryOperations(ClientDiagnostics, pipeline, host).GetStringWithInvalidAsync()); + }); + + [Test] + public Task PutDictionaryArrayValid() => TestStatus(async (host, pipeline) => + { + var value = new Dictionary> + { + { "0", new[] { "1", "2", "3" } }, + { "1", new[] { "4", "5", "6" } }, + { "2", new[] { "7", "8", "9" } } + }; + return await new DictionaryOperations(ClientDiagnostics, pipeline, host).PutArrayValidAsync(value); + }); + + [Test] + public Task PutDictionaryBooleanValid() => TestStatus(async (host, pipeline) => + { + var value = new Dictionary + { + { "0", true }, + { "1", false }, + { "2", false }, + { "3", true } + }; + return await new DictionaryOperations(ClientDiagnostics, pipeline, host).PutBooleanTfftAsync(value); + }); + + [Test] + public Task PutDictionaryByteValid() => TestStatus(async (host, pipeline) => + { + var value = new Dictionary + { + { "0", new byte[] { 255, 255, 255, 250 } }, + { "1", new byte[] { 1, 2, 3 } }, + { "2", new byte[] { 37, 41, 67 } } + }; + return await new DictionaryOperations(ClientDiagnostics, pipeline, host).PutByteValidAsync(value); + }); + + [Test] + public Task PutDictionaryComplexValid() => TestStatus(async (host, pipeline) => + { + var value = new Dictionary + { + { "0", new Widget { Integer = 1, String = "2" } }, + { "1", new Widget { Integer = 3, String = "4" } }, + { "2", new Widget { Integer = 5, String = "6" } } + }; + return await new DictionaryOperations(ClientDiagnostics, pipeline, host).PutComplexValidAsync(value); + }); + + [Test] + public Task PutDictionaryDateTimeRfc1123Valid() => TestStatus(async (host, pipeline) => + { + var value = new Dictionary + { + { "0", DateTimeOffset.Parse("Fri, 01 Dec 2000 00:00:01 GMT") }, + { "1", DateTimeOffset.Parse("Wed, 02 Jan 1980 00:11:35 GMT") }, + { "2", DateTimeOffset.Parse("Wed, 12 Oct 1492 10:15:01 GMT") } + }; + return await new DictionaryOperations(ClientDiagnostics, pipeline, host).PutDateTimeRfc1123ValidAsync(value); + }); + + [Test] + [IgnoreOnTestServer(TestServerVersion.V2, "Unmatched request")] + public Task PutDictionaryDateTimeValid() => TestStatus(async (host, pipeline) => + { + var value = new Dictionary + { + { "0", DateTimeOffset.Parse("2000-12-01T00:00:01Z") }, + { "1", DateTimeOffset.Parse("1980-01-01T23:11:35Z") }, + { "2", DateTimeOffset.Parse("1492-10-12T18:15:01Z") } + }; + return await new DictionaryOperations(ClientDiagnostics, pipeline, host).PutDateTimeValidAsync(value); + }); + + [Test] + public Task PutDictionaryDateValid() => TestStatus(async (host, pipeline) => + { + var value = new Dictionary + { + { "0", DateTimeOffset.Parse("2000-12-01") }, + { "1", DateTimeOffset.Parse("1980-01-02") }, + { "2", DateTimeOffset.Parse("1492-10-12") } + }; + return await new DictionaryOperations(ClientDiagnostics, pipeline, host).PutDateValidAsync(value); + }); + + [Test] + //TODO: Passes but has a bug: https://github.com/Azure/autorest.modelerfour/issues/106 + public Task PutDictionaryDictionaryValid() => TestStatus(async (host, pipeline) => + { + var value = new Dictionary + { + { "0", new Dictionary { { "1", "one" }, { "2", "two" }, { "3", "three" } } }, + { "1", new Dictionary { { "4", "four" }, { "5", "five" }, { "6", "six" } } }, + { "2", new Dictionary { { "7", "seven" }, { "8", "eight" }, { "9", "nine" } } } + }; + return await new DictionaryOperations(ClientDiagnostics, pipeline, host).PutDictionaryValidAsync(value); + }); + + [Test] + [IgnoreOnTestServer(TestServerVersion.V2, "Unmatched request")] + public Task PutDictionaryDoubleValid() => TestStatus(async (host, pipeline) => + { + var value = new Dictionary + { + { "0", 0d }, + { "1", -0.01d }, + { "2", -1.2e20d } + }; + return await new DictionaryOperations(ClientDiagnostics, pipeline, host).PutDoubleValidAsync(value); + }); + + [Test] + public Task PutDictionaryDurationValid() => TestStatus(async (host, pipeline) => + { + var value = new Dictionary + { + { "0", XmlConvert.ToTimeSpan("P123DT22H14M12.011S") }, + { "1", XmlConvert.ToTimeSpan("P5DT1H") } + }; + return await new DictionaryOperations(ClientDiagnostics, pipeline, host).PutDurationValidAsync(value); + }); + + [Test] + public Task PutDictionaryEmpty() => TestStatus(async (host, pipeline) => + { + var value = new Dictionary(); + return await new DictionaryOperations(ClientDiagnostics, pipeline, host).PutEmptyAsync(value); + }); + + [Test] + [IgnoreOnTestServer(TestServerVersion.V2, "Unmatched request")] + public Task PutDictionaryFloatValid() => TestStatus(async (host, pipeline) => + { + var value = new Dictionary + { + { "0", 0f }, + { "1", -0.01f }, + { "2", -1.2e20f } + }; + return await new DictionaryOperations(ClientDiagnostics, pipeline, host).PutFloatValidAsync(value); + }); + + [Test] + public Task PutDictionaryIntegerValid() => TestStatus(async (host, pipeline) => + { + var value = new Dictionary + { + { "0", 1 }, + { "1", -1 }, + { "2", 3 }, + { "3", 300 } + }; + return await new DictionaryOperations(ClientDiagnostics, pipeline, host).PutIntegerValidAsync(value); + }); + + [Test] + public Task PutDictionaryLongValid() => TestStatus(async (host, pipeline) => + { + var value = new Dictionary + { + { "0", 1L }, + { "1", -1L }, + { "2", 3L }, + { "3", 300L } + }; + return await new DictionaryOperations(ClientDiagnostics, pipeline, host).PutLongValidAsync(value); + }); + + [Test] + public Task PutDictionaryStringValid() => TestStatus(async (host, pipeline) => + { + var value = new Dictionary + { + { "0", "foo1" }, + { "1", "foo2" }, + { "2", "foo3" } + }; + return await new DictionaryOperations(ClientDiagnostics, pipeline, host).PutStringValidAsync(value); + }); + } +} diff --git a/test/scripts/TestList.txt b/test/scripts/TestList.txt index 6928c942..9408881b 100644 Binary files a/test/scripts/TestList.txt and b/test/scripts/TestList.txt differ