Test_LossSet.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.Linq;
 
using AnalyzeRe;
using AnalyzeRe.APITypes;
using AnalyzeRe.Distributions;
using AnalyzeRe.LargeDataUpload;
using AnalyzeRe.Layers;
using AnalyzeRe.LossSets;
using AnalyzeRe.Metrics;
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_LossSet_Base : BaseAbstractStoredResourceTestSuite<LossSet>
    {
        protected override IResourceCollection<LossSet> collection_source => API.LossSets;
        
        public static void Test_LossSet_Simulatable<T>(T posted) where T : LossSet
        {
            Console.WriteLine("Verifying that we can safely POST and simulate a LayerView " +
                $"containing a reference to this {posted.GetType().NiceTypeName()}");
            // Ensure the loss set processed successfully
            if (posted is ILossSet_WithData asWithData)
                posted = (T)asWithData.PollUntilReady();
            // Post a new simple layer_view that includes this loss set
            ILayerView<ILayer_WithLossSets> layerView = Samples.LayerView_QuotaShare.Unposted;
            layerView.layer.loss_sets.Add(posted.ToReference());
            layerView = layerView.Post();
            // Assert that the layer_view can be simulated
            TestSuite_APIResourceView.TestMetricsRetrievable(layerView);
        }
    }
 
    #region ELTLossSet Derived Types Test Classes
    [TestClass]
    public sealed class TestSuite_LossSet_ELTLossSet : TestSuite_ELTLossSet<ELTLossSet>
    {
        #region Set Up and Configuration
        private const string TypeName = "ELTLossSet";
        protected override IInjectableResource<ELTLossSet> TestInjectableResource =>
            Samples.LossSet_ELTLossSet;
 
        protected override string POSTData => Samples.CSV.Loss_Set_1_Data;
        #endregion Set Up and Configuration
    }
 
    [TestClass]
    [Obsolete("This tests a now obsolete class for backwards compatibility purposes.")]
    public sealed class TestSuite_LossSet_PortfolioLossSet : TestSuite_ELTLossSet<PortfolioLossSet>
    {
        #region Set Up and Configuration
        private const string TypeName = "PortfolioLossSet";
        protected override IInjectableResource<PortfolioLossSet> TestInjectableResource =>
            Samples.LossSet_PortfolioLossSet;
 
        protected override string POSTData => Samples.CSV.Loss_Set_1_Data;
        #endregion Set Up and Configuration
 
        #region POST
        #region perspective
        [TestMethod, TestCategory(TypeName)]
        public void Test_LossSet_POST_Perspective_TooLong()
        {
            POST_WithValue(l => l.perspective, "ABC", false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_LossSet_POST_Perspective_TooShort()
        {
            POST_WithValue(l => l.perspective, "A", false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_LossSet_POST_Perspective_Null()
        {
            POST_Attribute_Null(l => l.perspective);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_LossSet_POST_Perspective_Blank()
        {
            POST_StringAttribute_Empty(l => l.perspective);
        }
        #endregion perspective
 
        #region analysis
        [TestMethod, TestCategory(TypeName)]
        public void Test_LossSet_POST_Analysis_Null()
        {
            POST_Attribute_Null(l => l.analysis);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_LossSet_POST_Analysis_Reference_NullId()
        {
            POST_Reference_NullId(l => l.analysis);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_LossSet_POST_Analysis_Reference_EmptyStringId()
        {
            POST_Reference_EmptyStringId(l => l.analysis);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_LossSet_POST_Analysis_Reference_NonExistantId()
        {
            POST_Reference_NonExistantId(l => l.analysis);
        }
        #endregion analysis
        #endregion POST
 
        #region PUT
        #region perspective
        [TestMethod, TestCategory(TypeName)]
        public void Test_LossSet_PUT_Perspective()
        {
            PUT_WithValue(l => l.perspective, "ZZ", true);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_LossSet_PUT_Perspective_TooLong()
        {
            PUT_WithValue(l => l.perspective, "ABC", false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_LossSet_PUT_Perspective_TooShort()
        {
            PUT_WithValue(l => l.perspective, "A", false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_LossSet_PUT_Perspective_Null()
        {
            PUT_Attribute_Null(l => l.perspective);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_LossSet_PUT_Perspective_Blank()
        {
            PUT_StringAttribute_Empty(l => l.perspective);
        }
        #endregion perspective
 
        #region analysis
        [TestMethod, TestCategory(TypeName)]
        public void Test_LossSet_PUT_Analysis()
        {
            PUT_WithValue(l => l.analysis,
                Samples.Analysis_VendorPortfolioAnalysis.AsReference, true);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_LossSet_PUT_Analysis_Reference_NullId()
        {
            PUT_Reference_NullId(l => l.analysis);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_LossSet_PUT_Analysis_Reference_EmptyStringId()
        {
            PUT_Reference_EmptyStringId(l => l.analysis);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_LossSet_PUT_Analysis_Reference_NonExistantId()
        {
            PUT_Reference_NonExistantId(l => l.analysis);
        }
        #endregion analysis
        #endregion PUT
    }
 
    [TestClass]
    [Obsolete("This tests a now obsolete class for backwards compatibility purposes.")]
    public sealed class TestSuite_LossSet_TreatyLossSet : TestSuite_ELTLossSet<TreatyLossSet>
    {
        #region Set Up and Configuration
        private const string TypeName = "TreatyLossSet";
        protected override IInjectableResource<TreatyLossSet> TestInjectableResource =>
            Samples.LossSet_TreatyLossSet;
 
        protected override string POSTData => Samples.CSV.Loss_Set_2_Data;
        #endregion Set Up and Configuration
 
        #region POST
        #region treaty
        [TestMethod, TestCategory(TypeName)]
        public void Test_LossSet_POST_Treaty_Null()
        {
            POST_Attribute_Null(l => l.treaty);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_LossSet_POST_Treaty_WithNullProperties()
        {
            POST_WithValue(l => l.treaty, new TreatyLossSet.Treaty { id = null, description = null }, false);
        }
        #endregion treaty
 
        #region analysis
        [TestMethod, TestCategory(TypeName)]
        public void Test_LossSet_POST_Analysis_Null()
        {
            POST_Attribute_Null(l => l.analysis);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_LossSet_POST_Analysis_Reference_NullId()
        {
            POST_Reference_NullId(l => l.analysis);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_LossSet_POST_Analysis_Reference_EmptyStringId()
        {
            POST_Reference_EmptyStringId(l => l.analysis);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_LossSet_POST_Analysis_Reference_NonExistantId()
        {
            POST_Reference_NonExistantId(l => l.analysis);
        }
        #endregion analysis
        #endregion POST
 
        #region PUT
        #region treaty
        [TestMethod, TestCategory(TypeName)]
        public void Test_LossSet_PUT_Treaty()
        {
            PUT_WithValue(l => l.treaty, new TreatyLossSet.Treaty { id = "2", description = "Test Treaty 2" }, true);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_LossSet_PUT_Treaty_WithNullProperties()
        {
            // If a treaty is supplied, all its values must be specified.
            PUT_WithValue(l => l.treaty,
                new TreatyLossSet.Treaty { id = null, description = null }, false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_LossSet_PUT_Treaty_Null()
        {
            PUT_Attribute_Null(l => l.treaty);
        }
        #endregion treaty
 
        #region analysis
        [TestMethod, TestCategory(TypeName)]
        public void Test_LossSet_PUT_Analysis()
        {
            PUT_WithValue(l => l.analysis, Samples.Analysis_VendorTreatyAnalysis.AsReference, true);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_LossSet_PUT_Analysis_Reference_NullId()
        {
            PUT_Reference_NullId(l => l.analysis);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_LossSet_PUT_Analysis_Reference_EmptyStringId()
        {
            PUT_Reference_EmptyStringId(l => l.analysis);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_LossSet_PUT_Analysis_Reference_NonExistantId()
        {
            PUT_Reference_NonExistantId(l => l.analysis);
        }
        #endregion analysis
        #endregion PUT
    }
    #endregion ELTLossSet Derived Types Test Classes
 
    #region LossSetWithData Derived Types Test Classes
    [TestClass]
    public sealed class TestSuite_LossSet_YELTLossSet : TestSuite_LossSet_Simulated<YELTLossSet>
    {
        #region Set Up and Configuration
        private const string TypeName = "YELTLossSet";
        protected override IInjectableResource<YELTLossSet> TestInjectableResource =>
            Samples.LossSet_YELTLossSet;
 
        protected override string POSTData => Samples.CSV.YELTLossSet_10Trials;
 
        protected override IInjectableResource<YELTLossSet> LossSetWithReinstatements =>
            Samples.LossSet_YELTLossSetWithReinstatements;
 
        protected override string POSTDataWithReinstatements =>
            Samples.CSV.YELTLossSet_WithReinstatements_10Trials;
        #endregion Set Up and Configuration
 
        #region POST
        #region event_catalogs
        [TestMethod, TestCategory(TypeName)]
        public void Test_YELTLossSet_POST_EventCatalogs_Null()
        {
            POST_Attribute_Null(l => l.event_catalogs);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_YELTLossSet_POST_EventCatalogs_Empty()
        {
            POST_ListAttribute_Empty(l => l.event_catalogs);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_YELTLossSet_POST_EventCatalogs_Invalid()
        {
            POST_ReferenceList_NonExistantId(a => a.event_catalogs);
        }
        #endregion event_catalogs
        #region yelt_adjustment_attributes
        [TestMethod, TestCategory(TypeName)]
        public void Test_AnalysisProfile_POST_YeltLossSetSimulationFiltering()
        {
            POST_WithValue(l => l.adjust_leap_years, true, true);
            POST_WithValue(l => l.one_based_sequencing, true, true);
        }
        #endregion yelt_adjustment_properties
 
        #region data_type
        [TestMethod, TestCategory(TypeName)]
        [Obsolete("ARE-5226 Remove support for Binary YELT Loss Set format. ")]
        public void Test_LossSet_POST_DataType_CSV()
        {
            POST_WithValue(l => l.data_type, YELTLossSet.DataType.csv, true);
        }
 
        [TestMethod, TestCategory(TypeName)]
        [Obsolete("ARE-5226 Remove support for Binary YELT Loss Set format. ")]
        public void Test_LossSet_POST_DataType_Binary()
        {
            YELTLossSet binaryLossSet =
                TestResource.Change(l => l.data_type, YELTLossSet.DataType.binary);
            GenericTest.POST_WithData_ThenDoAction(binaryLossSet,
                // We must also change the data we upload when we change the data type
                Samples.CSV.YELTLossSet_10Trials_ForBinary,
                TestSuite_LossSet_Base.Test_LossSet_Simulatable);
        }
        #endregion data_type
        #endregion POST
 
        #region PUT
        #region event_catalogs
        [TestMethod, TestCategory(TypeName)]
        public void Test_YELTLossSet_PUT_EventCatalogs()
        {
            PUT_WithValue(l => l.event_catalogs,
                new List<IReference<EventCatalog>> { Samples.EventCatalog.AsReference }, true);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_YELTLossSet_PUT_EventCatalogs_Null()
        {
            PUT_Attribute_Null(l => l.event_catalogs);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_YELTLossSet_PUT_EventCatalogs_Empty()
        {
            PUT_ListAttribute_Empty(l => l.event_catalogs);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_YELTLossSet_PUT_EventCatalogs_Invalid()
        {
            PUT_ReferenceList_NonExistantId(a => a.event_catalogs);
        }
        #endregion event_catalogs
 
        #region data_type
        [TestMethod, TestCategory(TypeName)]
        [Obsolete("ARE-5226 Remove support for Binary YELT Loss Set format. ")]
        public void Test_LossSet_PUT_DataType_CSV()
        {
            PUT_WithValue(l => l.data_type, YELTLossSet.DataType.csv, true);
        }
 
        [TestMethod, TestCategory(TypeName)]
        [Obsolete("ARE-5226 Remove support for Binary YELT Loss Set format. ")]
        public void Test_LossSet_PUT_DataType_Binary()
        {
            // We do not use the standard test, because we'll need to upload different data.
            //PUT_WithValue(l => l.data_type, YELTLossSet.DataType.binary, true);
            POST_ForPutTest(TestResource, posted =>
            {
                YELTLossSet toPut = posted.ShallowCopy().Change(l => l.data_type, YELTLossSet.DataType.binary);
                YELTLossSet putResponse = null;
                // The server will initially accept the modifications
                AssertApi.MethodIsAllowed(() => GenericTest.ExecuteWithConsoleErrorLogging(() => putResponse = toPut.Put()), "PUT");
                AssertApi.PutResponseMatches(posted, toPut, putResponse);
                // Take advantage of this utility to add binary data.
                putResponse = Reflection.FinalizePostedResource(putResponse);
                AdditionalValidResourceTests(putResponse);
            });
        }
        #endregion data_type
        #endregion PUT
    }
 
    [TestClass]
    public sealed class TestSuite_LossSet_YLTLossSet : TestSuite_LossSet_Simulated<YLTLossSet>
    {
        #region Set Up and Configuration
        private const string TypeName = "YLTLossSet";
        protected override IInjectableResource<YLTLossSet> TestInjectableResource =>
            Samples.LossSet_YLTLossSet;
 
        protected override string POSTData => Samples.CSV.YLTLossSet_10Trials;
        protected override LossType DefaultLossType => LossType.LossNetOfAggregateTerms;
 
        protected override IInjectableResource<YLTLossSet> LossSetWithReinstatements =>
            Samples.LossSet_YLTLossSetWithReinstatements;
 
        protected override string POSTDataWithReinstatements =>
            Samples.CSV.YLTLossSet_WithReinstatements_10Trials;
        #endregion Set Up and Configuration
 
        #region POST
        #region attributes
        [TestMethod, TestCategory(TypeName)]
        public void Test_ParametricLossSet_POST_Attributes_Null()
        {
            POST_Attribute_Null(l => l.attributes);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_ParametricLossSet_POST_Attributes_Empty()
        {
            POST_WithValue(l => l.attributes,
                new Dictionary<string, string>(), true);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_ParametricLossSet_POST_Attributes_Multiple()
        {
            POST_WithValue(l => l.attributes,
                new Dictionary<string, string> {
                    { "Test1", "TestValue" },
                    { "Test2", "2" },
                    { "Test 3", "3.33" }
                }, true);
        }
        #endregion attributes
        #endregion POST
 
        #region PUT
        public override void Test_LossSet_PUT_LossType_Null()
        {
            // BUG: ARE-2618 - loss_type is left unchanged on PUT, but most other properties
            //      get "reset" to their default value on PUT - this is an inconsistency
            // Note that this is only showing up for YLTLossSets because the default value
            //   is 'LossNetOfAggregateTerms', but the test resource has it set to 'LossGross'.
            //   Many other test resources have property values equal to their defaults, so
            //   the tests don't "detect" whether the property is being "reset" or left alone.
            Skip.Indefinitely("ARE-2618 - Some Properties Not Reset on PUT");
            base.Test_LossSet_PUT_LossType_Null();
        }
 
        #region attributes
        [TestMethod, TestCategory(TypeName)]
        public void Test_ParametricLossSet_PUT_Attributes_Empty()
        {
            PUT_WithValue(l => l.attributes,
                new Dictionary<string, string>(), true);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_ParametricLossSet_PUT_Attributes_MixedTypes()
        {
            PUT_WithValue(l => l.attributes,
                new Dictionary<string, string> {
                    { "Test1", "TestValue" },
                    { "Test2", "2" },
                    { "Test 3", "3.33" }
                }, true);
        }
        #endregion attributes
        #endregion PUT
 
        #region data / profile tests
        [TestMethod, TestCategory(TypeName)]
        public void Test_LossSet_YLTLossSet_NegativeLosses_Succeeds()
        {
            GenericTest.POST_ValidResourceWithData(new YLTLossSet
            {
                description = "Negative Losses",
                currency = "USD",
                trial_count = 10,
                start_date = DateTime.Today
            }, "trial_id,loss\n1,0\n2,-10");
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_LossSet_YLTLossSet_ProfileValid()
        {
            GenericTest.POST_WithData_ThenDoAction(new YLTLossSet
            {
                description = "Simple YLT Profile",
                currency = "USD",
                trial_count = 10,
                start_date = DateTime.Today
            }, "trial_id,loss\n1,0\n2,10", ls =>
            {
                Assert.IsNotNull(ls.profile);
                Assert.AreEqual(1.0, ls.profile.avg_annual_loss);
                Assert.AreEqual(0d, ls.profile.min_loss);
                Assert.AreEqual(10.0, ls.profile.max_loss);
                Assert.AreEqual("USD", ls.profile.currency);
                Assert.AreEqual(2, ls.profile.num_losses);
                Assert.AreEqual(1, ls.profile.non_zero_losses);
            });
        }
        #endregion data / profile tests
    }
    #endregion LossSetWithData Derived Types Test Classes
 
    #region Other Loss Set Test Classes
    [TestClass]
    public sealed class TestSuite_LossSet_ParametricLossSet : TestSuite_LossSet_WithCurrency<ParametricLossSet>
    {
        #region Set Up and Configuration
        private const string TypeName = "ParametricLossSet";
        protected override IInjectableResource<ParametricLossSet> TestInjectableResource =>
            Samples.LossSet_ParametricLossSet;
        #endregion Set Up and Configuration
 
        #region POST
        #region attributes
        [TestMethod, TestCategory(TypeName)]
        public void Test_ParametricLossSet_POST_Attributes_Null()
        {
            POST_Attribute_Null(l => l.attributes);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_ParametricLossSet_POST_Attributes_Empty()
        {
            POST_WithValue(l => l.attributes,
                new Dictionary<string, string>(), true);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_ParametricLossSet_POST_Attributes_Multiple()
        {
            POST_WithValue(l => l.attributes, new Dictionary<string, string>
            {
                { "Test1", "TestValue" },
                { "Test2", "2" },
                { "Test 3", "3.33" }
            }, true);
        }
        #endregion attributes
 
        #region frequency
        [TestMethod, TestCategory(TypeName)]
        public void Test_ParametricLossSet_POST_Frequency_Null()
        {
            POST_Attribute_Null(a => a.frequency);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_ParametricLossSet_POST_Frequency_Reference_NullId()
        {
            POST_Reference_NullId(a => a.frequency);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_ParametricLossSet_POST_Frequency_Reference_EmptyStringId()
        {
            POST_Reference_EmptyStringId(a => a.frequency);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_ParametricLossSet_POST_Frequency_Reference_NonExistantId()
        {
            POST_Reference_NonExistantId(a => a.frequency);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_ParametricLossSet_POST_Frequency_AllValidTypes()
        {
            IReference<IDiscreteDistribution>[] validDistributions =
            {
                Samples.Distribution_CustomFrequencyDistribution.AsReference,
                Samples.Distribution_BinomialDistribution.AsReference,
                Samples.Distribution_NegativeBinomialDistribution.AsReference,
                Samples.Distribution_DiracDistribution.AsReference,
                Samples.Distribution_PoissonDistribution.AsReference,
                Samples.Distribution_UniformIntDistribution.AsReference
            };
            foreach (IReference<IDiscreteDistribution> distribution in validDistributions)
                POST_WithValue(a => a.frequency, distribution, true);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_ParametricLossSet_POST_Frequency_AllInvalidTypes()
        {
            // Certain distribution types cannot be associated with this property, even though
            // no type constraint is available to distinguish. Here we verify that the user
            // returns an error for those loss set types that might mistakenly be used.
            IReference<IDiscreteDistribution>[] invalidDistributions =
            {
                Samples.Distribution_CustomSeasonalityDistribution.AsReference,
                Samples.Distribution_CustomSeverityDistribution.AsReference
            };
            foreach (IReference<IDiscreteDistribution> distribution in invalidDistributions)
                POST_WithValue(a => a.frequency, distribution, false);
        }
        #endregion frequency
 
        #region seasonality
        [TestMethod, TestCategory(TypeName)]
        public void Test_ParametricLossSet_POST_Seasonality_Null()
        {
            POST_Attribute_Null(a => a.seasonality);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_ParametricLossSet_POST_Seasonality_Reference_NullId()
        {
            POST_Reference_NullId(a => a.seasonality);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_ParametricLossSet_POST_Seasonality_Reference_EmptyStringId()
        {
            POST_Reference_EmptyStringId(a => a.seasonality);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_ParametricLossSet_POST_Seasonality_Reference_NonExistantId()
        {
            POST_Reference_NonExistantId(a => a.seasonality);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_ParametricLossSet_POST_Seasonality_AllValidTypes()
        {
            IReference<IContinuousDistribution>[] validDistributions =
            {
                Samples.Distribution_CustomSeasonalityDistribution.AsReference,
                Samples.Distribution_LogNormalDistribution.AsReference,
                Samples.Distribution_NormalDistribution.AsReference,
                Samples.Distribution_DiracDistribution.AsReference,
                Samples.Distribution_ParetoDistribution.AsReference,
                Samples.Distribution_UniformDistribution.AsReference
            };
            foreach (IReference<IContinuousDistribution> distribution in validDistributions)
                POST_WithValue(a => a.seasonality, distribution, true);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_ParametricLossSet_POST_Seasonality_AllInvalidTypes()
        {
            // Certain distribution types cannot be associated with this property, even though
            // no type constraint is available to distinguish. Here we verify that the user
            // returns an error for those loss set types that might mistakenly be used.
            IReference<IContinuousDistribution>[] invalidDistributions =
            {
                Samples.Distribution_CustomFrequencyDistribution.AsReference,
                Samples.Distribution_CustomSeverityDistribution.AsReference
            };
            foreach (IReference<IContinuousDistribution> distribution in invalidDistributions)
                POST_WithValue(a => a.seasonality, distribution, false);
        }
        #endregion seasonality
 
        #region severity
        [TestMethod, TestCategory(TypeName)]
        public void Test_ParametricLossSet_POST_Severity_Null()
        {
            POST_Attribute_Null(a => a.severity);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_ParametricLossSet_POST_Severity_Reference_NullId()
        {
            POST_Reference_NullId(a => a.severity);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_ParametricLossSet_POST_Severity_Reference_EmptyStringId()
        {
            POST_Reference_EmptyStringId(a => a.severity);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_ParametricLossSet_POST_Severity_Reference_NonExistantId()
        {
            POST_Reference_NonExistantId(a => a.severity);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_ParametricLossSet_POST_Severity_AllValidTypes()
        {
            IReference<IContinuousDistribution>[] validDistributions =
            {
                Samples.Distribution_CustomSeverityDistribution.AsReference,
                Samples.Distribution_LogNormalDistribution.AsReference,
                Samples.Distribution_NormalDistribution.AsReference,
                Samples.Distribution_DiracDistribution.AsReference,
                Samples.Distribution_ParetoDistribution.AsReference,
                Samples.Distribution_UniformDistribution.AsReference
            };
            foreach (IReference<IContinuousDistribution> distribution in validDistributions)
                POST_WithValue(a => a.severity, distribution, true);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_ParametricLossSet_POST_Severity_AllInvalidTypes()
        {
            // Certain distribution types cannot be associated with this property, even though
            // no type constraint is available to distinguish. Here we verify that the user
            // returns an error for those loss set types that might mistakenly be used.
            IReference<IContinuousDistribution>[] invalidDistributions =
            {
                Samples.Distribution_CustomFrequencyDistribution.AsReference,
                Samples.Distribution_CustomSeasonalityDistribution.AsReference
            };
            foreach (IReference<IContinuousDistribution> distribution in invalidDistributions)
                POST_WithValue(a => a.severity, distribution, false);
        }
        #endregion severity
 
        #region start_date
        [TestMethod, TestCategory(TypeName)]
        public void Test_ParametricLossSet_POST_StartDate_MinValue()
        {
            DateTime minUtcDateTime = new DateTime(0L, DateTimeKind.Utc);
            POST_WithValue(l => l.start_date, minUtcDateTime, true);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_ParametricLossSet_POST_StartDate_MaxValue()
        {
            DateTime maxUtcDateTime = new DateTime(DateTime.MaxValue.Ticks, DateTimeKind.Utc);
            POST_WithValue(l => l.start_date, maxUtcDateTime, true);
        }
        #endregion start_date
 
        #region profile
        [TestMethod, TestCategory(TypeName)]
        public override void Test_LossSet_CreatesProfile()
        {
            if (EnvironmentSettings.RUN_OFFLINE)
                Assert.Inconclusive("RUN_OFFLINE = true");
            // Overridden because the ParametricLossSet behaves slightly differently
            ParametricLossSet ls = TestResource_Existing;
            Assert.IsNotNull(ls.profile, "Profile was null");
            Assert.IsNotNull(ls.profile.min_loss, "min_loss was null");
            Assert.IsNotNull(ls.profile.max_loss, "max_loss was null");
            Assert.IsNotNull(ls.profile.avg_annual_loss, "avg_annual_loss was null");
            Assert.IsNotNull(ls.profile.num_losses, "num_losses was null");
            // Only difference: No notion of non-zero losses for this loss set type.
            // TODO: Can the server just set this==num_losses too (see ARE-3164)
            Assert.IsNull(ls.profile.non_zero_losses, "non_zero_losses was null");
            Assert.IsNotNull(ls.profile.currency, "Currency was null");
            Assert.IsNotNull(ls.profile.attributes, "Attributes was null");
            Assert.AreNotEqual(ls.profile.attributes.Count, 0, "Attributes were empty");
        }
        #endregion profile
 
        #region event_id
        [TestMethod, TestCategory(TypeName)]
        public void Test_ParametricLossSet_POST_EventId_Null()
        {
            POST_Attribute_Null(l => l.event_id);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_ParametricLossSet_POST_EventId_MinValue()
        {
            POST_WithValue(l => l.event_id, 0uL, true);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_ParametricLossSet_POST_EventId_MaxValue()
        {
            // TODO: ARE-4300: The largest value currently allowed by the API is Int32.Max
            // (even though the type is supposed to be an unsigned long and support up to UInt64.Max)
            POST_WithValue(l => l.event_id, (ulong)Int32.MaxValue, true);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_ParametricLossSet_POST_EventId_GreaterThanMaxValue()
        {
            // TODO: ARE-4300: this should succeed once we fix all the API integer validation
            POST_WithValue(l => l.event_id, UInt64.MaxValue, false);
        }
        #endregion event_id
        #endregion POST
 
        #region data / profile tests
        [TestMethod, TestCategory(TypeName)]
        public void Test_LossSet_ParametricLossSet_NegativeProfile()
        {
            GenericTest.POST_ThenDoAction(
                new DiracDistribution { description = "1", value = 1 },
                oneDist =>
                {
                    POST_ThenDoAction(new ParametricLossSet
                    {
                        description = "Retro Coverage Income",
                        currency = "USD",
                        seasonality = oneDist.ToReference(),
                        severity = new DiracDistribution { description = "-1", value = -1 }.Post().ToReference(),
                        frequency = oneDist.ToReference(),
                        start_date = DateTime.Today
                    }, ls =>
                    {
                        Assert.IsNotNull(ls.profile);
                        Assert.AreEqual(-1d, ls.profile.avg_annual_loss);
                        Assert.AreEqual(-1d, ls.profile.min_loss);
                        Assert.AreEqual(-1d, ls.profile.max_loss);
                        Assert.AreEqual("USD", ls.profile.currency);
                        Assert.AreEqual(1, ls.profile.num_losses);
                        Assert.IsNull(ls.profile.non_zero_losses);
                    });
                });
        }
        #endregion data / profile tests
        
        [TestMethod, TestCategory(TypeName)]
        public void Test_ParametricLossSet_ARE6592()
        {
            // BUG ARE-6592 discovered that including a parametric loss set in a layer_view
            //     could cause its id to become non-deterministic.
            //Skip.Indefinitely("ARE-6592: Posting a LayerView containing a ParametricLossSet...");
            // TODO: Once this bug is fixed, we should start using parametric loss sets in
            //       our test resource more often.
            ILayerView<Filter> testView = Samples.LayerView_Filter.Unposted;
            testView.layer.loss_sets = Samples.AllLossSetTypesTestList
                .Select(ls => ls.AsReference).ToList();
            // In theory, this bug might exist for inlined filters as well
            testView.layer.filters = new List<IReference<LossFilter>>
            {
                Samples.LossFilter_AnyFilter.AsReference,
                Samples.LossFilter_AndFilter.AsReference,
                Samples.LossFilter_AnyOfFilter.AsReference,
                Samples.LossFilter_GTFilter.AsReference,
                Samples.LossFilter_LTFilter.AsReference,
                Samples.LossFilter_OrFilter.AsReference,
                Samples.LossFilter_RangeFilter.AsReference,
                Samples.LossFilter_RecordTypeAnyOfFilter.AsReference
            };
 
            string expectedId = testView.Post().id;
            // Re-post this layer_view several times. We expect to get the same id each time.
            Enumerable.Range(1, 20).AsParallel().ForAll(i =>
                GenericTest.POST_ThenDoAction(testView, posted =>
                    Assert.AreEqual(expectedId, posted.id,
                        $"The id of the posted layer_view changed on attempt {i} of 10, " +
                        $"despite the request being identical in each case.")));
        }
    }
 
    [TestClass]
    [Obsolete("This tests a now obsolete class for backwards compatibility purposes.")]
    public sealed class TestSuite_LossSet_NestedLayerLossSet : TestSuite_LossSet<NestedLayerLossSet>
    {
        #region Set Up and Configuration
        private const string TypeName = "NestedLayerLossSet";
        protected override IInjectableResource<NestedLayerLossSet> TestInjectableResource =>
            Samples.LossSet_NestedLayerLossSet;
        #endregion Set Up and Configuration
 
        [TestMethod, TestCategory(TypeName)]
        public override void Test_LossSet_POST_LossType_LossNetOfAggregateTerms()
        {
            Skip.UntilRelease.Validation("ARE-6040: NestedLayerLossSet.loss_type " +
                "should not be LossNetOfAggregateTerms, but API allows it.");
            base.Test_LossSet_POST_LossType_LossNetOfAggregateTerms();
        }
 
        #region POST
        #region layer
        [TestMethod, TestCategory(TypeName)]
        public void Test_NestedLayerLossSet_POST_Layer_EveryType()
        {
            // Loop over each layer type, generated a nestedLayerLossSet with it, and test POST
            foreach (IInjectableResource<ILayer> layer in Samples.AllSaveableLayerTypesTestList)
                GenericTest.POST_ValidResource(
                    Samples.GetInjectableNestedLayerLossSet(layer).Unposted);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_NestedLayerLossSet_POST_Layer_MixedLossSetTypes()
        {
            // A layer may be posted such that it contains mixed loss set types. For a time
            // this created issues with NestedLayerLossSets, but it should now be supported.
            AggXL modified = Samples.Layer_AggXL.Unposted;
            modified.loss_sets = Samples.AllLossSetTypesTestList.Select(ls => ls.AsReference).ToList();
            GenericTest.POST_ValidResource(Samples.GetInjectableNestedLayerLossSet(
                InjectableResource.Create(modified)).Unposted);
        }
        #endregion layer
 
        #region profile
        [TestMethod, TestCategory(TypeName)]
        public override void Test_LossSet_CreatesProfile()
        {
            if (EnvironmentSettings.RUN_OFFLINE)
                Assert.Inconclusive("RUN_OFFLINE = true");
            // In the case of NestedLayerLossSets, we expect the profile to be mostly empty
            NestedLayerLossSet lossSet = TestResource_Existing;
            Assert.IsNotNull(lossSet.profile, "Profile was null");
            Assert.IsNull(lossSet.profile.min_loss, "Expected min_loss to be null");
            Assert.IsNull(lossSet.profile.max_loss, "Expected max_loss to be null");
            Assert.IsNull(lossSet.profile.avg_annual_loss, "Expected avg_annual_loss to be null");
            Assert.IsNull(lossSet.profile.num_losses, "Expected num_losses to be null");
            Assert.IsNotNull(lossSet.profile.currency, "Currency was null");
            Assert.IsNotNull(lossSet.profile.attributes, "Attributes was null");
            Assert.AreEqual(lossSet.profile.attributes.Count, 0, "Expected attributes to be empty");
        }
        #endregion profile
        #endregion POST
    }
 
    [TestClass]
    public sealed class TestSuite_LossSet_LoadedLossSet : TestSuite_LossSet<LoadedLossSet>
    {
        #region Set Up and Configuration
        private const string TypeName = "LoadedLossSet";
        protected override IInjectableResource<LoadedLossSet> TestInjectableResource =>
            Samples.LossSet_LoadedLossSet;
        #endregion Set Up and Configuration
 
        #region POST
        #region source
        [TestMethod, TestCategory(TypeName)]
        public void Test_LoadedLossSet_POST_Source_EveryType()
        {
            // Loop over each LossSet type, generated a LoadedLossSe with it, and test POST
            foreach (IInjectableResource<LossSet> source in Samples.AllLossSetTypesTestList)
                GenericTest.POST_ValidResource(Samples.GetInjectableLoadedLossSet(source, 1.5).Unposted);
        }
        #endregion source
 
        #region load
        [TestMethod, TestCategory(TypeName)]
        public void Test_LoadedLossSet_POST_Load_MaxValue()
        {
            POST_WithValue(l => l.load, Double.MaxValue, true);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_LoadedLossSet_POST_Load_MinValue()
        {
            POST_WithValue(l => l.load, Double.MinValue, true);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_LoadedLossSet_POST_Load_NaN()
        {
            POST_WithValue(l => l.load, Double.NaN, false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_LoadedLossSet_POST_Load_Infinity()
        {
            POST_WithValue(l => l.load, Double.PositiveInfinity, false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_LoadedLossSet_POST_Load_NegativeInfinity()
        {
            POST_WithValue(l => l.load, Double.NegativeInfinity, false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_LoadedLossSet_POST_Load_HighPrecision()
        {
            POST_WithValue(l => l.load, Math.PI / 1E12, true);
        }
        #endregion load
        #endregion POST
    }
 
    [TestClass]
    public sealed class TestSuite_LossSet_QCLSLossSet : TestSuite_LossSet_WithCurrency<QCLSLossSet>
    {
        #region Set Up and Configuration
        private const string TypeName = "QCLSLossSet";
        protected override IInjectableResource<QCLSLossSet> TestInjectableResource =>
            Samples.LossSet_QCLSLossSet;
        #endregion Set Up and Configuration
 
        #region POST
        #region correlation_coefficient
        [TestMethod, TestCategory(TypeName)]
        public void Test_QCLSLossSet_POST_CorrelationCoefficient_MaxValue()
        {
            POST_WithValue(l => l.correlation_coefficient, 1d, true);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_QCLSLossSet_POST_CorrelationCoefficient_MinValue()
        {
            POST_WithValue(l => l.correlation_coefficient, -1d, true);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_QCLSLossSet_POST_CorrelationCoefficient_GreaterThanMaxValue()
        {
            POST_WithValue(l => l.correlation_coefficient, 1.01d, false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_QCLSLossSet_POST_CorrelationCoefficient_LessThanMinValue()
        {
            POST_WithValue(l => l.correlation_coefficient, -1.01d, false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_QCLSLossSet_POST_CorrelationCoefficient_NaN()
        {
            POST_WithValue(l => l.correlation_coefficient, Double.NaN, false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_QCLSLossSet_POST_CorrelationCoefficient_Zero()
        {
            POST_WithValue(l => l.correlation_coefficient, 0d, true);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_QCLSLossSet_POST_CorrelationCoefficient_HighPrecision()
        {
            POST_WithValue(l => l.correlation_coefficient, Math.PI / 1E12, true);
        }
        #endregion correlation_coefficient
 
        #region distribution
        [TestMethod, TestCategory(TypeName)]
        public void Test_QCLSLossSet_POST_Distribution_Null()
        {
            POST_Attribute_Null(a => a.distribution);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_QCLSLossSet_POST_Distribution_Reference_NullId()
        {
            POST_Reference_NullId(a => a.distribution);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_QCLSLossSet_POST_Distribution_Reference_EmptyStringId()
        {
            POST_Reference_EmptyStringId(a => a.distribution);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_QCLSLossSet_POST_Distribution_Reference_NonExistantId()
        {
            POST_Reference_NonExistantId(a => a.distribution);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_QCLSLossSet_POST_Distribution_AllValidTypes()
        {
            IReference<IContinuousDistribution>[] validDistributions =
            {
                Samples.Distribution_CustomSeverityDistribution.AsReference,
                Samples.Distribution_LogNormalDistribution.AsReference,
                Samples.Distribution_NormalDistribution.AsReference,
                Samples.Distribution_DiracDistribution.AsReference,
                Samples.Distribution_ParetoDistribution.AsReference,
                Samples.Distribution_UniformDistribution.AsReference
            };
            foreach (IReference<IContinuousDistribution> distribution in validDistributions)
                POST_WithValue(a => a.distribution, distribution, true);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_QCLSLossSet_POST_Distribution_AllInvalidTypes()
        {
            // Certain distribution types cannot be associated with this property, even though
            // no type constraint is available to distinguish. Here we verify that the user
            // returns an error for those loss set types that might mistakenly be used.
            IReference<IContinuousDistribution>[] invalidDistributions =
            {
                Samples.Distribution_CustomFrequencyDistribution.AsReference,
                Samples.Distribution_CustomSeasonalityDistribution.AsReference
            };
            foreach (IReference<IContinuousDistribution> distribution in invalidDistributions)
                POST_WithValue(a => a.distribution, distribution, false);
        }
        #endregion distribution
 
        #region simulation
        [TestMethod, TestCategory(TypeName)]
        public void Test_QCLSLossSet_POST_Simulation_Null()
        {
            POST_Attribute_Null(a => a.simulation);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_QCLSLossSet_POST_Simulation_Reference_NullId()
        {
            POST_Reference_NullId(a => a.simulation);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_QCLSLossSet_POST_Simulation_Reference_EmptyStringId()
        {
            POST_Reference_EmptyStringId(a => a.simulation);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_QCLSLossSet_POST_Simulation_Reference_NonExistantId()
        {
            POST_Reference_NonExistantId(a => a.simulation);
        }
        #endregion simulation
 
        #region profile
        [TestMethod, TestCategory(TypeName)]
        public override void Test_LossSet_CreatesProfile()
        {
            // Currently, no loss set profile is created for this type.
            Skip.Indefinitely("ARE-3782: QCLS Loss Set Profile");
            base.Test_LossSet_CreatesProfile();
        }
        #endregion profile
        #endregion POST
    }
    #endregion Other Loss Set Test Classes
 
    #region Abstract Base Test Classes
    [TestClass]
    public abstract class TestSuite_LossSet_Simulated<T> : TestSuite_LossSet_WithData<T>
        where T : LossSet_WithData, ILossSet_Simulated
    {
        private const string TypeName = "ILossSet_Simulated";
 
        #region Abstract Members
        protected abstract IInjectableResource<T> LossSetWithReinstatements { get; }
 
        protected abstract string POSTDataWithReinstatements { get; }
        #endregion Abstract Members
 
        #region POST
        #region trial_count
        [TestMethod, TestCategory(TypeName)]
        public void Test_LossSet_POST_TrialCount_Negative()
        {
            POST_WithValue(s => s.trial_count, -1, false);
        }
        #endregion trial_count
 
        #region start_date
        [TestMethod, TestCategory(TypeName)]
        public void Test_LossSet_POST_StartDate_MinValue()
        {
            DateTime minUtcDateTime = new DateTime(0L, DateTimeKind.Utc);
            POST_WithValue(l => l.start_date, minUtcDateTime, true);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_LossSet_POST_StartDate_MaxValue()
        {
            DateTime maxUtcDateTime = new DateTime(DateTime.MaxValue.Ticks, DateTimeKind.Utc);
            POST_WithValue(l => l.start_date, maxUtcDateTime, true);
        }
        #endregion start_date
 
        #region reinstatements_data_type
        [TestMethod, TestCategory(TypeName)]
        public void Test_LossSet_POST_ReinstatementsDataType_Currency()
        {
            POST_WithValue(l => l.reinstatements_data_type, ReinstatementsDataType.currency, true);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_LossSet_POST_ReinstatementsDataType_Percentage()
        {
            POST_WithValue(l => l.reinstatements_data_type, ReinstatementsDataType.percentage, true);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_LossSet_POST_ReinstatementsDataType_Null()
        {
            POST_Attribute_Null(l => l.reinstatements_data_type);
        }
        #endregion reinstatements_data_type
        #endregion POST
 
        #region PUT
        #region trial_count
        [TestMethod, TestCategory(TypeName)]
        public void Test_LossSet_PUT_TrialCount()
        {
            PUT_WithValue(s => s.trial_count, 1234, true);
        }
        #endregion trial_count
 
        #region start_date
        [TestMethod, TestCategory(TypeName)]
        public void Test_LossSet_PUT_StartDate_MinValue()
        {
            DateTime minUtcDateTime = new DateTime(0L, DateTimeKind.Utc);
            PUT_WithValue(l => l.start_date, minUtcDateTime, true);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_LossSet_PUT_StartDate_MaxValue()
        {
            DateTime maxUtcDateTime = new DateTime(DateTime.MaxValue.Ticks, DateTimeKind.Utc);
            PUT_WithValue(l => l.start_date, maxUtcDateTime, true);
        }
        #endregion start_date
 
        #region reinstatements_data_type
        [TestMethod, TestCategory(TypeName)]
        public void Test_LossSet_PUT_ReinstatementsDataType_Currency()
        {
            PUT_WithValue(l => l.reinstatements_data_type, ReinstatementsDataType.currency, true);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_LossSet_PUT_ReinstatementsDataType_Percentage()
        {
            PUT_WithValue(l => l.reinstatements_data_type, ReinstatementsDataType.percentage, true);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_LossSet_PUT_ReinstatementsDataType_Null()
        {
            PUT_Attribute_Null(l => l.reinstatements_data_type);
        }
        #endregion reinstatements_data_type
        #endregion PUT
 
        #region Reinstatement Information Tests
        [TestMethod, TestCategory(TypeName)]
        public void Test_LossSet_POST_LossNetOfAggregateTerms_ReinstatementInformation()
        {
            GenericTest.POST_ValidResourceWithData(LossSetWithReinstatements.Unposted
                    .Change(ls => ls.loss_type, LossType.LossNetOfAggregateTerms),
                POSTDataWithReinstatements);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_LossSet_POST_LossGross_ReinstatementInformation()
        {
            GenericTest.POST_InvalidResourceWithData_Fails(LossSetWithReinstatements.Unposted
                    .Change(ls => ls.loss_type, LossType.LossGross), POSTDataWithReinstatements,
                // Expect an error on commit referencing the loss_type property.
                (CommitFailedException ex) => Assert.IsTrue(ex.Message.Contains(nameof(LossSet.loss_type))));
        }
 
        #region Test Different Wrapper Layer Types
        private readonly MetricsOptions _requestPremium = MetricsOptions.Default
            .Change(o => o.perspective, Perspective.ReinstatementPremium);
 
        private void Test_LossSet_ReinstatementInformation_Forwarded(ILayer_WithLossSets wrapperLayer)
        {
            if (EnvironmentSettings.RUN_OFFLINE)
                Assert.Inconclusive("RUN_OFFLINE = true");
            T preparedResource = LossSetWithReinstatements.Posted;
            T fixed_reinstatements, variable_reinstatements;
            ILayerView<ILayer_WithLossSets> testLayerView;
            double rprem, new_rprem;
 
            // Create a copy of the loss set with each reinstatements data type set.
            if (preparedResource.reinstatements_data_type == ReinstatementsDataType.currency)
            {
                fixed_reinstatements = preparedResource;
                variable_reinstatements = preparedResource
                    .Change(ls => ls.reinstatements_data_type, ReinstatementsDataType.percentage)
                    .Post().PollUntilReady(Samples.DataPollingOptions);
            }
            else
            {
                variable_reinstatements = preparedResource;
                fixed_reinstatements = preparedResource
                    .Change(ls => ls.reinstatements_data_type, ReinstatementsDataType.currency)
                    .Post().PollUntilReady(Samples.DataPollingOptions);
            }
 
            // If this layer has a premium property, we will play with changing its value.
            // Even if this layer doesn't have a premium property, we should be able to test
            // that a loss set with 'currency' premium values has its values passed through.
            ILayer_WithTerms asWithPremium = wrapperLayer as ILayer_WithTerms;
            if (asWithPremium != null)
                asWithPremium.premium = new MonetaryUnit(5000, "USD");
 
            PollingOptions simulationPolling = TestSuite_APIResourceView.SimulationPolling;
 
            // A LayerView with fixed reinstatements should never change it's reinstatement premium
            wrapperLayer.loss_sets = new List<IReference<LossSet>> { fixed_reinstatements.ToReference() };
            testLayerView = Samples.GetInjectableLayerView(wrapperLayer).Posted;
            rprem = API.PollUntilReady(() => testLayerView.expected_loss(_requestPremium), simulationPolling);
            Assert.IsTrue(rprem > 0, "Expected some non-zero reinstatement premium.");
 
            // Post a new layer with a different premium, assert that reinstatement premium is the same.
            if (asWithPremium != null)
            {
                asWithPremium.premium = new MonetaryUnit(0, "USD");
                testLayerView = Samples.GetInjectableLayerView(wrapperLayer).Posted;
                new_rprem = API.PollUntilReady(() => testLayerView.expected_loss(_requestPremium), simulationPolling);
                Assert.AreEqual(rprem, new_rprem, "Expected the reinstatement premium to remain the same.");
            }
 
            // Now if we run the same experiment with loss type set to "percentage", we should see changes
            if (asWithPremium != null)
                asWithPremium.premium = new MonetaryUnit(5000, "USD");
            wrapperLayer.loss_sets = new List<IReference<LossSet>> { variable_reinstatements.ToReference() };
            testLayerView = Samples.GetInjectableLayerView(wrapperLayer).Posted;
            rprem = API.PollUntilReady(() => testLayerView.expected_loss(_requestPremium), simulationPolling);
            if (asWithPremium == null)
            {
                Assert.AreEqual(0, rprem, $"Expected the reinstatement premium to be zero " +
                    $"since the wrapper layer type {wrapperLayer.GetType()} has no premium property.");
                return;
            }
            Assert.IsTrue(rprem > 0, "Expected some non-zero reinstatement premium.");
 
            // Post a new layer with a premium of zero. Expect the reinstatement premium to become zero.
            asWithPremium.premium = new MonetaryUnit(0, "USD");
            testLayerView = Samples.GetInjectableLayerView(wrapperLayer).Posted;
            new_rprem = API.PollUntilReady(() => testLayerView.expected_loss(_requestPremium), simulationPolling);
            Assert.AreEqual(0, new_rprem, "Expected the reinstatement premium to be zero since premium is zero.");
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_LossSet_ReinstatementInformation_Forwarded_QuotaShare()
        {
            Test_LossSet_ReinstatementInformation_Forwarded(
                new QuotaShare { event_limit = new MonetaryUnit(Double.MaxValue, "USD") });
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_LossSet_ReinstatementInformation_Forwarded_CatXL()
        {
            Test_LossSet_ReinstatementInformation_Forwarded(new CatXL
            {
                attachment = new MonetaryUnit(0, "USD"),
                limit = new MonetaryUnit(Double.MaxValue, "USD"),
                franchise = new MonetaryUnit(0, "USD"),
                nth = 1,
            });
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_LossSet_ReinstatementInformation_Forwarded_AggXL()
        {
            Test_LossSet_ReinstatementInformation_Forwarded(new AggXL
            {
                attachment = new MonetaryUnit(0, "USD"),
                limit = new MonetaryUnit(Double.MaxValue, "USD"),
                aggregate_attachment = new MonetaryUnit(0, "USD"),
                aggregate_limit = new MonetaryUnit(Double.MaxValue, "USD"),
                franchise = new MonetaryUnit(0, "USD"),
            });
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_LossSet_ReinstatementInformation_Forwarded_Generic()
        {
            Test_LossSet_ReinstatementInformation_Forwarded(new Generic
            {
                attachment = new MonetaryUnit(0, "USD"),
                limit = new MonetaryUnit(Double.MaxValue, "USD"),
                aggregate_attachment = new MonetaryUnit(0, "USD"),
                aggregate_limit = new MonetaryUnit(Double.MaxValue, "USD"),
                franchise = new MonetaryUnit(0, "USD"),
            });
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_LossSet_ReinstatementInformation_Forwarded_FilterLayer()
        {
            Test_LossSet_ReinstatementInformation_Forwarded(new Filter { invert = true });
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_LossSet_ReinstatementInformation_Forwarded_FixedRateCurrencyConverter()
        {
            Test_LossSet_ReinstatementInformation_Forwarded(new FixedRateCurrencyConverter
            {
                in_currency = "USD",
                out_currency = "CAD",
                rate = 1.0
            });
        }
        #endregion Test Different Wrapper Layer Types
 
        // TODO: Assert that the perspective "LossGross" cannot be queries on layers containing net loss sets.
        #endregion Reinstatement Information Tests
    }
 
    [TestClass]
    public abstract class TestSuite_ELTLossSet<T> : TestSuite_LossSet_WithData<T> where T : ELTLossSet
    {
        private const string TypeName = "ELTLossSet";
 
        #region POST
        #region event_catalogs
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_ELTLossSet_POST_EventCatalogs_Null()
        {
            POST_Attribute_Null(l => l.event_catalogs);
        }
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_ELTLossSet_POST_EventCatalogs_Empty()
        {
            POST_ListAttribute_Empty(l => l.event_catalogs);
        }
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_ELTLossSet_POST_EventCatalogs_Invalid()
        {
            POST_ReferenceList_NonExistantId(a => a.event_catalogs);
        }
        #endregion event_catalogs
        #endregion POST
 
        #region PUT
        #region event_catalogs
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_ELTLossSet_PUT_EventCatalogs()
        {
            PUT_WithValue(l => l.event_catalogs, new List<IReference<EventCatalog>> { Samples.EventCatalog.AsReference }, true);
        }
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_ELTLossSet_PUT_EventCatalogs_Null()
        {
            PUT_Attribute_Null(l => l.event_catalogs);
        }
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_ELTLossSet_PUT_EventCatalogs_Empty()
        {
            PUT_ListAttribute_Empty(l => l.event_catalogs);
        }
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_ELTLossSet_PUT_EventCatalogs_Invalid()
        {
            PUT_ReferenceList_NonExistantId(a => a.event_catalogs);
        }
        #endregion event_catalogs
        #endregion PUT
    }
 
    [TestClass]
    public abstract class TestSuite_LossSet_WithData<T> : BaseResourceWithDataTestSuite<T>
        where T : LossSet_WithData
    {
        private const string TypeName = "LossSetWithData";
        protected virtual LossType DefaultLossType => LossType.LossGross;
 
        public override void AdditionalValidResourceWithDataTests(T posted) =>
            TestSuite_LossSet_Base.Test_LossSet_Simulatable(posted);
 
        // We inherit some complex tests from BaseResourceWithLargeDataTest.
        // Ideally, we could also inherit the tests from Test_LossSet_WithCurrency<T>
        // (as well as the Test_LossSet<T> tests it inherits), but as multiple
        // inheritance is not supported, all we can do is copy those tests into
        // this alternate base test class.
        #region LossSet_WithCurrency
        // TODO: Ensure any new tests added to Test_LossSet_WithCurrency<T> are added below.
        #region POST
        #region currency
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_LossSet_WithCurrency_POST_Currency_Null()
        {
            POST_Attribute_Null(l => l.currency);
        }
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_LossSet_WithCurrency_POST_Currency_Blank()
        {
            POST_StringAttribute_Empty(l => l.currency);
        }
        // TODO: Test enforce currency length = 3 characters
        #endregion currency
        #endregion POST
 
        // PUT tests only apply to LossSets with Data since only these have a mutable state.
        #region PUT
        #region currency
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_LossSet_WithCurrency_PUT_Currency()
        {
            PUT_WithValue(l => l.currency, "CAD", true);
        }
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_LossSet_WithCurrency_PUT_Currency_Null()
        {
            PUT_Attribute_Null(l => l.currency);
        }
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_LossSet_WithCurrency_PUT_Currency_Blank()
        {
            PUT_StringAttribute_Empty(l => l.currency);
        }
        #endregion currency
        #endregion PUT
        #endregion LossSet_WithCurrency
 
        #region LossSet
        // TODO: Ensure any new tests added to Test_LossSet<T> are added below.
        #region POST
        #region loss_type
        [TestMethod, TestCategory(TypeName)]
        public void Test_LossSet_POST_LossType_LossGross()
        {
            POST_WithValue(l => l.loss_type, LossType.LossGross, true);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_LossSet_POST_LossType_LossNetOfAggregateTerms()
        {
            POST_WithValue(l => l.loss_type, LossType.LossNetOfAggregateTerms, true);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_LossSet_POST_LossType_Null()
        {
            POST_Attribute_Null(ls => ls.loss_type);
        }
        #endregion loss_type
 
        #region profile
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_LossSet_CreatesProfile()
        {
            if (EnvironmentSettings.RUN_OFFLINE)
                Assert.Inconclusive("RUN_OFFLINE = true");
            T ls = TestResource_Existing;
            Assert.IsNotNull(ls.profile, "Profile was null");
            Assert.IsNotNull(ls.profile.min_loss, "min_loss was null");
            Assert.IsNotNull(ls.profile.max_loss, "max_loss was null");
            Assert.IsNotNull(ls.profile.avg_annual_loss, "avg_annual_loss was null");
            Assert.IsNotNull(ls.profile.num_losses, "num_losses was null");
            Assert.IsNotNull(ls.profile.non_zero_losses, "non_zero_losses was null");
            Assert.IsNotNull(ls.profile.currency, "Currency was null");
            Assert.IsNotNull(ls.profile.attributes, "Attributes was null");
            Assert.AreNotEqual(ls.profile.attributes.Count, 0, "Attributes were empty");
        }
        #endregion profile
        #endregion POST
 
        // PUT tests only apply to LossSets with Data since only these have a mutable state.
        #region PUT
        #region loss_type
        [TestMethod, TestCategory(TypeName)]
        public void Test_LossSet_PUT_LossType_LossGross()
        {
            PUT_WithValue(l => l.loss_type, LossType.LossGross, true);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_LossSet_PUT_LossType_LossNetOfAggregateTerms()
        {
            PUT_WithValue(l => l.loss_type, LossType.LossNetOfAggregateTerms, true);
        }
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_LossSet_PUT_LossType_Null()
        {
            PUT_Attribute_Null(l => l.loss_type);
        }
        #endregion loss_type
        #endregion PUT
        #endregion LossSet
    }
 
    [TestClass]
    public abstract class TestSuite_LossSet_WithCurrency<T> : TestSuite_LossSet<T> where T : LossSet_WithCurrency
    {
        private const string TypeName = "LossSetWithLossType";
 
        #region POST
        #region currency
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_LossSet_WithCurrency_POST_Currency_Null()
        {
            POST_Attribute_Null(l => l.currency);
        }
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_LossSet_WithCurrency_POST_Currency_Blank()
        {
            POST_StringAttribute_Empty(l => l.currency);
        }
        // TODO: Test enforce currency length = 3 characters
        #endregion currency
        #endregion POST
    }
 
    [TestClass]
    public abstract class TestSuite_LossSet<T> : BaseImmutableResourceTestSuite<T> where T : LossSet
    {
        private const string TypeName = "LossSet";
 
        public override void AdditionalValidResourceTests(T posted) =>
            TestSuite_LossSet_Base.Test_LossSet_Simulatable(posted);
 
        #region POST
        #region loss_type
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_LossSet_POST_LossType_LossGross()
        {
            POST_WithValue(l => l.loss_type, LossType.LossGross, true);
        }
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_LossSet_POST_LossType_LossNetOfAggregateTerms()
        {
            POST_WithValue(l => l.loss_type, LossType.LossNetOfAggregateTerms, true);
        }
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_LossSet_POST_LossType_Null()
        {
            POST_Attribute_Null(ls => ls.loss_type);
        }
        #endregion loss_type
 
        #region profile
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_LossSet_CreatesProfile()
        {
            if (EnvironmentSettings.RUN_OFFLINE)
                Assert.Inconclusive("RUN_OFFLINE = true");
            T ls = TestResource_Existing;
            Assert.IsNotNull(ls.profile, "Profile was null");
            Assert.IsNotNull(ls.profile.min_loss, "min_loss was null");
            Assert.IsNotNull(ls.profile.max_loss, "max_loss was null");
            Assert.IsNotNull(ls.profile.avg_annual_loss, "avg_annual_loss was null");
            Assert.IsNotNull(ls.profile.num_losses, "num_losses was null");
            Assert.IsNotNull(ls.profile.non_zero_losses, "non_zero_losses was null");
            Assert.IsNotNull(ls.profile.currency, "Currency was null");
            Assert.IsNotNull(ls.profile.attributes, "Attributes was null");
            Assert.AreNotEqual(ls.profile.attributes.Count, 0, "Attributes were empty");
        }
        #endregion profile
        #endregion POST
    }
    #endregion Abstract Base Test Classes
}