Test_Layer.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
 
using AnalyzeRe;
using AnalyzeRe.APITypes;
using AnalyzeRe.Attributes;
using AnalyzeRe.Fees;
using AnalyzeRe.Layers;
using AnalyzeRe.LossSets;
using AnalyzeRe.Utilities;
using AnalyzeReTesting.Base;
using AnalyzeReTesting.Utilities;
 
#if MSTEST
using Microsoft.VisualStudio.TestTools.UnitTesting;
#elif NUNIT
using NUnit.Framework;
using TestClass = NUnit.Framework.TestFixtureAttribute;
using TestMethod = NUnit.Framework.TestAttribute;
using TestCategory = NUnit.Framework.CategoryAttribute;
#endif
 
namespace AnalyzeReTesting.Tests.Model
{
    [TestClass]
    public sealed class TestSuite_Layer_Base : BaseAbstractStoredResourceTestSuite<ILayer>
    {
        protected override IResourceCollection<ILayer> collection_source => API.Layers;
 
        public static IEnumerable<Type> PaymentPatternTypes => new[] { typeof(DelayedPayment), typeof(FixedDatePayment) };
 
        public static void TestLayerInLayerView<T>(T layerToInline, bool shouldSucceed)
            where T : ILayer
        {
            ILayerView<T> inlinedLayerView =
                Samples.GetInjectableLayerView(layerToInline).Unposted;
            if (shouldSucceed)
            {
                // Assert not only that we can post a layer_view containing this layer,
                // but that we can retrieve metrics on this layer_view without issues.
                GenericTest.POST_ThenDoAction(inlinedLayerView,
                    TestSuite_APIResourceView.TestMetricsRetrievable);
            }
            else
                GenericTest.POST_InvalidResource_Fails(inlinedLayerView);
        }
 
        [TestMethod, TestCategory("FixedRateCurrencyConverter")]
        public void Test_Layer_FixedRateCurrencyConverter_POST_NotAllowed()
        {
            GenericTest.POST_InvalidResource_Fails(Samples.Layer_FixedRateCurrencyConverter.Unposted);
        }
 
        [TestMethod, TestCategory("Filter")]
        public void Test_Layer_Filter_POST_Allowed()
        {
            GenericTest.POST_ValidResource(Samples.Layer_Filter.Unposted);
        }
    }
 
    #region Layer Derived Types
    [TestClass]
    public sealed class TestSuite_Layer_AggXL : TestSuite_Layer_AggXL_Base<AggXL>
    {
        #region Set Up and Configuration
        private const string TypeName = "AggXL";
        protected override IInjectableResource<AggXL> TestInjectableResource =>
            Samples.Layer_AggXL;
        #endregion Set Up and Configuration
    }
 
    [TestClass]
    public sealed class TestSuite_Layer_Generic : TestSuite_Layer_AggXL_Base<Generic>
    {
        #region Set Up and Configuration
        private const string TypeName = "Generic";
        protected override IInjectableResource<Generic> TestInjectableResource =>
            Samples.Layer_Generic;
        #endregion Set Up and Configuration
 
        #region POST
        // Includes some additional Reinstatement Type tests.
        #region reinstatements
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_Generic_POST_Reinstatements_Null()
        {
            POST_Attribute_Null(l => l.reinstatements);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_Generic_POST_Reinstatements_Empty()
        {
            POST_ListAttribute_Empty(l => l.reinstatements);
        }
 
        #region reinstatement.premium and .brokerage
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_Generic_POST_Reinstatements_MaxValue()
        {
            List<Reinstatement> newList = new List<Reinstatement> { new Reinstatement { premium = Double.MaxValue, brokerage = Double.MaxValue } };
            POST_WithValue(l => l.reinstatements, newList, true);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_Generic_POST_Reinstatements_MinValue()
        {
            List<Reinstatement> newList = new List<Reinstatement> { new Reinstatement { premium = Double.MinValue, brokerage = Double.MinValue } };
            POST_WithValue(l => l.reinstatements, newList, true);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_Generic_POST_Reinstatements_Zero()
        {
            List<Reinstatement> newList = new List<Reinstatement> { new Reinstatement { premium = 0, brokerage = 0 } };
            POST_WithValue(l => l.reinstatements, newList, true);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_Generic_POST_Reinstatements_NaN()
        {
            List<Reinstatement> newList = new List<Reinstatement> { new Reinstatement { premium = Double.NaN, brokerage = Double.NaN } };
            POST_WithValue(l => l.reinstatements, newList, false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_Generic_POST_Reinstatements_Infinity()
        {
            List<Reinstatement> newList = new List<Reinstatement> { new Reinstatement { premium = Double.PositiveInfinity, brokerage = Double.PositiveInfinity } };
            POST_WithValue(l => l.reinstatements, newList, false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_Generic_POST_Reinstatements_NegativeInfinity()
        {
            List<Reinstatement> newList = new List<Reinstatement> { new Reinstatement { premium = Double.NegativeInfinity, brokerage = Double.NegativeInfinity } };
            POST_WithValue(l => l.reinstatements, newList, false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_Generic_POST_Reinstatements_HighPrecision()
        {
            List<Reinstatement> newList = new List<Reinstatement> {
                new Reinstatement { premium = Math.PI / 1E12, brokerage = Math.PI / 1E12 }
            };
            POST_WithValue(l => l.reinstatements, newList, true);
        }
        #endregion reinstatement.premium and .brokerage
        #endregion reinstatements
        #endregion POST
 
        #region PUT
        #region reinstatements
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_Generic_PUT_Reinstatements()
        {
            List<Reinstatement> newReinstatements = new List<Reinstatement>
            {
                new Reinstatement { brokerage = 1, premium = 1 },
                new Reinstatement { brokerage = 0.5, premium = 1 }
            };
            PUT_WithValue(l => l.reinstatements, newReinstatements, true);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_Generic_PUT_Reinstatements_Empty()
        {
            PUT_ListAttribute_Empty(l => l.reinstatements);
        }
        #endregion reinstatements
        #endregion PUT
    }
 
    [TestClass]
    public sealed class TestSuite_Layer_CatXL : TestSuite_Layer_XL<CatXL>
    {
        #region Set Up and Configuration
        private const string TypeName = "CatXL";
        protected override IInjectableResource<CatXL> TestInjectableResource =>
            Samples.Layer_CatXL;
        #endregion Set Up and Configuration
 
        #region POST
        #region nth
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_CatXL_POST_Nth_MaxValue()
        {
            POST_WithValue(l => l.nth, Int32.MaxValue, true);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_CatXL_POST_Nth_MinValue()
        {
            POST_WithValue(l => l.nth, Int32.MinValue, false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_CatXL_POST_Nth_LessThanOne()
        {
            POST_WithValue(l => l.nth, 0, false);
            POST_WithValue(l => l.nth, -1, false);
        }
        #endregion nth
 
        #region reinstatements
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_CatXL_POST_Reinstatements_Null()
        {
            POST_Attribute_Null(l => l.reinstatements);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_CatXL_POST_Reinstatements_Empty()
        {
            POST_ListAttribute_Empty(l => l.reinstatements);
        }
 
        // Note: Detailed Reinstatements tests exist in the Generic layer tests
        //       the test outcomes are assumed to be shared between the two.
        #endregion reinstatements
        #endregion POST
 
        #region PUT
        #region nth
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_CatXL_PUT_Nth()
        {
            PUT_WithValue(l => l.nth, 5, true);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_CatXL_PUT_Nth_MaxValue()
        {
            PUT_WithValue(l => l.nth, Int32.MaxValue, true);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_CatXL_PUT_Nth_MinValue()
        {
            PUT_WithValue(l => l.nth, Int32.MinValue, false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_CatXL_PUT_Nth_LessThanOne()
        {
            PUT_WithValue(l => l.nth, 0, false);
            PUT_WithValue(l => l.nth, -1, false);
        }
        #endregion nth
 
        #region reinstatements
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_CatXL_PUT_Reinstatements()
        {
            List<Reinstatement> newReinstatements = new List<Reinstatement>
            {
                new Reinstatement { brokerage = 1, premium = 1 },
                new Reinstatement { brokerage = 0.5, premium = 1 }
            };
            PUT_WithValue(l => l.reinstatements, newReinstatements, true);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_CatXL_PUT_Reinstatements_Empty()
        {
            PUT_ListAttribute_Empty(l => l.reinstatements);
        }
        #endregion reinstatements
        #endregion PUT
    }
 
    [TestClass]
    public sealed class TestSuite_Layer_QuotaShare : TestSuite_Layer_QuotaShare_Base<QuotaShare>
    {
        #region Set Up and Configuration
        private const string TypeName = "QuotaShare";
        protected override IInjectableResource<QuotaShare> TestInjectableResource =>
            Samples.Layer_QuotaShare;
        #endregion Set Up and Configuration
    }
 
    [TestClass]
    public sealed class TestSuite_Layer_AggregateQuotaShare
        : TestSuite_Layer_QuotaShare_Base<AggregateQuotaShare>
    {
        #region Set Up and Configuration
        private const string TypeName = "AggregateQuotaShare";
        protected override IInjectableResource<AggregateQuotaShare> TestInjectableResource =>
            Samples.Layer_AggregateQuotaShare;
        #endregion Set Up and Configuration
 
        #region POST
        #region aggregate_attachment
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_AggregateQuotaShare_POST_AggregateAttachment_Null()
        {
            POST_Attribute_Null(l => l.aggregate_attachment);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_AggregateQuotaShare_POST_AggregateAttachment_HighPrecision()
        {
            POST_WithValue(l => l.aggregate_attachment,
               new MonetaryUnit(Math.PI / 1E12, "USD"), true);
        }
        #endregion aggregate_attachment
 
        #region aggregate_limit
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_AggregateQuotaShare_POST_AggregateLimit_Null()
        {
            POST_Attribute_Null(l => l.aggregate_limit);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_AggregateQuotaShare_POST_AggregateLimit_HighPrecision()
        {
            POST_WithValue(l => l.aggregate_limit,
                new MonetaryUnit(Math.PI / 1E12, "USD"), true);
        }
        #endregion aggregate_limit
        #endregion POST
 
        #region PUT
        #region aggregate_attachment
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_AggregateQuotaShare_PUT_AggregateAttachment_Null()
        {
            PUT_Attribute_Null(l => l.aggregate_attachment);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_AggregateQuotaShare_PUT_AggregateAttachment_HighPrecision()
        {
            PUT_WithValue(l => l.aggregate_attachment,
               new MonetaryUnit(Math.PI / 1E12, "USD"), true);
        }
        #endregion aggregate_attachment
 
        #region aggregate_limit
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_AggregateQuotaShare_PUT_AggregateLimit_Null()
        {
            PUT_Attribute_Null(l => l.aggregate_limit);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_AggregateQuotaShare_PUT_AggregateLimit_HighPrecision()
        {
            PUT_WithValue(l => l.aggregate_limit,
                new MonetaryUnit(Math.PI / 1E12, "USD"), true);
        }
        #endregion aggregate_limit
        #endregion PUT
    }
 
    [TestClass]
    public sealed class TestSuite_Layer_SurplusShare : TestSuite_Layer_WithTerms<SurplusShare>
    {
        #region Set Up and Configuration
        private const string TypeName = "SurplusShare";
        protected override IInjectableResource<SurplusShare> TestInjectableResource =>
            Samples.Layer_SurplusShare;
        #endregion Set Up and Configuration
 
        #region POST
        #region sums_insured
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_SurplusShare_POST_SumsInsured_Null()
        {
            POST_Attribute_Null(l => l.sums_insured);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_SurplusShare_POST_SumsInsured_HighPrecision()
        {
            POST_WithValue(l => l.sums_insured,
                new MonetaryUnit(Math.PI / 1E12, "USD"), true);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_SurplusShare_POST_SumsInsured_Negative()
        {
            POST_WithValue(l => l.sums_insured,
                new MonetaryUnit(-100.0, "USD"), true);
        }
        #endregion sums_insured
 
        #region retained_line
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_SurplusShare_POST_RetainedLine_Null()
        {
            POST_Attribute_Null(l => l.retained_line);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_SurplusShare_POST_RetainedLine_HighPrecision()
        {
            POST_WithValue(l => l.retained_line,
                new MonetaryUnit(Math.PI / 1E12, "USD"), true);
        }
        #endregion retained_line
 
        #region participation
        // Disable these inherited test methods and don't set the [TestMethod] attribute - participation is get only, no set.
        public override void Test_Layer_POST_Participation_MaxValue() { }
        public override void Test_Layer_POST_Participation_MinValue() { }
        public override void Test_Layer_POST_Participation_NaN() { }
        public override void Test_Layer_POST_Participation_Infinity() { }
        public override void Test_Layer_POST_Participation_NegativeInfinity() { }
        public override void Test_Layer_POST_Participation_HighPrecision() { }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_SurplusShare_Participation_ServerSide()
        {
            Skip.Indefinitely("ARE-5460: Server doesn't return SurplusShare participation.");
            SurplusShare postedLayer = TestResource_Existing;
 
            // Check that the server_computed participation is being populated behind the scenes
            PropertyInfo privateParticipation = typeof(SurplusShare).GetProperty(
                "server_set_participation", BindingFlags.NonPublic | BindingFlags.Instance);
            double? privateValue = (double?)privateParticipation?.GetValue(postedLayer);
            Assert.IsNotNull(privateValue, "The server didn't supply a participation value!");
            Assert.AreEqual(postedLayer.participation, privateValue);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_SurplusShare_Participation_CientSide()
        {
            // Check that the overridden 'participation' property behaves as expected
            double computed_participation = TestResource.participation;
            SurplusShare postedLayer = TestResource_Existing;
            // The server-side participation is used after post, but it should match our calculations
            AssertApi.DoublesAreEqual(computed_participation, postedLayer.participation);
 
            // Check that there is only one user-facing property that identifies as "participation"
            PropertyInfo participation = typeof(SurplusShare).GetUserFacingProperties()
                .Single(pi => pi.Name.ToLower().Equals(nameof(ILayer_WithTerms.participation)) ||
                    (pi.GetCustomAttributeFast<PropertyAlias>()?.Aliases?
                        .Contains(nameof(ILayer_WithTerms.participation)) ?? false));
 
            // Verify that property that identifies as "participation" returns the same
            // value as the overridden participation property.
            double reflected_value = (double)participation.GetValue(TestResource);
            AssertApi.DoublesAreEqual(computed_participation, reflected_value);
            Console.WriteLine("Property identifying as \"participation\" is named \"" +
                participation.Name + "\" (Value: " + reflected_value + ")");
 
            // Verify that the same is observed if referencing participation without strong typing.
            Layer_WithTerms asWithTerms = postedLayer;
            AssertApi.DoublesAreEqual(computed_participation, asWithTerms.participation);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_SurplusShare_NegativeParticipation()
        {
            // Test that both client and server compute negative participation the same.
            double original_participation = TestResource.participation;
            Assert.IsTrue(original_participation > 0,
                "This test assumes the test resource has a positive computed participation.");
            MonetaryUnit sumsInsured = TestResource.sums_insured;
            SurplusShare negated = TestResource.Change(ss => ss.sums_insured,
                new MonetaryUnit(sumsInsured.value * -1, sumsInsured.currency));
            double computed_negative_participation = negated.participation;
            Assert.AreEqual(-original_participation, computed_negative_participation);
            // Ensure that the server agrees with our calculations
            POST_ThenDoAction(negated, posted =>
                Assert.AreEqual(computed_negative_participation, posted.participation,
                    "Server did not compute the same negative participation as us."));
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_SurplusShare_Participation_NoSet()
        {
            AssertApi.ExceptionThrown<NotSupportedException>(
                () => TestResource.participation = 1);
        }
        #endregion participation
 
        #region number_of_lines
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_SurplusShare_POST_NumberOfLines_MaxValue()
        {
            POST_WithValue(l => l.number_of_lines, Double.MaxValue, true);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_SurplusShare_POST_NumberOfLines_MinValue()
        {
            POST_WithValue(l => l.number_of_lines, Double.MinValue, false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_SurplusShare_POST_NumberOfLines_NaN()
        {
            POST_WithValue(l => l.number_of_lines, Double.NaN, false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_SurplusShare_POST_NumberOfLines_Infinity()
        {
            POST_WithValue(l => l.number_of_lines, Double.PositiveInfinity, false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_SurplusShare_POST_NumberOfLines_NegativeInfinity()
        {
            POST_WithValue(l => l.number_of_lines, Double.NegativeInfinity, false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_SurplusShare_POST_NumberOfLines_HighPrecision()
        {
            POST_WithValue(l => l.number_of_lines, Math.PI / 1E12, true);
        }
        #endregion number_of_lines
        #endregion POST
 
        #region PUT
        #region sums_insured
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_SurplusShare_PUT_SumsInsured_Null()
        {
            PUT_Attribute_Null(l => l.sums_insured);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_SurplusShare_PUT_SumsInsured_HighPrecision()
        {
            PUT_WithValue(l => l.sums_insured,
                new MonetaryUnit(Math.PI / 1E12, "USD"), true);
        }
        #endregion sums_insured
 
        #region retained_line
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_SurplusShare_PUT_RetainedLine_Null()
        {
            PUT_Attribute_Null(l => l.retained_line);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_SurplusShare_PUT_RetainedLine_HighPrecision()
        {
            PUT_WithValue(l => l.retained_line, new MonetaryUnit(Math.PI / 1E12, "USD"), true);
        }
        #endregion retained_line
 
        #region participation
        // Disable this inherited test method and don't set the [TestMethod] attribute - participation is get only, no set.
        public override void Test_Layer_PUT_Participation() { }
        #endregion participation
 
        #region number_of_lines
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_SurplusShare_PUT_NumberOfLines()
        {
            PUT_WithValue(l => l.number_of_lines, 1234.56789, true);
        }
        #endregion number_of_lines
        #endregion PUT
    }
 
    [TestClass]
    public sealed class TestSuite_Layer_IndustryLossWarranty : TestSuite_Layer_WithTerms<IndustryLossWarranty>
    {
        #region Set Up and Configuration
        private const string TypeName = "IndustryLossWarranty";
        protected override IInjectableResource<IndustryLossWarranty> TestInjectableResource =>
            Samples.Layer_IndustryLossWarranty;
        #endregion Set Up and Configuration
 
        #region POST
        #region trigger
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_IndustryLossWarranty_POST_Trigger_Null()
        {
            POST_Attribute_Null(l => l.trigger);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_IndustryLossWarranty_POST_Trigger_HighPrecision()
        {
            POST_WithValue(l => l.trigger,
                new MonetaryUnit(Math.PI / 1E12, "USD"), true);
        }
        #endregion trigger
 
        #region payout
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_IndustryLossWarranty_POST_Payout_Null()
        {
            POST_Attribute_Null(l => l.payout);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_IndustryLossWarranty_POST_Payout_HighPrecision()
        {
            POST_WithValue(l => l.payout,
                new MonetaryUnit(Math.PI / 1E12, "USD"), true);
        }
        #endregion payout
 
        #region nth
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_IndustryLossWarranty_POST_Nth_Null()
        {
            POST_Attribute_Null(l => l.nth);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_IndustryLossWarranty_POST_Nth_MaxValue()
        {
            POST_WithValue(l => l.nth, Int32.MaxValue, true);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_IndustryLossWarranty_POST_Nth_MinValue()
        {
            POST_WithValue(l => l.nth, Int32.MinValue, false);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_IndustryLossWarranty_POST_Nth_LessThanOne()
        {
            POST_WithValue(l => l.nth, 0, false);
            POST_WithValue(l => l.nth, -1, false);
        }
        #endregion nth
        #endregion POST
 
        #region PUT
        #region trigger
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_IndustryLossWarranty_PUT_Trigger_Null()
        {
            PUT_Attribute_Null(l => l.trigger);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_IndustryLossWarranty_PUT_Trigger_HighPrecision()
        {
            PUT_WithValue(l => l.trigger,
                new MonetaryUnit(Math.PI / 1E12, "USD"), true);
        }
        #endregion trigger
 
        #region payout
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_IndustryLossWarranty_PUT_Payout_Null()
        {
            PUT_Attribute_Null(l => l.payout);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_IndustryLossWarranty_PUT_Payout_HighPrecision()
        {
            PUT_WithValue(l => l.payout, new MonetaryUnit(Math.PI / 1E12, "USD"), true);
        }
        #endregion payout
 
        #region nth
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_IndustryLossWarranty_PUT_Nth()
        {
            PUT_WithValue(l => l.nth, 5, true);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_IndustryLossWarranty_PUT_Nth_Null()
        {
            PUT_Attribute_Null(l => l.nth);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_IndustryLossWarranty_PUT_Nth_MaxValue()
        {
            PUT_WithValue(l => l.nth, Int32.MaxValue, true);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_IndustryLossWarranty_PUT_Nth_MinValue()
        {
            PUT_WithValue(l => l.nth, Int32.MinValue, false);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_IndustryLossWarranty_PUT_Nth_LessThanOne()
        {
            PUT_WithValue(l => l.nth, 0, false);
            PUT_WithValue(l => l.nth, -1, false);
        }
        #endregion nth
        #endregion PUT
    }
 
    [TestClass]
    public sealed class TestSuite_Layer_Nested : TestSuite_Layer<Nested>
    {
        #region Set Up and Configuration
        private const string TypeName = "Nested";
        protected override IInjectableResource<Nested> TestInjectableResource =>
            Samples.Layer_Nested;
        #endregion Set Up and Configuration
 
        #region Test Helpers
        public static HashSet<Type> UnsupportedNestedSinkTypes => new HashSet<Type> { typeof(ValueAllocator), typeof(BackAllocatedLayer) };
 
        public static IEnumerable<IInjectableResource<ILayer>> ValidSinkLayerTypesTestList =>
            Samples.AllLayerTypesTestList.Where(i => !UnsupportedNestedSinkTypes.Contains(i.UnderlyingType));
 
        public static IEnumerable<IInjectableResource<ILayer>> ForbiddenSinkLayerTypesTestList =>
            Samples.AllLayerTypesTestList.Where(i => UnsupportedNestedSinkTypes.Contains(i.UnderlyingType));
        #endregion Test Helpers
 
        #region POST
        #region sink
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_Nested_POST_Sink_Null()
        {
            POST_Attribute_Null(l => l.sink);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_Nested_POST_Sink_Reference_NullId()
        {
            POST_Reference_NullId(l => l.sink);
            // Try a "null" version of various reference types to ensure our serializer can handle it.
            POST_WithValue(l => l.sink, new Reference<ILayer>((string)null), false);
            POST_WithValue(l => l.sink, new Reference<Layer>((string)null), false);
            POST_WithValue(l => l.sink, new Reference<ILayerView>((string)null), false);
            POST_WithValue(l => l.sink, new Reference<ILayerSource>((string)null), false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_Nested_POST_Sink_Reference_EmptyStringId()
        {
            //POST_Reference_EmptyStringId(l => l.sink);
            IReference<ILayer> reference = new Reference<Layer>("");
            POST_WithValue(l => l.sink, reference, false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_Nested_POST_Sink_Reference_NonExistantId()
        {
            //POST_Reference_NonExistantId(l => l.sink);
            IReference<ILayer> reference = new Reference<Layer>(Samples.Valid_NonExistant_UUID);
            POST_WithValue(l => l.sink, reference, false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_Nested_POST_Sink_EveryType()
        {
            // Loop over each layer type, generate and test POST a testResource with it.
            foreach (IInjectableResource<ILayer> layer in ValidSinkLayerTypesTestList
                    .Where(l => !l.UnderlyingType.IsAttributeDefinedFast<NotSaveableAttribute>()))
                POST_WithValue(l => l.sink, layer.AsReference, true);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_Nested_POST_Sink_Inlined()
        {
            // Demonstrate that posting Nested layers with inlined sinks is disallowed.
            // LayerViews, however, allow the inlining
            foreach (IInjectableResource<ILayer> layer in ValidSinkLayerTypesTestList)
                POST_WithValue_Inconsistent(l => l.sink, layer.AsInlinedReference, false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_Nested_POST_Sink_LayerViewReference()
        {
            Skip.UntilRelease.Validation("ARE-6190: Referenced LayerViews cause Internal Server Error");
            // While the Nested Layer sink can hold a layer_view reference, these cannot be saved
            foreach (IInjectableResource<ILayerView> layerView in Samples.AllLayerViewTypesTestList)
                POST_WithValue_Inconsistent(l => l.sink, layerView.AsReference, false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_Nested_POST_Sink_InvalidType()
        {
            foreach (IInjectableResource<ILayer> layer in ForbiddenSinkLayerTypesTestList)
            {
                // Test invalid types as layer references
                POST_WithValue(l => l.sink, layer.AsReference, false);
                // Test invalid types as inlined layer definitions
                POST_WithValue(l => l.sink, layer.AsInlinedReference, false);
            }
        }
        #endregion sink
 
        #region sources
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_Nested_POST_Sources_Null()
        {
            POST_WithValue(l => l.sources, null, false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_Nested_POST_Sources_Empty()
        {
            // BUG: ARE-3548 - Nested "sources" can't be empty on POST, but can be empty in a LayerView
            POST_WithValue_Inconsistent(l => l.sources, new Nested.Sources(), false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_Nested_POST_Sources_Invalid()
        {
            POST_ReferenceList_NonExistantId(l => l.sources);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_Nested_POST_Sources_Duplicates()
        {
            // BUG: ARE-3553 - Inconsistency: /layers/ forbids duplicate layer references
            //                 in "sources", but /layer_views/ does not.
            POST_WithValue_Inconsistent(l => l.sources, new Nested.Sources(
                Samples.Layer_QuotaShare.AsReference, Samples.Layer_QuotaShare.AsReference), false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_Nested_POST_Sources_ContainsSink()
        {
            // This is actually okay, the same layer definition can be used both as a source,
            // and the sink that all the sources are put through. This is because even
            // if they are passed as references, they are only used for their layer terms.
            POST_WithValue(l => l.sources, new Nested.Sources(TestResource.sink), true);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_Nested_POST_Sources_EveryType()
        {
            POST_WithValue(l => l.sources, new Nested.Sources(
                Samples.AllSaveableLayerTypesTestList.Select(s => s.AsReference)), true);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_Nested_POST_Sources_Inlined()
        {
            // Inlined sources are not allowed for saved layers, but are okay for layer_views
            POST_WithValue_Inconsistent(l => l.sources, new Nested.Sources(
                Samples.AllLayerTypesTestList.Select(s => s.AsInlinedReference)), false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_Nested_POST_Sources_LayerViewReference()
        {
            Skip.UntilRelease.Validation("ARE-6190: Referenced LayerViews cause Internal Server Error");
            // LayerView references are not allowed for saved layers, but are okay for layer_views
            POST_WithValue_Inconsistent(l => l.sources, new Nested.Sources(
                Samples.AllLayerViewTypesTestList.Select(s => s.AsReference)), false);
        }
        #endregion sources
        #endregion POST
 
        #region PUT
        #region sink
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_Nested_PUT_Sink()
        {
            PUT_WithValue(l => l.sink, Samples.Layer_QuotaShare.AsReference, true);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_Nested_PUT_Sink_Null()
        {
            PUT_Attribute_Null(l => l.sink);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_Nested_PUT_Sink_Reference_NullId()
        {
            PUT_Reference_NullId(l => l.sink);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_Nested_PUT_Sink_Reference_EmptyStringId()
        {
            PUT_Reference_EmptyStringId(l => l.sink);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_Nested_PUT_Sink_Reference_NonExistantId()
        {
            PUT_Reference_NonExistantId(l => l.sink);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_Nested_PUT_Sink_EveryType()
        {
            // Loop over each layer type, generate and test PUT a testResource with it.
            foreach (IInjectableResource<ILayer> layer in ValidSinkLayerTypesTestList
                    .Where(l => !l.UnderlyingType.IsAttributeDefinedFast<NotSaveableAttribute>()))
                PUT_WithValue(l => l.sink, layer.AsReference, true);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_Nested_PUT_Sink_Inlined()
        {
            // Demonstrate that updating Nested layers with inlined sinks is disallowed.
            foreach (IInjectableResource<ILayer> layer in Samples.AllLayerTypesTestList)
                PUT_WithValue(l => l.sink, layer.AsInlinedReference, false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_Nested_PUT_Sink_LayerViewReference()
        {
            Skip.UntilRelease.Validation("ARE-6190: Referenced LayerViews cause Internal Server Error");
            // While the Nested Layer can hold a layer_view reference, these cannot be saved
            foreach (IInjectableResource<ILayerView> layerView in Samples.AllLayerViewTypesTestList)
                PUT_WithValue(l => l.sink, layerView.AsReference, false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_Nested_PUT_Sink_InvalidType()
        {
            foreach (IInjectableResource<ILayer> layer in ForbiddenSinkLayerTypesTestList)
            {
                // Test invalid types as layer references
                PUT_WithValue(l => l.sink, layer.AsReference, false);
                // Test invalid types as inlined layer definitions
                PUT_WithValue(l => l.sink, layer.AsInlinedReference, false);
            }
        }
        #endregion sink
 
        #region sources
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_Nested_PUT_Sources()
        {
            PUT_WithValue(l => l.sources,
                new Nested.Sources(Samples.Layer_QuotaShare.AsReference), true);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_Nested_PUT_Sources_Null()
        {
            PUT_Attribute_Null(l => l.sources);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_Nested_PUT_Sources_Empty()
        {
            PUT_ListAttribute_Empty(l => l.sources);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_Nested_PUT_Sources_Invalid()
        {
            PUT_ReferenceList_NonExistantId(l => l.sources);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_Nested_PUT_Sources_Duplicates()
        {
            PUT_ListAttribute_Duplicates(l => l.sources,
                (IReference<ILayerSource>)Samples.Layer_QuotaShare.AsReference, false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_Nested_PUT_Sources_EveryType()
        {
            PUT_WithValue(l => l.sources, new Nested.Sources(
                Samples.AllSaveableLayerTypesTestList.Select(sample => sample.AsReference)), true);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_Nested_PUT_Sources_Inlined()
        {
            // Demonstrate that posting Nested layers with inlined sources is disallowed.
            PUT_WithValue(l => l.sources, new Nested.Sources(
                Samples.AllLayerTypesTestList.Select(sample => sample.AsInlinedReference)), false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_Nested_PUT_Sources_LayerViewReference()
        {
            Skip.UntilRelease.Validation("ARE-6190: Referenced LayerViews cause Internal Server Error");
            // Demonstrate that posting Nested layer_view references is disallowed.
            PUT_WithValue(l => l.sources, new Nested.Sources(
                Samples.AllLayerViewTypesTestList.Select(s => s.AsReference)), false);
        }
        #endregion sources
        #endregion PUT
    }
 
    [TestClass]
    public sealed class TestSuite_Layer_Filter : TestSuite_Layer_Unsaveable<Filter>
    {
        #region Set Up and Configuration
        private const string TypeName = "Filter";
        protected override IInjectableResource<Filter> TestInjectableResource =>
            Samples.Layer_Filter;
        #endregion Set Up and Configuration
 
        #region POST
        #region Test Invert
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_Filter_POST_Invert()
        {
            POST_WithValue(l => l.invert, true, true);
        }
        #endregion Test Invert
 
        #region Test Filters
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_Filter_POST_Filters()
        {
            POST_WithValue(l => l.filters, new List<IReference<LossFilter>> {
                Samples.LossFilter_GTFilter.AsReference }, true);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_Filter_POST_Filters_Null()
        {
            POST_Attribute_Null(l => l.filters);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_Filter_POST_Filters_NonExistantId()
        {
            //POST_ReferenceList_NonExistantId(l => l.filters);
            POST_WithValue(l => l.filters, new List<IReference<LossFilter>> {
                new Reference<LossFilter>(Samples.Valid_NonExistant_UUID) }, false);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_Filter_POST_Filters_Empty()
        {
            POST_WithValue(l => l.filters, new List<IReference<LossFilter>>(), true);
            //POST_ListAttribute_Empty(l => l.filters);
        }
        
        // After ARE-7829 implementation, the following two tests were failing in the base class
        // An override was added here to correctly handle the updated API logic.
        [TestMethod, TestCategory(TypeName)]
        public override void Test_Resource_POST_FieldsIdOnly()
        {
            GenericTest.POST_ValidResource(TestResource);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public override void Test_Resource_POST_Valid()
        {
            // Only in this base test - confirm that a layer with this type cannot be posted
            GenericTest.POST_ValidResource(TestResource);
            // Now test that it can be posted as part of a layer_view
            TestSuite_Layer_Base.TestLayerInLayerView(TestResource, true);
        }
 
        #endregion Test Filters
        #endregion POST
 
        #region PUT
        /* PUT Tests are disabled until there is some way to save these layers
        #region Test Invert
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_Filter_PUT_Invert()
        {
            PUT_WithValue(l => l.invert, true, true);
        }
        #endregion Test Invert
 
        #region Test Filters
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_Filter_PUT_Filters()
        {
            PUT_WithValue(l => l.filters, new List<IReference<LossFilter>> {
                Samples.LossFilter_GTFilter.AsReference }, true);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_Filter_PUT_Filters_NonExistantId()
        {
            PUT_ReferenceList_NonExistantId(l => l.filters);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_Filter_PUT_Filters_Empty()
        {
            PUT_ListAttribute_Empty(l => l.filters);
        }
        #endregion Test Filters
        */
        #endregion PUT
    }
 
    [TestClass]
    public sealed class TestSuite_Layer_FixedRateCurrencyConverter
        : TestSuite_Layer_Unsaveable<FixedRateCurrencyConverter>
    {
        #region Set Up and Configuration
        private const string TypeName = "FixedRateCurrencyConverter";
        protected override IInjectableResource<FixedRateCurrencyConverter> TestInjectableResource =>
            Samples.Layer_FixedRateCurrencyConverter;
        #endregion Set Up and Configuration
 
        #region POST
        #region in_currency
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_FixedRateCurrencyConverter_POST_InCurrency_Null()
        {
            POST_Attribute_Null(l => l.in_currency);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_FixedRateCurrencyConverter_POST_InCurrency_Empty()
        {
            //POST_StringAttribute_Empty(l => l.in_currency);
            POST_WithValue(l => l.in_currency, "", false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_FixedRateCurrencyConverter_POST_InCurrency_TooShort()
        {
            POST_WithValue(l => l.in_currency, "AU", false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_FixedRateCurrencyConverter_POST_InCurrency_TooLong()
        {
            POST_WithValue(l => l.in_currency, "asdf", false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_FixedRateCurrencyConverter_POST_InCurrency_ValidISO()
        {
            POST_WithValue(l => l.in_currency, "EUR", true);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_FixedRateCurrencyConverter_POST_InCurrency_InvalidCurrencyConversion()
        {
            // This is a valid ISO currency code, but it's not in the exchange rate table,
            // and doesn't match the underlying loss set currency, so we expect a
            // BadRequest error due to a missing exchange rate.
            POST_WithValue(l => l.in_currency, "AED", false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_FixedRateCurrencyConverter_POST_InCurrency_InvalidISO()
        {
            if (EnvironmentSettings.RUN_OFFLINE)
                Assert.Inconclusive("RUN_OFFLINE = true");
            // For simplicity, we'll just modify a copy of a sample ELT loss set that already has data.
            ELTLossSet lossSet = Samples.LossSet_ELTLossSet.Posted
                .Change(ls => ls.currency, "AAA").Post().PollUntilReady(Samples.DataPollingOptions);
            // This is NOT a valid ISO currency code, but the system should allow it as long as the
            // underlying loss set has the same currency code (thereby requiring no automatic conversion)
            FixedRateCurrencyConverter toTest = Samples.Layer_FixedRateCurrencyConverter.Unposted
                .Change(layer => layer.in_currency, "AAA")
                .Change(layer => layer.loss_sets, new List<IReference<LossSet>> { lossSet.ToReference() });
            TestSuite_Layer_Base.TestLayerInLayerView(toTest, true);
            // TODO: Use this instead when layer is saveable
            // POST_ThenDoAction(toTest, AdditionalValidResourceTests);
        }
        #endregion in_currency
 
        #region out_currency
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_FixedRateCurrencyConverter_POST_OutCurrency_Null()
        {
            POST_Attribute_Null(l => l.out_currency);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_FixedRateCurrencyConverter_POST_OutCurrency_Empty()
        {
            //POST_StringAttribute_Empty(l => l.out_currency);
            POST_WithValue(l => l.out_currency, "", false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_FixedRateCurrencyConverter_POST_OutCurrency_TooShort()
        {
            POST_WithValue(l => l.out_currency, "AU", false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_FixedRateCurrencyConverter_POST_OutCurrency_TooLong()
        {
            POST_WithValue(l => l.out_currency, "asdf", false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_FixedRateCurrencyConverter_POST_OutCurrency_ValidISO()
        {
            POST_WithValue(l => l.out_currency, "EUR", true);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_FixedRateCurrencyConverter_POST_OutCurrency_InvalidISO()
        {
            POST_WithValue(l => l.out_currency, "AAA", true);
        }
        #endregion out_currency
 
        #region rate
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_FixedRateCurrencyConverter_POST_Rate()
        {
            POST_WithValue(l => l.rate, 1.23, true);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_FixedRateCurrencyConverter_POST_Rate_Zero()
        {
            POST_WithValue(l => l.rate, 0, true);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_FixedRateCurrencyConverter_POST_Rate_Negative()
        {
            POST_WithValue(l => l.rate, -1.23, true);
        }
        #endregion rate
        #endregion POST
 
        #region PUT
        /* PUT Tests are disabled until there is some way to save these layers
        #region in_currency
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_FixedRateCurrencyConverter_PUT_InCurrency_Null()
        {
            PUT_Attribute_Null(l => l.in_currency);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_FixedRateCurrencyConverter_PUT_InCurrency_Empty()
        {
            PUT_StringAttribute_Empty(l => l.in_currency);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_FixedRateCurrencyConverter_PUT_InCurrency_TooShort()
        {
            PUT_WithValue(l => l.in_currency, "AU", shouldSucceed: false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_FixedRateCurrencyConverter_PUT_InCurrency_TooLong()
        {
            PUT_WithValue(l => l.in_currency, "asdf", shouldSucceed: false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_FixedRateCurrencyConverter_PUT_InCurrency_ValidISO()
        {
            PUT_WithValue(l => l.in_currency, "EUR", shouldSucceed: true);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_FixedRateCurrencyConverter_PUT_InCurrency_InvalidISO()
        {
            PUT_WithValue(l => l.in_currency, "AAA", shouldSucceed: true);
        }
        #endregion in_currency
 
        #region out_currency
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_FixedRateCurrencyConverter_PUT_OutCurrency_Null()
        {
            PUT_Attribute_Null(l => l.out_currency);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_FixedRateCurrencyConverter_PUT_OutCurrency_Empty()
        {
            PUT_StringAttribute_Empty(l => l.out_currency);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_FixedRateCurrencyConverter_PUT_OutCurrency_TooShort()
        {
            PUT_WithValue(l => l.out_currency, "AU", shouldSucceed: false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_FixedRateCurrencyConverter_PUT_OutCurrency_TooLong()
        {
            PUT_WithValue(l => l.out_currency, "asdf", shouldSucceed: false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_FixedRateCurrencyConverter_PUT_OutCurrency_ValidISO()
        {
            PUT_WithValue(l => l.out_currency, "EUR", shouldSucceed: true);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_FixedRateCurrencyConverter_PUT_OutCurrency_InvalidISO()
        {
            PUT_WithValue(l => l.out_currency, "AAA", shouldSucceed: true);
        }
        #endregion out_currency
 
        #region rate
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_FixedRateCurrencyConverter_PUT_Rate()
        {
            PUT_WithValue(l => l.rate, 1.23, shouldSucceed: true);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_FixedRateCurrencyConverter_PUT_Rate_Zero()
        {
            PUT_WithValue(l => l.rate, 0, shouldSucceed: true);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_FixedRateCurrencyConverter_PUT_Rate_Negative()
        {
            PUT_WithValue(l => l.rate, -1.23, shouldSucceed: true);
        }
        #endregion rate
        */
        #endregion PUT
    }
 
    [TestClass]
    public sealed class TestSuite_Layer_LossRank : TestSuite_Layer_WithLossSets<LossRank>
    {
        #region Set Up and Configuration
        private const string TypeName = "LossRank";
        protected override IInjectableResource<LossRank> TestInjectableResource =>
            Samples.Layer_LossRank;
        #endregion Set Up and Configuration
 
        #region POST
        #region Test Invert
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_LossRank_POST_Invert()
        {
            POST_WithValue(l => l.invert, true, true);
        }
        #endregion Test Invert
 
        #region Test Count
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_LossRank_POST_Count()
        {
            POST_WithValue(l => l.count, 100, true);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_LossRank_POST_Count_Max()
        {
            POST_WithValue(l => l.count, Int32.MaxValue, true);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_LossRank_POST_Count_Min()
        {
            POST_WithValue(l => l.count, 0, true);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_LossRank_POST_Count_LessThanMin()
        {
            POST_WithValue(l => l.count, Int32.MinValue, false);
        }
        #endregion Test Count
 
        #region Test Criterion
        // TODO: Uncomment when criterion is fixed (ARE-6251 for context)
        // [TestMethod, TestCategory(TypeName)]
        // public void Test_Layer_LossRank_POST_Criterion()
        // {
        //     POST_WithValue(l => l.criterion, LossRank.Criterion.SmallestLoss, true);
        // }
 
        // TODO: Uncomment when criterion is fixed (ARE-6251 for context)
        // [TestMethod, TestCategory(TypeName)]
        // public void Test_Layer_LossRank_POST_Criterion_Unknown()
        // {
        //     POST_WithValue(l => l.criterion, (LossRank.Criterion)0xff, false);
        // }
        #endregion Test Criterion
        #endregion POST
 
        #region PUT
        #region Test Invert
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_LossRank_PUT_Invert()
        {
            PUT_WithValue(l => l.invert, true, true);
        }
        #endregion Test Invert
 
        #region Test Count
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_LossRank_PUT_Count()
        {
            PUT_WithValue(l => l.count, 100, true);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_LossRank_PUT_Count_Max()
        {
            PUT_WithValue(l => l.count, Int32.MaxValue, true);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_LossRank_PUT_Count_Min()
        {
            PUT_WithValue(l => l.count, Int32.MinValue, false);
        }
        #endregion Test Count
 
        #region Test Criterion
        // TODO: Uncomment when criterion is fixed (ARE-6251 for context)
        // [TestMethod, TestCategory(TypeName)]
        // public void Test_Layer_LossRank_PUT_Criterion()
        // {
        //     PUT_WithValue(l => l.criterion, LossRank.Criterion.SmallestLoss, true);
        // }
 
        // TODO: Uncomment when criterion is fixed (ARE-6251 for context)
        // [TestMethod, TestCategory(TypeName)]
        // public void Test_Layer_LossRank_PUT_Criterion_Unknown()
        // {
        //     PUT_WithValue(l => l.criterion, (LossRank.Criterion)0xff, false);
        // }
        #endregion Test Criterion
        #endregion PUT
    }
 
    [TestClass]
    public sealed class TestSuite_Layer_NoClaimsBonus : TestSuite_Layer_WithLossSets<NoClaimsBonus>
    {
        #region Set Up and Configuration
        private const string TypeName = "NoClaimsBonus";
        protected override IInjectableResource<NoClaimsBonus> TestInjectableResource =>
            Samples.Layer_NoClaimsBonus;
        #endregion Set Up and Configuration
 
        #region POST
        #region payout_amount
        [TestMethod, TestCategory(TypeName)]
        public void TestSuite_Layer_NoClaimsBonus_POST_PayoutAmount_Null()
        {
            POST_Attribute_Null(l => l.payout_amount);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void TestSuite_Layer_NoClaimsBonus_POST_PayoutAmount_HighPrecision()
        {
            POST_WithValue(l => l.payout_amount, new MonetaryUnit(Math.PI / 1E12, "USD"), true);
        }
        #endregion payout_amount
 
        #region payout_date
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_POST_PayoutDate_Null()
        {
            POST_WithValue(l => l.payout_date, null, false);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_POST_PayoutDate()
        {
            POST_WithValue(l => l.payout_date, DateTime.UtcNow, true);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_POST_PayoutDate_MinValue()
        {
            POST_WithValue(l => l.payout_date,
                new DateTime(DateTime.MinValue.Ticks, DateTimeKind.Utc), true);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_POST_PayoutDate_MaxValue()
        {
            POST_WithValue(l => l.payout_date,
                new DateTime(DateTime.MaxValue.Ticks, DateTimeKind.Utc), true);
        }
        #endregion payout_date
        #endregion POST
 
        #region PUT
        #region payout_amount
        [TestMethod, TestCategory(TypeName)]
        public void TestSuite_Layer_NoClaimsBonus_PUT_PayoutAmount_Null()
        {
            PUT_Attribute_Null(l => l.payout_amount);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void TestSuite_Layer_NoClaimsBonus_PUT_PayoutAmount_HighPrecision()
        {
            PUT_WithValue(l => l.payout_amount, new MonetaryUnit(Math.PI / 1E12, "USD"), true);
        }
        #endregion payout_amount
 
        #region payout_date
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_PUT_PayoutDate_Null()
        {
            PUT_WithValue(l => l.payout_date, null, false);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_PUT_PayoutDate()
        {
            PUT_WithValue(l => l.payout_date,
                TestResource.payout_date.Value.Subtract(new TimeSpan(0, 0, 0, 1)), true);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_PUT_PayoutDate_MinValue()
        {
            PUT_WithValue(l => l.payout_date,
                new DateTime(DateTime.MinValue.Ticks, DateTimeKind.Utc), true);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_PUT_PayoutDate_MaxValue()
        {
            PUT_WithValue(l => l.payout_date,
                new DateTime(DateTime.MaxValue.Ticks, DateTimeKind.Utc), true);
        }
        #endregion payout_date
        #endregion PUT
    }
 
    [TestClass]
    public sealed class TestSuite_Layer_ValueAllocator : TestSuite_Layer<ValueAllocator>
    {
        #region Set Up and Configuration
        private const string TypeName = "ValueAllocator";
        protected override IInjectableResource<ValueAllocator> TestInjectableResource =>
            Samples.Layer_ValueAllocator;
        #endregion Set Up and Configuration
 
        #region POST
        #region source
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_ValueAllocator_POST_Source_Null()
        {
            POST_Attribute_Null(l => l.source);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_ValueAllocator_POST_Source_Reference_NullId()
        {
            //POST_Reference_NullId(l => l.source);
            IReference<ILayer> reference = new Reference<Layer>((string)null);
            POST_WithValue(l => l.source, reference, false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_ValueAllocator_POST_Source_Reference_EmptyStringId()
        {
            //POST_Reference_EmptyStringId(l => l.source);
            IReference<ILayer> reference = new Reference<Layer>("");
            POST_WithValue(l => l.source, reference, false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_ValueAllocator_POST_Source_Reference_NonExistantId()
        {
            //POST_Reference_NonExistantId(l => l.source);
            IReference<ILayer> reference = new Reference<Layer>(Samples.Valid_NonExistant_UUID);
            POST_WithValue(l => l.source, reference, false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_ValueAllocator_POST_Source_EveryType()
        {
            // Loop over each layer type, generate and test POST a testResource with it.
            foreach (IInjectableResource<ILayer> layer in Samples.AllSaveableLayerTypesTestList)
                POST_WithValue(l => l.source, layer.AsReference, true);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_ValueAllocator_POST_Source_Inlined()
        {
            // While the ValueAllocator can hold an inlined layer definition,
            // these are only allowed when posting as a layer_view, not a layer.
            foreach (IInjectableResource<ILayer> layer in Samples.AllLayerTypesTestList)
                POST_WithValue_Inconsistent(l => l.source, layer.AsInlinedReference, false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_ValueAllocator_POST_Source_LayerViewReference()
        {
            Skip.UntilRelease.Validation("ARE-6190: Referenced LayerViews cause Internal Server Error");
            // While the ValueAllocator can hold a layer_view reference,
            // these are only allowed when posting as a layer_view, not a layer.
            foreach (IInjectableResource<ILayerView> layerView in Samples.AllLayerViewTypesTestList)
                POST_WithValue_Inconsistent(l => l.source, layerView.AsReference, false);
        }
        #endregion source
 
        #region target
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_ValueAllocator_POST_Target_Null()
        {
            POST_Attribute_Null(l => l.target);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_ValueAllocator_POST_Target_Reference_NullId()
        {
            //POST_Reference_NullId(l => l.target);
            IReference<ILayer> reference = new Reference<Layer>((string)null);
            POST_WithValue(l => l.target, reference, false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_ValueAllocator_POST_Target_Reference_EmptyStringId()
        {
            //POST_Reference_EmptyStringId(l => l.target);
            IReference<ILayer> reference = new Reference<Layer>("");
            POST_WithValue(l => l.target, reference, false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_ValueAllocator_POST_Target_Reference_NonExistantId()
        {
            //POST_Reference_NonExistantId(l => l.target);
            IReference<ILayer> reference = new Reference<Layer>(Samples.Valid_NonExistant_UUID);
            POST_WithValue(l => l.target, reference, false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_ValueAllocator_POST_Target_EveryType()
        {
            // Loop over each layer type, generate and test POST a testRetarget with it.
            foreach (IInjectableResource<ILayer> layer in Samples.AllSaveableLayerTypesTestList)
                POST_WithValue(l => l.target, layer.AsReference, true);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_ValueAllocator_POST_Target_Inlined()
        {
            // Demonstrate that posting Nested layers with inlined targets is disallowed.
            foreach (IInjectableResource<ILayer> layer in Samples.AllLayerTypesTestList)
                POST_WithValue_Inconsistent(l => l.target, layer.AsInlinedReference, false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_ValueAllocator_POST_Target_LayerViewReference()
        {
            Skip.UntilRelease.Validation("ARE-6190: Referenced LayerViews cause Internal Server Error");
            // While the ValueAllocator can hold a layer_view reference,
            // these are only allowed when posting as a layer_view, not a layer.
            foreach (IInjectableResource<ILayerView> layerView in Samples.AllLayerViewTypesTestList)
                POST_WithValue_Inconsistent(l => l.target, layerView.AsReference, false);
        }
        #endregion target
 
        #region group
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_ValueAllocator_POST_Group_Null()
        {
            POST_Attribute_Null(l => l.group);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_ValueAllocator_POST_Group_Reference_NullId()
        {
            //POST_Reference_NullId(l => l.group);
            IReference<ILayer> reference = new Reference<Layer>((string)null);
            POST_WithValue(l => l.group, reference, false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_ValueAllocator_POST_Group_Reference_EmptyStringId()
        {
            //POST_Reference_EmptyStringId(l => l.group);
            IReference<ILayer> reference = new Reference<Layer>("");
            POST_WithValue(l => l.group, reference, false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_ValueAllocator_POST_Group_Reference_NonExistantId()
        {
            //POST_Reference_NonExistantId(l => l.group);
            IReference<ILayer> reference = new Reference<Layer>(Samples.Valid_NonExistant_UUID);
            POST_WithValue(l => l.group, reference, false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_ValueAllocator_POST_Group_EveryType()
        {
            // Loop over each layer type, generate and test POST a testRegroup with it.
            foreach (IInjectableResource<ILayer> layer in Samples.AllSaveableLayerTypesTestList)
                POST_WithValue(l => l.group, layer.AsReference, true);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_ValueAllocator_POST_Group_Inlined()
        {
            // Demonstrate that posting Nested layers with inlined groups is disallowed.
            foreach (IInjectableResource<ILayer> layer in Samples.AllLayerTypesTestList)
                POST_WithValue_Inconsistent(l => l.group, layer.AsInlinedReference, false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_ValueAllocator_POST_Group_LayerViewReference()
        {
            Skip.UntilRelease.Validation("ARE-6190: Referenced LayerViews cause Internal Server Error");
            // While the ValueAllocator can hold a layer_view reference,
            // these are only allowed when posting as a layer_view, not a layer.
            foreach (IInjectableResource<ILayerView> layerView in Samples.AllLayerViewTypesTestList)
                POST_WithValue_Inconsistent(l => l.group, layerView.AsReference, false);
        }
        #endregion group
 
        #region allocation_perspectives
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_ValueAllocator_POST_AllocationPerspective_Null()
        {
            POST_Attribute_Null(l => l.allocation_perspectives);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_ValueAllocator_POST_AllocationPerspective_Empty()
        {
            POST_ListAttribute_Empty(l => l.allocation_perspectives);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_ValueAllocator_POST_AllocationPerspective_Duplicates()
        {
            POST_ListAttribute_Duplicates(l => l.allocation_perspectives,
                ValueAllocator.Perspective.LossNetOfAggregateTerms, false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_ValueAllocator_POST_AllocationPerspective_EveryPerspective()
        {
            POST_WithValue(l => l.allocation_perspectives, new[] { ValueAllocator.Perspective.LossNetOfAggregateTerms }, true);
            POST_WithValue(l => l.allocation_perspectives, new[] { ValueAllocator.Perspective.ReinstatementPremium }, true);
            POST_WithValue(l => l.allocation_perspectives, new[] { ValueAllocator.Perspective.ReinstatementBrokerage }, true);
            POST_WithValue(l => l.allocation_perspectives, new[] { ValueAllocator.Perspective.LossNetOfAggregateTerms, ValueAllocator.Perspective.ReinstatementPremium }, true);
            POST_WithValue(l => l.allocation_perspectives, new[] { ValueAllocator.Perspective.LossNetOfAggregateTerms, ValueAllocator.Perspective.ReinstatementBrokerage }, true);
            POST_WithValue(l => l.allocation_perspectives, new[] { ValueAllocator.Perspective.ReinstatementPremium, ValueAllocator.Perspective.ReinstatementBrokerage }, true);
            POST_WithValue(l => l.allocation_perspectives, new[] { ValueAllocator.Perspective.LossNetOfAggregateTerms,
                ValueAllocator.Perspective.ReinstatementPremium, ValueAllocator.Perspective.ReinstatementBrokerage }, true);
        }
        #endregion allocation_perspectives
 
        #region proportioned_perspective
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_ValueAllocator_POST_ProportionedPerspective_Null()
        {
            POST_Attribute_Null(l => l.proportioned_perspective);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_ValueAllocator_POST_ProportionedPerspective_EveryPerspective()
        {
            POST_WithValue(l => l.proportioned_perspective, ValueAllocator.Perspective.LossNetOfAggregateTerms, true);
            POST_WithValue(l => l.proportioned_perspective, ValueAllocator.Perspective.ReinstatementPremium, true);
            POST_WithValue(l => l.proportioned_perspective, ValueAllocator.Perspective.ReinstatementBrokerage, true);
        }
        #endregion proportioned_perspective
 
        #region allocation_ratio_basis
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_ValueAllocator_POST_AllocationRationBasis_Null()
        {
            POST_Attribute_Null(l => l.allocation_ratio_basis);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_ValueAllocator_POST_AllocationRatioBasis_PossibleValues()
        {
            POST_WithValue(l => l.allocation_ratio_basis, ValueAllocator.AllocationRatioBasis.PerEvent, true);
            POST_WithValue(l => l.allocation_ratio_basis, ValueAllocator.AllocationRatioBasis.PerTrial, true);
        }
        #endregion allocation_ratio_basis
        #endregion POST
 
        #region PUT
        #region source
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_ValueAllocator_PUT_Source()
        {
            PUT_WithValue(l => l.source, Samples.Layer_QuotaShare.AsReference, true);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_ValueAllocator_PUT_Source_Null()
        {
            PUT_Attribute_Null(l => l.source);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_ValueAllocator_PUT_Source_Reference_NullId()
        {
            PUT_Reference_NullId(l => l.source);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_ValueAllocator_PUT_Source_Reference_EmptyStringId()
        {
            PUT_Reference_EmptyStringId(l => l.source);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_ValueAllocator_PUT_Source_Reference_NonExistantId()
        {
            PUT_Reference_NonExistantId(l => l.source);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_ValueAllocator_PUT_Source_EveryType()
        {
            // Loop over each layer type, generate and test PUT a testResource with it.
            foreach (IInjectableResource<ILayer> layer in Samples.AllSaveableLayerTypesTestList)
                PUT_WithValue(l => l.source, layer.AsReference, true);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_ValueAllocator_PUT_Source_Inlined()
        {
            // Demonstrate that updating Nested layers with inlined sources is disallowed.
            foreach (IInjectableResource<ILayer> layer in Samples.AllLayerTypesTestList)
                PUT_WithValue(l => l.source, layer.AsInlinedReference, false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_ValueAllocator_PUT_Source_LayerViewReference()
        {
            Skip.UntilRelease.Validation("ARE-6190: Referenced LayerViews cause Internal Server Error");
            // While the ValueAllocator can hold a layer_view reference,
            // these are only allowed when updating as a layer_view, not a layer.
            foreach (IInjectableResource<ILayerView> layerView in Samples.AllLayerViewTypesTestList)
                PUT_WithValue(l => l.source, layerView.AsReference, false);
        }
        #endregion source
 
        #region target
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_ValueAllocator_PUT_Target()
        {
            PUT_WithValue(l => l.target, Samples.Layer_QuotaShare.AsReference, true);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_ValueAllocator_PUT_Target_Null()
        {
            PUT_Attribute_Null(l => l.target);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_ValueAllocator_PUT_Target_Reference_NullId()
        {
            PUT_Reference_NullId(l => l.target);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_ValueAllocator_PUT_Target_Reference_EmptyStringId()
        {
            PUT_Reference_EmptyStringId(l => l.target);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_ValueAllocator_PUT_Target_Reference_NonExistantId()
        {
            PUT_Reference_NonExistantId(l => l.target);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_ValueAllocator_PUT_Target_EveryType()
        {
            // Loop over each layer type, generate and test PUT a testRetarget with it.
            foreach (IInjectableResource<ILayer> layer in Samples.AllSaveableLayerTypesTestList)
                PUT_WithValue(l => l.target, layer.AsReference, true);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_ValueAllocator_PUT_Target_Inlined()
        {
            // Demonstrate that updating Nested layers with inlined targets is disallowed.
            foreach (IInjectableResource<ILayer> layer in Samples.AllLayerTypesTestList)
                PUT_WithValue(l => l.target, layer.AsInlinedReference, false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_ValueAllocator_PUT_Target_LayerViewReference()
        {
            Skip.UntilRelease.Validation("ARE-6190: Referenced LayerViews cause Internal Server Error");
            // While the ValueAllocator can hold a layer_view reference,
            // these are only allowed when updating as a layer_view, not a layer.
            foreach (IInjectableResource<ILayerView> layerView in Samples.AllLayerViewTypesTestList)
                PUT_WithValue(l => l.target, layerView.AsReference, false);
        }
        #endregion target
 
        #region group
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_ValueAllocator_PUT_Group()
        {
            PUT_WithValue(l => l.group, Samples.Layer_QuotaShare.AsReference, true);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_ValueAllocator_PUT_Group_Null()
        {
            PUT_Attribute_Null(l => l.group);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_ValueAllocator_PUT_Group_Reference_NullId()
        {
            PUT_Reference_NullId(l => l.group);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_ValueAllocator_PUT_Group_Reference_EmptyStringId()
        {
            PUT_Reference_EmptyStringId(l => l.group);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_ValueAllocator_PUT_Group_Reference_NonExistantId()
        {
            PUT_Reference_NonExistantId(l => l.group);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_ValueAllocator_PUT_Group_EveryType()
        {
            // Loop over each layer type, generate and test PUT a testRegroup with it.
            foreach (IInjectableResource<ILayer> layer in Samples.AllSaveableLayerTypesTestList)
                PUT_WithValue(l => l.group, layer.AsReference, true);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_ValueAllocator_PUT_Group_Inlined()
        {
            // Demonstrate that updating Nested layers with inlined groups is disallowed.
            foreach (IInjectableResource<ILayer> layer in Samples.AllLayerTypesTestList)
                PUT_WithValue(l => l.group, layer.AsInlinedReference, false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_ValueAllocator_PUT_Group_LayerViewReference()
        {
            Skip.UntilRelease.Validation("ARE-6190: Referenced LayerViews cause Internal Server Error");
            // While the ValueAllocator can hold a layer_view reference,
            // these are only allowed when updating as a layer_view, not a layer.
            foreach (IInjectableResource<ILayerView> layerView in Samples.AllLayerViewTypesTestList)
                PUT_WithValue(l => l.group, layerView.AsReference, false);
        }
        #endregion group
 
        #region allocation_perspectives
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_ValueAllocator_PUT_AllocationPerspective_Null()
        {
            PUT_Attribute_Null(l => l.allocation_perspectives);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_ValueAllocator_PUT_AllocationPerspective_Empty()
        {
            PUT_ListAttribute_Empty(l => l.allocation_perspectives);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_ValueAllocator_PUT_AllocationPerspective_Duplicates()
        {
            PUT_ListAttribute_Duplicates(l => l.allocation_perspectives,
                ValueAllocator.Perspective.LossNetOfAggregateTerms, false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_ValueAllocator_PUT_AllocationPerspective_EveryPerspective()
        {
            PUT_WithValue(l => l.allocation_perspectives, new[] { ValueAllocator.Perspective.LossNetOfAggregateTerms }, true);
            PUT_WithValue(l => l.allocation_perspectives, new[] { ValueAllocator.Perspective.ReinstatementPremium }, true);
            PUT_WithValue(l => l.allocation_perspectives, new[] { ValueAllocator.Perspective.ReinstatementBrokerage }, true);
            PUT_WithValue(l => l.allocation_perspectives, new[] { ValueAllocator.Perspective.LossNetOfAggregateTerms, ValueAllocator.Perspective.ReinstatementPremium }, true);
            PUT_WithValue(l => l.allocation_perspectives, new[] { ValueAllocator.Perspective.LossNetOfAggregateTerms, ValueAllocator.Perspective.ReinstatementBrokerage }, true);
            PUT_WithValue(l => l.allocation_perspectives, new[] { ValueAllocator.Perspective.ReinstatementPremium, ValueAllocator.Perspective.ReinstatementBrokerage }, true);
            PUT_WithValue(l => l.allocation_perspectives, new[] { ValueAllocator.Perspective.LossNetOfAggregateTerms,
                ValueAllocator.Perspective.ReinstatementPremium, ValueAllocator.Perspective.ReinstatementBrokerage }, true);
        }
        #endregion allocation_perspectives
 
        #region proportioned_perspective
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_ValueAllocator_PUT_ProportionedPerspective_Null()
        {
            PUT_Attribute_Null(l => l.proportioned_perspective);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_ValueAllocator_PUT_ProportionedPerspective_EveryPerspective()
        {
            PUT_WithValue(l => l.proportioned_perspective, ValueAllocator.Perspective.LossNetOfAggregateTerms, true);
            PUT_WithValue(l => l.proportioned_perspective, ValueAllocator.Perspective.ReinstatementPremium, true);
            PUT_WithValue(l => l.proportioned_perspective, ValueAllocator.Perspective.ReinstatementBrokerage, true);
        }
        #endregion proportioned_perspective
 
        #region allocation_ratio_basis
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_ValueAllocator_PUT_AllocationRationBasis_Null()
        {
            PUT_Attribute_Null(l => l.allocation_ratio_basis);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_ValueAllocator_PUT_AllocationRatioBasis_PossibleValues()
        {
            PUT_WithValue(l => l.allocation_ratio_basis, ValueAllocator.AllocationRatioBasis.PerEvent, true);
            PUT_WithValue(l => l.allocation_ratio_basis, ValueAllocator.AllocationRatioBasis.PerTrial, true);
        }
        #endregion allocation_ratio_basis
        #endregion PUT
    }
 
    [TestClass]
    public sealed class TestSuite_Layer_BackAllocatedLayer : TestSuite_Layer<BackAllocatedLayer>
    {
        #region Set Up and Configuration
        private const string TypeName = "BackAllocatedLayer";
        protected override IInjectableResource<BackAllocatedLayer> TestInjectableResource =>
            Samples.Layer_BackAllocatedLayer;
        #endregion Set Up and Configuration
 
        #region Test Helpers
        public static HashSet<Type> UnsupportedBackAllocatedLayerSinkTypes =>
            new HashSet<Type>(TestSuite_Layer_Base.PaymentPatternTypes);
 
        public static IEnumerable<IInjectableResource<ILayer>> ValidSinkLayerTypesTestList =>
            Samples.AllLayerTypesTestList.Where(i => !UnsupportedBackAllocatedLayerSinkTypes.Contains(i.UnderlyingType));
 
        public static IEnumerable<IInjectableResource<ILayer>> ForbiddenSinkLayerTypesTestList =>
            Samples.AllLayerTypesTestList.Where(i => UnsupportedBackAllocatedLayerSinkTypes.Contains(i.UnderlyingType));
        #endregion Test Helpers
 
        #region POST
        #region sink
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_BackAllocatedLayer_POST_Sink_Null()
        {
            POST_Attribute_Null(l => l.sink);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_BackAllocatedLayer_POST_Sink_Reference_NullId()
        {
            //POST_Reference_NullId(l => l.sink);
            IReference<ILayer> reference = new Reference<Layer>((string)null);
            POST_WithValue(l => l.sink, reference, false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_BackAllocatedLayer_POST_Sink_Reference_EmptyStringId()
        {
            //POST_Reference_EmptyStringId(l => l.sink);
            IReference<ILayer> reference = new Reference<Layer>("");
            POST_WithValue(l => l.sink, reference, false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_BackAllocatedLayer_POST_Sink_Reference_NonExistantId()
        {
            //POST_Reference_NonExistantId(l => l.sink);
            IReference<ILayer> reference = new Reference<Layer>(Samples.Valid_NonExistant_UUID);
            POST_WithValue(l => l.sink, reference, false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_BackAllocatedLayer_POST_Sink_ValidTypes()
        {
            // While the BackAllocatedLayer can hold an inlined layer definition,
            // these are only allowed when posting as a layer_view, not a layer.
            foreach (IInjectableResource<ILayer> layer in ValidSinkLayerTypesTestList)
            {
                // First, test having with this type of layer definition inlined
                IReference<ILayer> newSink = layer.AsInlinedReference;
                BackAllocatedLayer ofCurrentType = TestResource.Change(l => l.sink, newSink)
                    // We must also change the source_id to match something within the sink.
                    .Change(l => l.source_id, Reflection.PickBackAllocatedLayerSourceId(newSink));
                // Saving to "/layers/" will always fail, because inlining is not allowed
                GenericTest.POST_InvalidResource_Fails(ofCurrentType);
                // But posting as a layer_view should succeed.
                TestSuite_Layer_Base.TestLayerInLayerView(ofCurrentType, true);
 
                // If this layer type is saveable, test again using a saved layer reference of this type
                if (layer.UnderlyingType.IsAttributeDefinedFast<NotSaveableAttribute>())
                {
                    Console.WriteLine("Skipping sink layer reference test of un-saveable layer type " +
                        layer.UnderlyingType.NiceTypeName());
                    continue;
                }
 
                newSink = layer.AsReference;
                ofCurrentType = ofCurrentType.Change(l => l.sink, newSink)
                    .Change(l => l.source_id, Reflection.PickBackAllocatedLayerSourceId(newSink));
                // Test that the resource can be posted as a layer, and a layer_view
                POST_ThenDoAction(ofCurrentType, AdditionalValidResourceTests);
            }
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_BackAllocatedLayer_POST_Sink_InvalidTypes()
        {
            Skip.Indefinitely("ARE-7212: BackAllocating Payment Patterns cause Internal Server Errors");
            // While the BackAllocatedLayer can hold an inlined layer definition,
            // these are only allowed when posting as a layer_view, not a layer.
            foreach (IInjectableResource<ILayer> layer in ForbiddenSinkLayerTypesTestList)
            {
                // First, test having with this type of layer definition inlined
                IReference<ILayer> newSink = layer.AsInlinedReference;
                BackAllocatedLayer ofCurrentType = TestResource.Change(l => l.sink, newSink)
                    // We must also change the source_id to match something within the sink.
                    .Change(l => l.source_id, Reflection.PickBackAllocatedLayerSourceId(newSink));
 
                // Saving to "/layers/" will always fail, because inlining is not allowed
                GenericTest.POST_InvalidResource_Fails(ofCurrentType);
                // Posting as a layer_view should always fail if this type is not allowed.
                // BUG ARE-7212 Causes an Internal Server Error rather than a BadRequest
                TestSuite_Layer_Base.TestLayerInLayerView(ofCurrentType, false);
 
                // If this layer type is saveable, test again using a saved layer reference of this type
                if (layer.UnderlyingType.IsAttributeDefinedFast<NotSaveableAttribute>())
                {
                    Console.WriteLine("Skipping sink layer reference test of un-saveable layer type " +
                        layer.UnderlyingType.NiceTypeName());
                    continue;
                }
 
                newSink = layer.AsReference;
                ofCurrentType = ofCurrentType.Change(l => l.sink, newSink)
                    .Change(l => l.source_id, Reflection.PickBackAllocatedLayerSourceId(newSink));
                // BUG ARE-7212 - this is not validated on the API, so this POST is allowed
                GenericTest.POST_InvalidResource_Fails(ofCurrentType);
            }
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_BackAllocatedLayer_POST_Sink_LayerViewReference()
        {
            Skip.UntilRelease.Validation("ARE-6190: Referenced LayerViews cause Internal Server Error");
            // While the BackAllocatedLayer sink can hold a layer_view reference, these cannot be saved
            foreach (IInjectableResource<ILayerView> layerView in Samples.AllLayerViewTypesTestList)
                POST_WithValue_Inconsistent(l => l.sink, layerView.AsReference, false);
        }
        #endregion sink
 
        #region source_id
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_BackAllocatedLayer_POST_SourceId_LossSet()
        {
            POST_WithValue(a => a.source_id,
                // Try setting the source to a loss set id
                // which is known to be part of our sink layer definition
                Samples.Layer_CatXL.Unposted.loss_sets.First().ref_id, true);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_BackAllocatedLayer_POST_SourceId_Null()
        {
            POST_Attribute_Null(a => a.source_id);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_BackAllocatedLayer_POST_SourceId_Blank()
        {
            POST_StringAttribute_Empty(a => a.source_id);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_BackAllocatedLayer_POST_SourceId_Malformed()
        {
            POST_WithValue(a => a.source_id, "Not_A_UUID", false);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_BackAllocatedLayer_POST_SourceId_NonExistant()
        {
            // In invalid source id can be referenced when persisting this layer,
            // only upon submission for Analytics is it known that the id is invalid.
            POST_WithValue_Inconsistent(a => a.source_id,
                Samples.Valid_NonExistant_UUID, true);
        }
        #endregion source_id
        #endregion POST
 
        #region PUT
        #region sink
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_BackAllocatedLayer_PUT_Source()
        {
            PUT_WithValue(l => l.sink, Samples.Layer_QuotaShare.AsReference, true);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_BackAllocatedLayer_PUT_Sink_Null()
        {
            PUT_Attribute_Null(l => l.sink);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_BackAllocatedLayer_PUT_Sink_Reference_NullId()
        {
            PUT_Reference_NullId(l => l.sink);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_BackAllocatedLayer_PUT_Sink_Reference_EmptyStringId()
        {
            PUT_Reference_EmptyStringId(l => l.sink);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_BackAllocatedLayer_PUT_Sink_Reference_NonExistantId()
        {
            PUT_Reference_NonExistantId(l => l.sink);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_BackAllocatedLayer_PUT_Sink_ValidTypes()
        {
            // Used to restore back-allocated layers to a valid definition once we're done testing.
            IReference<ILayerSource> originalSink = TestResource.sink;
 
            // Loop over each layer type, generate and test using a reference
            foreach (IInjectableResource<ILayer> layer in ValidSinkLayerTypesTestList
                .Where(l => !l.UnderlyingType.IsAttributeDefinedFast<NotSaveableAttribute>()))
            {
                BackAllocatedLayer created = PUT_WithValue(l => l.sink, layer.AsReference, true);
                // Clean up: put the sink back to the original value (compatible with source_id)
                // So that we aren't abandoning saved resources on the test server that are invalid.
                created.Change(l => l.sink, originalSink).Put();
            }
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_BackAllocatedLayer_PUT_Sink_InvalidTypes()
        {
            // BUG ARE-7212 - this is not validated on the API, so this PUT is allowed
            Skip.Indefinitely("ARE-7212: BackAllocating Payment Patterns cause Internal Server Errors");
            // Loop over each layer type, and ensure that PUT references to invalid types are forbidden
            foreach (IInjectableResource<ILayer> layer in ForbiddenSinkLayerTypesTestList)
                PUT_WithValue(l => l.sink, layer.AsReference, false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_BackAllocatedLayer_PUT_Sink_Inlined()
        {
            // Demonstrate that updating Nested layers with inlined sources is disallowed.
            foreach (IInjectableResource<ILayer> layer in Samples.AllLayerTypesTestList)
                PUT_WithValue(l => l.sink, layer.AsInlinedReference, false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_BackAllocatedLayer_PUT_Sink_LayerViewReference()
        {
            Skip.UntilRelease.Validation("ARE-6190: Referenced LayerViews cause Internal Server Error");
            // While the BackAllocatedLayer can hold a layer_view reference, these cannot be saved
            foreach (IInjectableResource<ILayerView> layerView in Samples.AllLayerViewTypesTestList)
                PUT_WithValue(l => l.sink, layerView.AsReference, false);
        }
        #endregion sink
 
        #region source_id
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_BackAllocatedLayer_PUT_SourceId()
        {
            PUT_WithValue(a => a.source_id,
                Samples.Layer_CatXL.Unposted.loss_sets.First().ref_id, true);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_BackAllocatedLayer_PUT_SourceId_Null()
        {
            PUT_Attribute_Null(a => a.source_id);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_BackAllocatedLayer_PUT_SourceId_Blank()
        {
            PUT_StringAttribute_Empty(a => a.source_id);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_BackAllocatedLayer_PUT_SourceId_Malformed()
        {
            PUT_WithValue(a => a.source_id, "Not_A_UUID", false);
        }
        #endregion source_id
        #endregion PUT
    }
 
    [TestClass]
    public sealed class TestSuite_Layer_DelayedPayment : TestSuite_Layer_WithLossSets<DelayedPayment>
    {
        #region Set Up and Configuration
        private const string TypeName = "DelayedPayment";
        protected override IInjectableResource<DelayedPayment> TestInjectableResource =>
            Samples.Layer_DelayedPayment;
        #endregion Set Up and Configuration
 
        #region POST
        #region Test payments
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_DelayedPayment_POST_Payments()
        {
            POST_WithValue(l => l.payments, new List<DelayedPayment.Payment>
            {
                new DelayedPayment.Payment(0d, 0.5),
                new DelayedPayment.Payment(1d, 0.5)
            }, true);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_DelayedPayment_POST_Payments_Null()
        {
            POST_Attribute_Null(l => l.payments);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_DelayedPayment_POST_Payments_Empty()
        {
            POST_ListAttribute_Empty(l => l.payments);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_DelayedPayment_POST_Payments_Negative()
        {
            // Both negative sequence offsets and negative loads should be supported
            POST_WithValue(l => l.payments, new List<DelayedPayment.Payment>
            {
                new DelayedPayment.Payment(-2d, -5.0),
                new DelayedPayment.Payment(-1d, 0.5),
                new DelayedPayment.Payment(1d, -0.5)
            }, true);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_DelayedPayment_POST_Payments_OutOfOrder()
        {
            // DelayedPayments' sort order is NOT validated.
            POST_WithValue(l => l.payments, new List<DelayedPayment.Payment>
            {
                new DelayedPayment.Payment(1d, 0.1),
                new DelayedPayment.Payment(3d, 0.1),
                new DelayedPayment.Payment(2d, 0.1),
            }, true);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_DelayedPayment_POST_Payments_InvalidValues()
        {
            // Special case double values are not allowed
            POST_WithValue(l => l.payments, new List<DelayedPayment.Payment>
                { new DelayedPayment.Payment(Double.NaN, 0.1), }, false);
            POST_WithValue(l => l.payments, new List<DelayedPayment.Payment>
                { new DelayedPayment.Payment(Double.PositiveInfinity, 0.1), }, false);
            POST_WithValue(l => l.payments, new List<DelayedPayment.Payment>
                { new DelayedPayment.Payment(Double.NegativeInfinity, 0.1), }, false);
 
            POST_WithValue(l => l.payments, new List<DelayedPayment.Payment>
                { new DelayedPayment.Payment(0d, Double.NaN), }, false);
            POST_WithValue(l => l.payments, new List<DelayedPayment.Payment>
                { new DelayedPayment.Payment(0d, Double.PositiveInfinity), }, false);
            POST_WithValue(l => l.payments, new List<DelayedPayment.Payment>
                { new DelayedPayment.Payment(0d, Double.NegativeInfinity), }, false);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_DelayedPayment_POST_Payments_ValidSpecialValues()
        {
            // Test certain special values that are allowed and precision survives the round-trip
            POST_WithValue(l => l.payments, new List<DelayedPayment.Payment>
                { new DelayedPayment.Payment(Double.MaxValue, 0.1), }, true);
            POST_WithValue(l => l.payments, new List<DelayedPayment.Payment>
                { new DelayedPayment.Payment(Double.Epsilon, 0.1), }, true);
            POST_WithValue(l => l.payments, new List<DelayedPayment.Payment>
                { new DelayedPayment.Payment(Double.MinValue, 0.1), }, true);
            POST_WithValue(l => l.payments, new List<DelayedPayment.Payment>
                { new DelayedPayment.Payment(Math.PI, 0.1), }, true);
 
            POST_WithValue(l => l.payments, new List<DelayedPayment.Payment>
                { new DelayedPayment.Payment(0d, Double.MaxValue), }, true);
            POST_WithValue(l => l.payments, new List<DelayedPayment.Payment>
                { new DelayedPayment.Payment(0d, Double.Epsilon), }, true);
            POST_WithValue(l => l.payments, new List<DelayedPayment.Payment>
                { new DelayedPayment.Payment(0d, Double.MinValue), }, true);
            POST_WithValue(l => l.payments, new List<DelayedPayment.Payment>
                { new DelayedPayment.Payment(0d, Math.PI), }, true);
        }
        #endregion Test payments
        #endregion POST
 
        #region PUT
        #region Test payments
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_DelayedPayment_PUT_Payments()
        {
            PUT_WithValue(l => l.payments, new List<DelayedPayment.Payment>
            {
                new DelayedPayment.Payment(0d, 0.5),
                new DelayedPayment.Payment(1d, 0.5)
            }, true);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_DelayedPayment_PUT_Payments_Null()
        {
            PUT_Attribute_Null(l => l.payments);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_DelayedPayment_PUT_Payments_Empty()
        {
            PUT_ListAttribute_Empty(l => l.payments);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_DelayedPayment_PUT_Payments_Negative()
        {
            // Both negative sequence offsets and negative loads should be supported
            PUT_WithValue(l => l.payments, new List<DelayedPayment.Payment>
            {
                new DelayedPayment.Payment(-2d, -5.0),
                new DelayedPayment.Payment(-1d, 0.5),
                new DelayedPayment.Payment(1d, -0.5)
            }, true);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_DelayedPayment_PUT_Payments_OutOfOrder()
        {
            // DelayedPayments' sort order is NOT validated.
            PUT_WithValue(l => l.payments, new List<DelayedPayment.Payment>
            {
                new DelayedPayment.Payment(1d, 0.1),
                new DelayedPayment.Payment(3d, 0.1),
                new DelayedPayment.Payment(2d, 0.1),
            }, true);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_DelayedPayment_PUT_Payments_InvalidValues()
        {
            // Special case double values are not allowed
            PUT_WithValue(l => l.payments, new List<DelayedPayment.Payment>
                { new DelayedPayment.Payment(Double.NaN, 0.1), }, false);
            PUT_WithValue(l => l.payments, new List<DelayedPayment.Payment>
                { new DelayedPayment.Payment(Double.PositiveInfinity, 0.1), }, false);
            PUT_WithValue(l => l.payments, new List<DelayedPayment.Payment>
                { new DelayedPayment.Payment(Double.NegativeInfinity, 0.1), }, false);
 
            PUT_WithValue(l => l.payments, new List<DelayedPayment.Payment>
                { new DelayedPayment.Payment(0d, Double.NaN), }, false);
            PUT_WithValue(l => l.payments, new List<DelayedPayment.Payment>
                { new DelayedPayment.Payment(0d, Double.PositiveInfinity), }, false);
            PUT_WithValue(l => l.payments, new List<DelayedPayment.Payment>
                { new DelayedPayment.Payment(0d, Double.NegativeInfinity), }, false);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_DelayedPayment_PUT_Payments_ValidSpecialValues()
        {
            // Test certain special values that are allowed and precision survives the round-trip
            PUT_WithValue(l => l.payments, new List<DelayedPayment.Payment>
                { new DelayedPayment.Payment(Double.MaxValue, 0.1), }, true);
            PUT_WithValue(l => l.payments, new List<DelayedPayment.Payment>
                { new DelayedPayment.Payment(Double.Epsilon, 0.1), }, true);
            PUT_WithValue(l => l.payments, new List<DelayedPayment.Payment>
                { new DelayedPayment.Payment(Double.MinValue, 0.1), }, true);
            PUT_WithValue(l => l.payments, new List<DelayedPayment.Payment>
                { new DelayedPayment.Payment(Math.PI, 0.1), }, true);
 
            PUT_WithValue(l => l.payments, new List<DelayedPayment.Payment>
                { new DelayedPayment.Payment(0d, Double.MaxValue), }, true);
            PUT_WithValue(l => l.payments, new List<DelayedPayment.Payment>
                { new DelayedPayment.Payment(0d, Double.Epsilon), }, true);
            PUT_WithValue(l => l.payments, new List<DelayedPayment.Payment>
                { new DelayedPayment.Payment(0d, Double.MinValue), }, true);
            PUT_WithValue(l => l.payments, new List<DelayedPayment.Payment>
                { new DelayedPayment.Payment(0d, Math.PI), }, true);
        }
        #endregion Test payments
        #endregion PUT
    }
 
    [TestClass]
    public sealed class TestSuite_Layer_FixedDatePayment : TestSuite_Layer_WithLossSets<FixedDatePayment>
    {
        #region Set Up and Configuration
        private const string TypeName = "FixedDatePayment";
        protected override IInjectableResource<FixedDatePayment> TestInjectableResource =>
            Samples.Layer_FixedDatePayment;
        #endregion Set Up and Configuration
 
        #region POST
        #region Test payments
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_FixedDatePayment_POST_Payments()
        {
            POST_WithValue(l => l.payments, new List<double> { 0d, 0.5, 1d, 0.5 }, true);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_FixedDatePayment_POST_Payments_Null()
        {
            POST_Attribute_Null(l => l.payments);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_FixedDatePayment_POST_Payments_Empty()
        {
            POST_ListAttribute_Empty(l => l.payments);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_FixedDatePayment_POST_Payments_Negative()
        {
            // Negative payment fractions (loads) should be supported
            POST_WithValue(l => l.payments, new List<double> { -2d, -5.0, -1d, 0.5, 1d, -0.5 }, true);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_FixedDatePayment_POST_Payments_InvalidValues()
        {
            // Special case double values are not allowed
            POST_WithValue(l => l.payments, new List<double> { Double.NaN, 0.1 }, false);
            POST_WithValue(l => l.payments, new List<double> { Double.PositiveInfinity, 0.1 }, false);
            POST_WithValue(l => l.payments, new List<double> { Double.NegativeInfinity, 0.1 }, false);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_FixedDatePayment_POST_Payments_ValidSpecialValues()
        {
            // Test certain special values that are allowed and precision survives the round-trip
            POST_WithValue(l => l.payments, new List<double> { Double.MaxValue, 0.1 }, true);
            POST_WithValue(l => l.payments, new List<double> { Double.Epsilon, 0.1 }, true);
            POST_WithValue(l => l.payments, new List<double> { Double.MinValue, 0.1 }, true);
            POST_WithValue(l => l.payments, new List<double> { Math.PI, 0.1 }, true);
        }
        #endregion Test payments
 
        #region Test payment_dates
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_DelayedPayment_POST_PaymentDates()
        {
            POST_WithValue(l => l.payment_dates,
                Enumerable.Range(0, TestResource.payments.Count)
                    .Select(i => Samples.SimulationStartDate.AddYears(i + 1)).ToList(), true);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_DelayedPayment_POST_PaymentDates_Null()
        {
            POST_Attribute_Null(l => l.payment_dates);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_DelayedPayment_POST_PaymentDates_Empty()
        {
            POST_ListAttribute_Empty(l => l.payment_dates);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_DelayedPayment_POST_PaymentDates_OutOfOrder()
        {
            // PaymentDates should be sorted from soonest to latest.
            POST_WithValue(l => l.payment_dates,
                TestResource.payment_dates.Reverse<DateTime>().ToList(), false);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_DelayedPayment_POST_PaymentDates_InsufficientNumber()
        {
            POST_WithValue(l => l.payment_dates,
                Enumerable.Range(0, TestResource.payments.Count - 1)
                    .Select(i => Samples.SimulationStartDate.AddYears(i)).ToList(), false);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_DelayedPayment_POST_PaymentDates_ValidSpecialValues()
        {
            // Test certain special values that are allowed and precision survives the round-trip
            POST_WithValue(l => l.payment_dates, new[] { new DateTime(0L, DateTimeKind.Utc) }
                .Concat(TestResource.payment_dates).ToList(), true);
            POST_WithValue(l => l.payment_dates, TestResource.payment_dates.Concat(
                new[] { new DateTime(DateTime.MaxValue.Ticks, DateTimeKind.Utc) }).ToList(), true);
        }
        #endregion Test payment_dates
        #endregion POST
 
        #region PUT
        #region Test payments
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_FixedDatePayment_PUT_Payments()
        {
            PUT_WithValue(l => l.payments, new List<double> { 0d, 0.5, 1d, 0.5 }, true);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_FixedDatePayment_PUT_Payments_Null()
        {
            PUT_Attribute_Null(l => l.payments);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_FixedDatePayment_PUT_Payments_Empty()
        {
            PUT_ListAttribute_Empty(l => l.payments);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_FixedDatePayment_PUT_Payments_Negative()
        {
            // Negative payment fractions (loads) should be supported
            PUT_WithValue(l => l.payments, new List<double> { -2d, -5.0, -1d, 0.5, 1d, -0.5 }, true);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_FixedDatePayment_PUT_Payments_InvalidValues()
        {
            // Special case double values are not allowed
            PUT_WithValue(l => l.payments, new List<double> { Double.NaN, 0.1 }, false);
            PUT_WithValue(l => l.payments, new List<double> { Double.PositiveInfinity, 0.1 }, false);
            PUT_WithValue(l => l.payments, new List<double> { Double.NegativeInfinity, 0.1 }, false);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_FixedDatePayment_PUT_Payments_ValidSpecialValues()
        {
            // Test certain special values that are allowed and precision survives the round-trip
            PUT_WithValue(l => l.payments, new List<double> { Double.MaxValue, 0.1 }, true);
            PUT_WithValue(l => l.payments, new List<double> { Double.Epsilon, 0.1 }, true);
            PUT_WithValue(l => l.payments, new List<double> { Double.MinValue, 0.1 }, true);
            PUT_WithValue(l => l.payments, new List<double> { Math.PI, 0.1 }, true);
        }
        #endregion Test payments
 
        #region Test payment_dates
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_DelayedPayment_PUT_PaymentDates()
        {
            PUT_WithValue(l => l.payment_dates,
                Enumerable.Range(0, TestResource.payments.Count)
                    .Select(i => Samples.SimulationStartDate.AddYears(i + 1)).ToList(), true);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_DelayedPayment_PUT_PaymentDates_Null()
        {
            PUT_Attribute_Null(l => l.payment_dates);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_DelayedPayment_PUT_PaymentDates_Empty()
        {
            PUT_ListAttribute_Empty(l => l.payment_dates);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_DelayedPayment_PUT_PaymentDates_OutOfOrder()
        {
            // PaymentDates should be sorted from soonest to latest.
            PUT_WithValue(l => l.payment_dates,
                TestResource.payment_dates.Reverse<DateTime>().ToList(), false);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_DelayedPayment_PUT_PaymentDates_InsufficientNumber()
        {
            PUT_WithValue(l => l.payment_dates,
                Enumerable.Range(0, TestResource.payments.Count - 1)
                    .Select(i => Samples.SimulationStartDate.AddYears(i)).ToList(), false);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_Layer_DelayedPayment_PUT_PaymentDates_ValidSpecialValues()
        {
            // Test certain special values that are allowed and precision survives the round-trip
            PUT_WithValue(l => l.payment_dates, new[] { new DateTime(0L, DateTimeKind.Utc) }
                .Concat(TestResource.payment_dates).ToList(), true);
            PUT_WithValue(l => l.payment_dates, TestResource.payment_dates.Concat(
                new[] { new DateTime(DateTime.MaxValue.Ticks, DateTimeKind.Utc) }).ToList(), true);
        }
        #endregion Test payment_dates
        #endregion PUT
    }
    #endregion Layer Derived Types
 
    #region Abstract Base Layer Tests
    [TestClass]
    public abstract class TestSuite_Layer_QuotaShare_Base<T> : TestSuite_Layer_WithTerms<T> where T : QuotaShare
    {
        private const string TypeName = "QuotaShare";
 
        #region POST
        #region event_limit
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Layer_QuotaShare_POST_EventLimit_Null()
        {
            POST_Attribute_Null(l => l.event_limit);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Layer_QuotaShare_POST_EventLimit_HighPrecision()
        {
            POST_WithValue(l => l.event_limit, new MonetaryUnit(Math.PI / 1E12, "USD"), true);
        }
        #endregion event_limit
        #endregion POST
 
        #region PUT
        #region event_limit
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Layer_QuotaShare_PUT_EventLimit_Null()
        {
            PUT_Attribute_Null(l => l.event_limit);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Layer_QuotaShare_PUT_EventLimit_HighPrecision()
        {
            PUT_WithValue(l => l.event_limit, new MonetaryUnit(Math.PI / 1E12, "USD"), true);
        }
        #endregion event_limit
        #endregion PUT
    }
 
    [TestClass]
    public abstract class TestSuite_Layer_AggXL_Base<T> : TestSuite_Layer_XL<T> where T : AggXL
    {
        private const string TypeName = "Layer_AggXL_Base";
 
        #region POST
        #region aggregate_limit
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Layer_AggXL_POST_AggregateLimit_Null()
        {
            POST_Attribute_Null(l => l.aggregate_limit);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Layer_AggXL_POST_AggregateLimit_HighPrecision()
        {
            POST_WithValue(l => l.aggregate_limit, new MonetaryUnit(Math.PI / 1E12, "USD"), true);
        }
        #endregion aggregate_limit
 
        #region aggregate_attachment
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Layer_AggXL_POST_AggregateAttachment_Null()
        {
            POST_Attribute_Null(l => l.aggregate_attachment);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Layer_AggXL_POST_AggregateAttachment_HighPrecision()
        {
            POST_WithValue(l => l.aggregate_attachment, new MonetaryUnit(Math.PI / 1E12, "USD"), true);
        }
        #endregion aggregate_attachment
        #endregion POST
 
        #region PUT
        #region aggregate_limit
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Layer_AggXL_PUT_AggregateLimit_Null()
        {
            PUT_Attribute_Null(l => l.aggregate_limit);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Layer_AggXL_PUT_AggregateLimit_HighPrecision()
        {
            PUT_WithValue(l => l.aggregate_limit, new MonetaryUnit(Math.PI / 1E12, "USD"), true);
        }
        #endregion aggregate_limit
 
        #region aggregate_attachment
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Layer_AggXL_PUT_AggregateAttachment_Null()
        {
            PUT_Attribute_Null(l => l.aggregate_attachment);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Layer_AggXL_PUT_AggregateAttachment_HighPrecision()
        {
            PUT_WithValue(l => l.aggregate_attachment, new MonetaryUnit(Math.PI / 1E12, "USD"), true);
        }
        #endregion aggregate_attachment
        #endregion PUT
    }
 
    [TestClass]
    public abstract class TestSuite_Layer_XL<T> : TestSuite_Layer_WithTerms<T> where T : Layer_XL
    {
        private const string TypeName = "Layer_XL";
 
        #region POST
        #region limit
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Layer_XL_POST_Limit_Null()
        {
            POST_Attribute_Null(l => l.limit);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Layer_XL_POST_Limit_HighPrecision()
        {
            POST_WithValue(l => l.limit, new MonetaryUnit(Math.PI / 1E12, "USD"), true);
        }
        #endregion limit
 
        #region attachment
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Layer_XL_POST_Attachment_Null()
        {
            POST_Attribute_Null(l => l.attachment);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Layer_XL_POST_Attachment_HighPrecision()
        {
            POST_WithValue(l => l.attachment, new MonetaryUnit(Math.PI / 1E12, "USD"), true);
        }
        #endregion attachment
 
        #region franchise
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Layer_XL_POST_Franchise_Null()
        {
            POST_Attribute_Null(l => l.franchise);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Layer_XL_POST_Franchise_HighPrecision()
        {
            POST_WithValue(l => l.franchise, new MonetaryUnit(Math.PI / 1E12, "USD"), true);
        }
        #endregion franchise
        #endregion POST
 
        #region PUT
        #region limit
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Layer_XL_PUT_Limit_Null()
        {
            PUT_Attribute_Null(l => l.limit);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Layer_XL_PUT_Limit_HighPrecision()
        {
            PUT_WithValue(l => l.limit, new MonetaryUnit(Math.PI / 1E12, "USD"), true);
        }
        #endregion limit
 
        #region attachment
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Layer_XL_PUT_Attachment_Null()
        {
            PUT_Attribute_Null(l => l.attachment);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Layer_XL_PUT_Attachment_HighPrecision()
        {
            PUT_WithValue(l => l.attachment, new MonetaryUnit(Math.PI / 1E12, "USD"), true);
        }
        #endregion attachment
 
        #region franchise
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Layer_XL_PUT_Franchise_Null()
        {
            PUT_Attribute_Null(l => l.franchise);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Layer_XL_PUT_Franchise_HighPrecision()
        {
            PUT_WithValue(l => l.franchise, new MonetaryUnit(Math.PI / 1E12, "USD"), true);
        }
        #endregion franchise
        #endregion PUT
    }
 
    [TestClass]
    public abstract class TestSuite_Layer_WithTerms<T> : TestSuite_Layer_WithLossSets<T> where T : Layer_WithTerms
    {
        private const string TypeName = "Layer_WithTerms";
 
        #region POST
        #region participation
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Layer_POST_Participation_MaxValue()
        {
            POST_WithValue(l => l.participation, Double.MaxValue, true);
        }
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Layer_POST_Participation_MinValue()
        {
            POST_WithValue(l => l.participation, Double.MinValue, true);
        }
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Layer_POST_Participation_NaN()
        {
            POST_WithValue(l => l.participation, Double.NaN, false);
        }
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Layer_POST_Participation_Infinity()
        {
            POST_WithValue(l => l.participation, Double.PositiveInfinity, false);
        }
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Layer_POST_Participation_NegativeInfinity()
        {
            POST_WithValue(l => l.participation, Double.NegativeInfinity, false);
        }
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Layer_POST_Participation_HighPrecision()
        {
            POST_WithValue(l => l.participation, Math.PI / 1E12, true);
        }
        #endregion participation
 
        #region inception_date and expiry_date
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Layer_POST_Expiry_Null()
        {
            POST_WithValue(l => l.expiry_date, null, true);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Layer_POST_Inception_Null()
        {
            POST_WithValue(l => l.inception_date, null, true);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Layer_POST_InceptionExpiryDate_MinValue()
        {
            DateTime minUtcDateTime = new DateTime(0L, DateTimeKind.Utc);
            // Test them together so we don't violate inception <= expiry
            T tempTestResource = TestResource
                .Change(r => r.inception_date, minUtcDateTime)
                .Change(r => r.expiry_date, minUtcDateTime);
            POST_ThenDoAction(tempTestResource, AdditionalValidResourceTests);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Layer_POST_InceptionExpiryDate_MaxValue()
        {
            DateTime maxUtcDateTime = new DateTime(DateTime.MaxValue.Ticks, DateTimeKind.Utc);
            // Test them together so we don't violate inception <= expiry
            T tempTestResource = TestResource
                .Change(r => r.inception_date, maxUtcDateTime)
                .Change(r => r.expiry_date, maxUtcDateTime);
            POST_ThenDoAction(tempTestResource, AdditionalValidResourceTests);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Layer_POST_ExpiryDate_LessThanInception()
        {
            Assert.IsNotNull(TestResource.inception_date,
                "Test cannot proceed unless the inception date is set on the test resource.");
            POST_WithValue(l => l.expiry_date,
                TestResource.inception_date.Value.Subtract(new TimeSpan(0, 0, 0, 1)), false);
        }
        #endregion inception_date and expiry_date
 
        #region premium
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Layer_POST_Premium_Null()
        {
            POST_Attribute_Null(l => l.premium);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Layer_POST_Premium_HighPrecision()
        {
            POST_WithValue(l => l.premium,
                new MonetaryUnit(Math.PI / 1E12, "USD"), true);
        }
        #endregion premium
 
        #region fees
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Layer_POST_Fees_Null()
        {
            POST_Attribute_Null(l => l.fees);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Layer_POST_Fees_Empty()
        {
            POST_WithValue(l => l.fees, new List<Fee>(), true);
        }
 
        private void Test_Layer_POST_Fee(Fee fee)
        {
            POST_WithValue(l => l.fees, new List<Fee> { fee }, true);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Layer_POST_EachFee()
        {
            foreach (Fee fee in Samples.Fees.ListOfAllFeeTypes)
                Test_Layer_POST_Fee(fee);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Layer_POST_Fee_BadLossesReference()
        {
            POST_WithValue(l => l.fees, new List<Fee>
            {
                new ProfitCommission
                {
                    name = "MyFee",
                    payout_date = TestResource.inception_date,
                    rate = 0.5,
                    losses = new List<FeeReference> { FeeReference.CreateFromPremiumOrLossName("X") },
                }
            }, false);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Layer_POST_Fee_Good_Brokerage_Reference()
        {
            POST_WithValue(l => l.fees, new List<Fee>
            {
                new ProfitCommission()
                {
                    name = "MyFee",
                    payout_date = TestResource.inception_date,
                    rate = 0.5,
                    losses = new List<FeeReference>
                    {
                        FeeReference.CreateFromPremiumOrLossName("ReinstatementBrokerage")
                    },
                    premiums = new List<FeeReference>
                    {
                        FeeReference.CreateFromPremiumOrLossName("ReinstatementPremium")
                    },
                },
            }, true);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Layer_POST_Fee_Bad_Brokerage_Reference()
        {
            POST_WithValue(l => l.fees, new List<Fee>
            {
                new ProfitCommission()
                {
                    name = "MyFee",
                    payout_date = TestResource.inception_date,
                    rate = 0.5,
                    premiums = new List<FeeReference>
                    {
                        FeeReference.CreateFromPremiumOrLossName("ReinstatementBrokerage")
                    },
                },
            }, false);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Layer_POST_Fee_BadPremiumReference()
        {
            POST_WithValue(l => l.fees, new List<Fee>
            {
                new ProportionalExpense
                {
                    name = "MyFee",
                    payout_date = TestResource.inception_date,
                    rate = 0.5,
                    premiums = new List<FeeReference> { FeeReference.CreateFromPremiumOrLossName("X") },
                },
            }, false);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Layer_POST_Fee_BadFeeReference()
        {
            POST_WithValue(l => l.fees, new List<Fee>
            {
                new ProfitCommission
                {
                    name = "MyFee",
                    payout_date = TestResource.inception_date,
                    rate = 0.5,
                    fees = new List<FeeReference> { FeeReference.CreateFromFeeName("X") }
                }
            }, false);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Layer_POST_Fee_SelfFeeReference()
        {
            POST_WithValue(l => l.fees, new List<Fee>
            {
                new ProfitCommission
                {
                    name = "MyFee",
                    payout_date = TestResource.inception_date,
                    rate = 0.5,
                    fees = new List<FeeReference> { FeeReference.CreateFromFeeName("MyFee") }
                }
            }, false);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Layer_POST_Fee_CircularFeeReference()
        {
            List<Fee> fees = new List<Fee>
            {
                new ProfitCommission
                {
                    name = "MyFeeA",
                    payout_date = TestResource.inception_date,
                    rate = 0.5
                },
                new ProfitCommission
                {
                    name = "MyFee1",
                    payout_date = TestResource.inception_date,
                    rate = 0.5,
                    fees = new List<FeeReference> { FeeReference.CreateFromFeeName("MyFee3") }
                },
                new ProfitCommission
                {
                    name = "MyFeeB",
                    payout_date = TestResource.inception_date,
                    rate = 0.5,
                    fees = new List<FeeReference> { FeeReference.CreateFromFeeName("MyFeeA") }
                },
                new ProfitCommission
                {
                    name = "MyFee2",
                    payout_date = TestResource.inception_date,
                    rate = 0.5,
                    fees = new List<FeeReference> { FeeReference.CreateFromFeeName("MyFee1") }
                },
                new ProfitCommission
                {
                    name = "MyFeeC",
                    payout_date = TestResource.inception_date,
                    rate = 0.5,
                    fees = new List<FeeReference> { FeeReference.CreateFromFeeName("MyFeeB") }
                },
                new ProfitCommission
                {
                    name = "MyFee3",
                    payout_date = TestResource.inception_date,
                    rate = 0.5,
                    fees = new List<FeeReference>
                    {
                        FeeReference.CreateFromFeeName("MyFee2"),
                        FeeReference.CreateFromFeeName("MyFeeC"),
                    }
                },
                new ProfitCommission
                {
                    name = "MyFee4",
                    payout_date = TestResource.inception_date,
                    rate = 0.5,
                    fees = new List<FeeReference> { FeeReference.CreateFromFeeName("MyFee3") }
                }
            };
 
            POST_WithValue(l => l.fees, fees, false);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Layer_POST_Fees_Many()
        {
            POST_WithValue(l => l.fees, Samples.Fees.ListWithNestedFeeReference, true);
        }
        #endregion fees
        #endregion POST
 
        #region PUT
        #region participation
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Layer_PUT_Participation()
        {
            PUT_WithValue(l => l.participation, 0.56789, true);
        }
        #endregion participation
 
        #region inception_date and expiry_date
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Layer_PUT_Expiry_Null()
        {
            PUT_WithValue(l => l.expiry_date, null, true);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Layer_PUT_Inception_Null()
        {
            PUT_WithValue(l => l.inception_date, null, true);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Layer_PUT_InceptionDate()
        {
            PUT_WithValue(l => l.inception_date,
                TestResource.inception_date.Value.Subtract(new TimeSpan(0, 0, 0, 1)), true);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Layer_PUT_ExpiryDate()
        {
            PUT_WithValue(l => l.expiry_date,
                TestResource.expiry_date.Value.Add(new TimeSpan(0, 0, 0, 1)), true);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Layer_PUT_InceptionExpiryDate_MinValue()
        {
            DateTime minUtcDateTime = new DateTime(0L, DateTimeKind.Utc);
            // Test them together so we don't violate inception <= expiry
            PUT_WithChanges_Succeeds(posted => posted
                .Change(r => r.inception_date, minUtcDateTime)
                .Change(r => r.expiry_date, minUtcDateTime));
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Layer_PUT_InceptionExpiryDate_MaxValue()
        {
            DateTime maxUtcDateTime = new DateTime(DateTime.MaxValue.Ticks, DateTimeKind.Utc);
            // Test them together so we don't violate inception <= expiry
            PUT_WithChanges_Succeeds(posted => posted
                .Change(r => r.inception_date, maxUtcDateTime)
                .Change(r => r.expiry_date, maxUtcDateTime));
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Layer_PUT_ExpiryDate_LessThanInception()
        {
            Assert.IsNotNull(TestResource.inception_date,
                "Test cannot proceed unless the inception date is set on the test resource.");
            PUT_WithValue(l => l.expiry_date,
                TestResource.inception_date.Value.Subtract(new TimeSpan(0, 0, 0, 1)), false);
        }
        #endregion inception_date and expiry_date
 
        #region premium
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Layer_PUT_Premium_Null()
        {
            PUT_Attribute_Null(l => l.premium);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Layer_PUT_Premium_HighPrecision()
        {
            PUT_WithValue(l => l.premium,
                new MonetaryUnit(Math.PI / 1E12, "USD"), true);
        }
        #endregion premium
 
        // TODO: There are no tests for modifying fees
        #endregion PUT
    }
 
    [TestClass]
    public abstract class TestSuite_Layer_Unsaveable<T> : TestSuite_Layer_WithLossSets<T> where T : Layer_WithLossSets
    {
        private const string TypeName = "Layer_Unsaveable";
 
        [TestMethod, TestCategory(TypeName)]
        public sealed override void Test_Layer_Saveable()
        {
            Assert.IsTrue(typeof(T).IsAttributeDefinedFast<NotSaveableAttribute>(),
                $"The {typeof(T).NiceTypeName()} layer type is being tested as an un-saveable " +
                $"layer, but it does not carry the {nameof(NotSaveableAttribute)}.");
        }
 
        // Override any POST tests to *only* test these Layers as inlined LayerViews.
        // since they cannot be saved on their own.
        #region POST
        [TestMethod, TestCategory(TypeName)]
        public override void Test_Resource_POST_Valid()
        {
            // Only in this base test - confirm that a layer with this type cannot be posted
            GenericTest.POST_InvalidResource_Fails(TestResource);
            // Now test that it can be posted as part of a layer_view
            TestSuite_Layer_Base.TestLayerInLayerView(TestResource, true);
        }
 
        public override void POST_WithValue<TProperty>(
            Expression<Func<T, TProperty>> PropertyExpression,
            TProperty newValue, bool shouldSucceed)
        {
            TestSuite_Layer_Base.TestLayerInLayerView(
                TestResource.Change(PropertyExpression, newValue), shouldSucceed);
        }
        #endregion POST
 
        // Can't perform a GET/PUT/POST on layers that can't be saved.
        // In this case, we simply need to make sure the tests don't exist (aren't inherited)
        // for layers that can't be saved.
        // We do this by overriding base test methods and omitting the [TestMethod] attribute
        // This is simpler than deriving from BaseStoredResourceTestSuite and re-implementing
        //   the BaseMutableResourceTestSuite tests elsewhere. Again, multiple inheritance is missed.
        #region Hidden Tests
        public sealed override void Test_Resource_GET_Existing() { }
        public sealed override void Test_Resource_GET_Existing_ResolveReferences() { }
        public sealed override void Test_Resource_Search() { }
        public sealed override void Test_Resource_GET_FromBatch() { }
 
        public sealed override void Test_Resource_POST_CreatedAndModified() { }
        public sealed override void Test_Resource_POST_Id_Ignored() { }
        public sealed override void Test_Resource_POST_ExistingId() { }
 
        public sealed override void Test_Resource_PUT_Description() { }
        public sealed override void Test_Resource_PUT_Description_Blank() { }
        public sealed override void Test_Resource_PUT_Description_Null() { }
        public sealed override void Test_Resource_PUT_Metadata_Empty() { }
        public sealed override void Test_Resource_PUT_Metadata_MixedTypes() { }
        public sealed override void Test_Resource_PUT_Metadata_Null() { }
        public sealed override void Test_Resource_PUT_Metadata_InvalidValues() { }
        public sealed override void Test_Layer_WithLossSets_PUT_LossSet_NotFinalized() { }
        public sealed override void Test_Layer_WithLossSets_PUT_LossSets() { }
        public sealed override void Test_Layer_WithLossSets_PUT_LossSets_Duplicates() { }
        public sealed override void Test_Layer_WithLossSets_PUT_LossSets_Empty() { }
        public sealed override void Test_Layer_WithLossSets_PUT_LossSets_Invalid() { }
        public sealed override void Test_Layer_WithLossSets_PUT_Policy() { }
        public sealed override void Test_Layer_WithLossSets_PUT_Policy_TransformAll() { }
        public sealed override void Test_Layer_WithLossSets_PUT_Policy_ForwardAll() { }
        public sealed override void Test_Layer_WithLossSets_PUT_Policy_Empty() { }
        public sealed override void Test_Layer_WithLossSets_PUT_Policy_Duplicates() { }
        public sealed override void Test_Resource_PUT_CreatedAndModified() { }
        public sealed override void Test_Resource_PUT_NoChanges() { }
 
        public sealed override void Test_Resource_DELETE() { }
        #endregion Hidden Tests
    }
 
    [TestClass]
    public abstract class TestSuite_Layer_WithLossSets<T> : TestSuite_Layer<T> where T : Layer_WithLossSets
    {
        private const string TypeName = "Layer_WithLossSets";
 
        #region POST
        #region loss_sets
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Layer_WithLossSets_POST_LossSets_Null()
        {
            POST_Attribute_Null(l => l.loss_sets);
        }
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Layer_WithLossSets_POST_LossSets_Empty()
        {
            POST_ListAttribute_Empty(l => l.loss_sets);
        }
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Layer_WithLossSets_POST_LossSets_Duplicates()
        {
            POST_ListAttribute_Duplicates(l => l.loss_sets,
                Samples.LossSet_ELTLossSet.AsReference, false);
        }
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Layer_WithLossSets_POST_LossSets_Invalid()
        {
            POST_ReferenceList_NonExistantId(l => l.loss_sets);
        }
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Layer_WithLossSets_POST_LossSet_NotFinalized()
        {
            if (EnvironmentSettings.RUN_OFFLINE)
                Assert.Inconclusive("RUN_OFFLINE = true");
            // We expect an error when trying to attach a LossSet that has not had data uploaded
            // against it to a layer.
            LossSet notFinalized = Samples.LossSet_ELTLossSet.Unposted;
            // Post the loss set but not with data.
            notFinalized.Post();
            // Try to reference the loss set and demonstrate the error
            GenericTest.POST_InvalidResource_Fails(TestResource.Change(l => l.loss_sets,
                new List<IReference<LossSet>> { notFinalized.ToReference() }));
        }
        #endregion loss_sets
 
        #region policy
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Layer_WithLossSets_POST_Policy_Null()
        {
            POST_Attribute_Null(l => l.policy);
        }
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Layer_WithLossSets_POST_Policy_TransformAll()
        {
            POST_WithValue(l => l.policy, Samples.TransformAllPolicy, true);
        }
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Layer_WithLossSets_POST_Policy_ForwardAll()
        {
            POST_WithValue(l => l.policy, Samples.ForwardAllPolicy, true);
        }
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Layer_WithLossSets_POST_Policy_Empty()
        {
            POST_WithValue(l => l.policy, new Policy(), true);
        }
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Layer_WithLossSets_POST_Policy_Duplicates()
        {
            Policy withDuplicates = new Policy();
            withDuplicates.forward_records.Add(RecordType.Loss);
            withDuplicates.transform_records.Add(RecordType.Loss);
            POST_WithValue(l => l.policy, withDuplicates, false);
        }
        #endregion policy
        #endregion POST
 
        #region PUT
        #region loss_sets
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Layer_WithLossSets_PUT_LossSets()
        {
            PUT_WithValue(l => l.loss_sets, new List<IReference<LossSet>>
            {
                Samples.LossSet_YELTLossSetWithReinstatements.AsReference,
            }, true);
        }
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Layer_WithLossSets_PUT_LossSets_Empty()
        {
            PUT_ListAttribute_Empty(l => l.loss_sets);
        }
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Layer_WithLossSets_PUT_LossSets_Duplicates()
        {
            PUT_ListAttribute_Duplicates(l => l.loss_sets,
                Samples.LossSet_ELTLossSet.AsReference, false);
        }
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Layer_WithLossSets_PUT_LossSets_Invalid()
        {
            PUT_ReferenceList_NonExistantId(l => l.loss_sets);
        }
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Layer_WithLossSets_PUT_LossSet_NotFinalized()
        {
            if (EnvironmentSettings.RUN_OFFLINE)
                Assert.Inconclusive("RUN_OFFLINE = true");
            // We expect an error when trying to attach a LossSet that has not had data uploaded
            // against it to a layer.
            GenericTest.POST_ThenDoAction(Samples.LossSet_ELTLossSet.Unposted, notFinalized =>
            {
                PUT_WithValue(l => l.loss_sets,
                    new List<IReference<LossSet>> { notFinalized.ToReference() }, false);
            });
        }
        #endregion loss_sets
 
        #region policy
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Layer_WithLossSets_PUT_Policy()
        {
            PUT_WithValue(l => l.policy, Samples.Policy, true);
        }
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Layer_WithLossSets_PUT_Policy_TransformAll()
        {
            PUT_WithValue(l => l.policy, Samples.TransformAllPolicy, true);
        }
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Layer_WithLossSets_PUT_Policy_ForwardAll()
        {
            PUT_WithValue(l => l.policy, Samples.ForwardAllPolicy, true);
        }
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Layer_WithLossSets_PUT_Policy_Empty()
        {
            PUT_WithValue(l => l.policy, new Policy(), true);
        }
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Layer_WithLossSets_PUT_Policy_Duplicates()
        {
            Policy withDuplicates = new Policy();
            withDuplicates.forward_records.Add(RecordType.Loss);
            withDuplicates.transform_records.Add(RecordType.Loss);
            PUT_WithValue(l => l.policy, withDuplicates, false);
        }
        #endregion policy
        #endregion PUT
    }
 
    [TestClass]
    public abstract class TestSuite_Layer<T> : BaseMutableResourceTestSuite<T> where T : Layer
    {
        private const string TypeName = "Layer";
 
        public override void AdditionalValidResourceTests(T posted) =>
            TestSuite_Layer_Base.TestLayerInLayerView(posted, true);
 
        #region POST
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Layer_Saveable()
        {
            Assert.IsFalse(typeof(T).IsAttributeDefinedFast<NotSaveableAttribute>(),
                $"The {typeof(T).NiceTypeName()} layer type is being tested as a saveable " +
                $"layer, but it carries the {nameof(NotSaveableAttribute)}.");
        }
        #endregion POST
 
        #region BaseMutableResourceTestSuite Overrides
        #region GET
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Resource_GET_As_Inlined()
        {
            // Test getting an existing layer of this type inlined in a layer_view
            GenericTest.GET_ExistingResource_Succeeds(
                LayerViews.Create(TestResource, Samples.AnalysisProfile.Posted).Post());
        }
 
        [TestMethod, TestCategory(TypeName)]
        public override void Test_Resource_GET_AllPropertiesRecognized()
        {
            if (!typeof(T).IsAttributeDefinedFast<NotSaveableAttribute>())
                base.Test_Resource_GET_AllPropertiesRecognized();
            // Test that all properties are recognized in layer_view layer
            GenericTest.GET_AllPropertiesRecognized(
                LayerViews.Create(TestResource, Samples.AnalysisProfile.Posted).Post());
        }
        #endregion GET
 
        #region POST
        #region Helper Methods
        public override void POST_WithValue<TProperty>(
            Expression<Func<T, TProperty>> PropertyExpression,
            TProperty newValue, bool shouldSucceed)
        {
            base.POST_WithValue(PropertyExpression, newValue, shouldSucceed);
            // If the post should fail, we want to also verify that it fails when inlined in a
            // layer_view either. (AdditionalValidResourceTests already handles the success case.)
            if (!shouldSucceed)
                TestSuite_Layer_Base.TestLayerInLayerView(
                    TestResource.Change(PropertyExpression, newValue), false);
        }
 
        public virtual void POST_WithValue_Inconsistent<TProperty>(
            Expression<Func<T, TProperty>> PropertyExpression,
            TProperty newValue, bool layerPostSucceeeds)
        {
            // Similar to base.POST_WithValue, but skip AdditionalValidResourceTests,
            // since in this inconsistent case, we do not expect the layer_view to succeed
            T modifiedResource = TestResource.Change(PropertyExpression, newValue);
            if (layerPostSucceeeds)
                GenericTest.POST_ValidResource(modifiedResource);
            else
                GenericTest.POST_InvalidResource_Fails(modifiedResource);
            // Now test that a layer_view with this definition has the opposite outcome.
            TestSuite_Layer_Base.TestLayerInLayerView(modifiedResource, !layerPostSucceeeds);
        }
        #endregion Helper Methods
 
        [TestMethod, TestCategory(TypeName)]
        public override void Test_Resource_POST_FieldsIdOnly()
        {
            if (typeof(T).IsAttributeDefinedFast<NotSaveableAttribute>())
                GenericTest.POST_InvalidResource_Fails(TestResource);
            else
                base.Test_Resource_POST_FieldsIdOnly();
        }
        #endregion POST
 
        [TestMethod, TestCategory(TypeName)]
        public override void Test_Resource_ShallowCopy()
        {
            if (!typeof(T).IsAttributeDefinedFast<NotSaveableAttribute>())
                base.Test_Resource_ShallowCopy();
            // Test the resource inlined as part of a layer_view definition
            TestCopyHelper(Samples.GetInjectableLayerView(TestResource).Unposted,
                r => r.ShallowCopy());
        }
 
        [TestMethod, TestCategory(TypeName)]
        public override void Test_Resource_DeepCopy()
        {
            if (!typeof(T).IsAttributeDefinedFast<NotSaveableAttribute>())
                base.Test_Resource_DeepCopy();
            // Test the resource inlined as part of a layer_view definition
            TestCopyHelper(Samples.GetInjectableLayerView(TestResource).Unposted,
                r => r.DeepCopy());
        }
        #endregion BaseMutableResourceTestSuite Overrides
    }
    #endregion Abstract Base Layer Tests
}