Test_APIResourceView.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net;
 
using AnalyzeRe;
using AnalyzeRe.APIResourceView;
using AnalyzeRe.Layers;
using AnalyzeRe.LossFilters;
using AnalyzeRe.Metrics;
using AnalyzeRe.Utilities;
using AnalyzeReTesting.Base;
using AnalyzeReTesting.Tests.Model.DataTypes;
using AnalyzeReTesting.Utilities;
 
using RestSharp;
#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
{
    public static class TestSuite_APIResourceView
    {
        public static readonly PollingOptions SimulationPolling = new PollingOptions(
            maxPollInterval: EnvironmentSettings.POLLING_INTERVAL,
            maxPollTotalTime: EnvironmentSettings.SIMULATION_TIMEOUT
        );
 
        public static void TestMetricsRetrievable<T>(T view) where T : IAPIResourceView
        {
            Assert.IsNotNull(view.id, "The view must first be posted before testing its metrics.");
            try
            {
                TailMetrics result = view.tail_metrics_blocking(1,
                    MetricsOptions.Default, SimulationPolling);
                Console.WriteLine($"{view.GetType().NiceTypeName()} {view.id} " +
                    $"resulting metrics:\n{result.Serialize(true)}");
            }
            catch (NotWaitingException ex)
            {
                if (ex.InnerException is APIRequestException apiResponse)
                    Console.WriteLine("Timed out while waiting on metrics for the resource: " +
                        apiResponse.RestResponse.ResponseUri);
 
                // If we're stuck in the queue but something else is blocking it, set the test
                // to "Inconclusive" instead of "Failed". This clears out some of the noise of a
                // failed test run so we can more easily find the original failed test.
                if (ex.QueuePosition.HasValue && ex.QueuePosition >= 1)
                    Assert.Inconclusive("Cannot complete the test because a previous test has " +
                        $"blocked the Simulation Queue (current position: {ex.QueuePosition})");
                throw;
            }
        }
    }
 
    [TestClass]
    public abstract class TestSuite_APIResourceView<T> : BaseResourceTestSuite<T>
        where T : IAPIResourceView
    {
        #region Set Up and Configuration
        private const string TypeName = "IAPIResourceView";
        #endregion Set Up and Configuration
 
        private IReference<ILayerView> _layerViewComponentSingleton;
 
        public static PollingOptions SimulationPolling => TestSuite_APIResourceView.SimulationPolling;
 
        protected TestSuite_APIResourceView()
        {
            AddCommonTestCleanupAction(() => _layerViewComponentSingleton = null);
        }
 
        public override void AdditionalValidResourceTests(T posted) =>
            TestSuite_APIResourceView.TestMetricsRetrievable(posted);
 
        #region POST
        #region analysis_profile
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_IAPIResourceView_POST_AnalysisProfile_Null()
        {
            POST_Attribute_Null(l => l.analysis_profile);
        }
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_IAPIResourceView_POST_AnalysisProfile_Reference_NullId()
        {
            POST_Reference_NullId(l => l.analysis_profile);
        }
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_IAPIResourceView_POST_AnalysisProfile_Reference_EmptyStringId()
        {
            POST_Reference_EmptyStringId(l => l.analysis_profile);
        }
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_IAPIResourceView_POST_AnalysisProfile_Reference_NonExistantId()
        {
            POST_Reference_NonExistantId(l => l.analysis_profile);
        }
        #endregion analysis_profile
 
        #region target_currency
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_IAPIResourceView_POST_TargetCurrency_Null()
        {
            POST_Attribute_Null(l => l.target_currency);
        }
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_IAPIResourceView_POST_TargetCurrency_ValidISO()
        {
            POST_WithValue(l => l.target_currency, "EUR", true);
        }
        #endregion target_currency
        #endregion POST
 
        #region Metrics
        #region Helper Methods
        protected void Test_IAPIResourceView_Action_Succeeds(Action<T> action)
        {
            POST_ThenDoAction(TestResource, action);
        }
        protected void Test_IAPIResourceView_Action_Fails<TException>(Action<T> action,
            Action<TException> exceptionTest) where TException : Exception
        {
            POST_ThenDoAction(TestResource, posted =>
                AssertApi.ExceptionThrown(() => action(posted), exceptionTest));
        }
 
        public static void Test_IAPIResourceView_Metrics_MixedLossTypes(T posted,
            Perspective leastGranularPerspective = null)
        {
            // TODO: Compute the least granular perspective by looking at all loss sets?
            if (leastGranularPerspective == null)
                leastGranularPerspective = Perspective.LossGross;
            // After the successful post, it should always be possible to get metrics
            // for NetLoss perspective, but not necessarily other perspectives.
            Test_Metrics_Perspective(posted, Perspective.NetLoss, true);
            Test_Metrics_Perspective(posted, Perspective.LossGross,
                leastGranularPerspective.Equals(Perspective.LossGross));
        }
 
        private static void Test_Metrics_Perspective(T posted, Perspective perspective,
            bool shouldSucceed)
        {
            try
            {
                SimulationOptions setPerspective = new SimulationOptions(perspective);
                posted.tail_metrics_blocking(1, new MetricsOptions(setPerspective), SimulationPolling);
                posted.exceedance_probability_blocking(1,
                    new ExceedanceProbabilityOptions(setPerspective), SimulationPolling);
                if (!shouldSucceed)
                {
                    Assert.Fail("Metrics for perspective " + perspective +
                                " succeeded, when an error was expected.");
                }
            }
            catch (APIRequestException ex)
            {
                if (shouldSucceed)
                {
                    Assert.Fail("Metrics for perspective " + perspective + " failed, when " +
                                "it was expected to succeed: " + ex.ServerError.message);
                }
                else
                    Assert.AreEqual(HttpStatusCode.BadRequest, ex.RestResponse.StatusCode);
            }
        }
 
        public static Action<ArgumentOutOfRangeException> ProbabilityError(double min, double max)
        {
            string expectedMessage = min < 0 || min >= 1 ? "The min probability must be " +
                (min < 0 ? "greater than or equal to zero." : "less than one.") + " The range is [0,1)" :
                max <= 0 || max > 1 ? "The max probability must be " +
                (max <= 0 ? "greater than zero." : "less than or equal to one.") + " The range is (0,1]" :
                "The max probability must be greater or equal to than the min probability.";
            return ex => Assert.IsTrue(ex.Message.StartsWith(expectedMessage),
                "Expected an ArgumentOutOfRangeException with an error message starting with:\n" +
                $"{expectedMessage}\n{ex.Message}\n^ This was the actual message. " +
                $"Full Exception Details:\n{ex}");
        }
        #endregion Helper Methods
 
        #region TailMetrics
        #region Helper Methods
        private void Test_IAPIResourceView_GET_TailMetrics_Succeeds(
            double probability, MetricsOptions options = null)
        {
            Test_IAPIResourceView_Action_Succeeds(
                arg => GetTailMetricsAction(probability, options)(arg));
        }
 
        private void Test_IAPIResourceView_GET_TailMetrics_Fails<TException>(
            Action<TException> exceptionTest, double probability, MetricsOptions options = null)
            where TException : Exception
        {
            Test_IAPIResourceView_Action_Fails(
                arg => GetTailMetricsAction(probability, options)(arg), exceptionTest);
        }
 
        private static Func<T, TailMetrics> GetTailMetricsAction(
            double probability, MetricsOptions options = null)
        {
            return view =>
            {
                TailMetrics result = view.tail_metrics_blocking(
                    probability, options, SimulationPolling);
                // Check that metrics results were filled in correctly
                AssertTailDistributionMetricsExist(result);
                // Check that tail metrics context properties were filled in appropriately
                RunTailMetricsContextAssertions(view, probability, options, result.context);
                return result;
            };
        }
 
        private static void AssertTailDistributionMetricsExist(TailDistributionMetrics result)
        {
            Assert.IsNotNull(result);
            Assert.AreNotEqual(Double.NaN, result.min, "min was not assigned a value.");
            Assert.AreNotEqual(Double.NaN, result.mean, "mean was not assigned a value.");
            Assert.AreNotEqual(Double.NaN, result.max, "max was not assigned a value.");
            Assert.AreNotEqual(Double.NaN, result.variance, "variance was not assigned a value.");
            Assert.AreNotEqual(Double.NaN, result.skewness, "skewness was not assigned a value.");
            Assert.AreNotEqual(Double.NaN, result.kurtosis, "kurtosis was not assigned a value.");
        }
 
        private static void RunTailMetricsContextAssertions(
            T view, double probability, MetricsOptions options, TailMetrics.Context context)
        {
            // If no options were supplied, compare result context to a default set of options.
            options = options ?? new MetricsOptions();
 
            // Assertions that should be met as part of any successful tail metrics result
            AssertBasicOptionsMatchContext(view, options, context);
            AssertApi.DoublesAreEqual(probability, context.probability);
            Assert.AreEqual(options.currency ?? view.target_currency, context.currency);
 
            // If this is a PortfolioView, participation is always applied regardless of
            // the request parameter.
            if (view is PortfolioView)
                Assert.IsTrue(context.apply_participation);
            // If this is a LayerView, apply_participation defaults to false if not supplied.
            else
                Assert.AreEqual(options.apply_participation ?? false, context.apply_participation);
        }
 
        private static void AssertBasicOptionsMatchContext(T view, AggregationOptions options, Context context)
        {
            // If no options were supplied, compare result context to a default set of options.
            options = options ?? new AggregationOptions();
 
            // If filter was not set, we expect it to come back as the AnyFilter from the
            // analysis profile associated with the view.
            string expectedFilter = options.filter ?? TestSuite_AnalysisProfile_Base.GetDefaultFilterNameForAnalysisProfile(view.analysis_profile);
            Assert.AreEqual(expectedFilter, context.filter);
 
            // If perspective was not set, we expect it to come back as the current
            // analysis profile's default perspective
            Perspective expectedPerspective = options.perspective ?? TestSuite_Perspective.GetDefaultPerspectiveForAnalysisProfile(view.analysis_profile);
            Assert.AreEqual(expectedPerspective, context.perspective);
 
            // If aggregation method was not set, we expect it to come back as AEP
            Assert.AreEqual(options.aggregation_method ?? AggregationMethod.AEP,
                context.aggregation_method);
 
            // If secondary uncertainty was not set, we expect it to come back as TRUE
            Assert.AreEqual(options.secondary_uncertainty ?? true, context.secondary_uncertainty);
 
            // Check that reporting period matches within tolerance (if set)
            AssertApi.DatesAreEqual(options.reporting_period?.begin, context.reporting_period_begin);
            AssertApi.DatesAreEqual(options.reporting_period?.end, context.reporting_period_end);
        }
        #endregion Helper Methods
 
        #region Test Methods
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_IAPIResourceView_GET_TailMetrics_Probability_ValidValues()
        {
            Test_IAPIResourceView_GET_TailMetrics_Succeeds(1);
            Test_IAPIResourceView_GET_TailMetrics_Succeeds(0.01);
            // Test a high precision value survives the round trip.
            Test_IAPIResourceView_GET_TailMetrics_Succeeds(Math.PI / 4d);
            // Test a very small probability maintains precision
            Test_IAPIResourceView_GET_TailMetrics_Succeeds(1.234556789E-12);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_IAPIResourceView_GET_TailMetrics_Probability_InvalidValues()
        {
            void TestBadProbability(double probability) =>
                // Test that the appropriate client-side validation occurs
                Test_IAPIResourceView_GET_TailMetrics_Fails(ProbabilityError(0, probability), probability);
 
            TestBadProbability(0);
            TestBadProbability(1.00000000000001);
            TestBadProbability(2);
            TestBadProbability(-0.5);
            TestBadProbability(Double.MinValue);
            TestBadProbability(Double.MaxValue);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_IAPIResourceView_GET_TailMetrics_Filter_Existing()
        {
            Test_IAPIResourceView_Action_Succeeds(delegate (T view)
            {
                List<IReference<LossFilter>> availableFilters =
                    Reflection.Resolve(view.analysis_profile).loss_filters;
                foreach (IReference<LossFilter> lf in availableFilters)
                    GetTailMetricsAction(1, new MetricsOptions(filter: Reflection.Resolve(lf).name))(view);
            });
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_IAPIResourceView_GET_TailMetrics_Filter_NonExistant()
        {
            Test_IAPIResourceView_GET_TailMetrics_Fails(
                AssertApi.ApiExceptionTest(HttpStatusCode.BadRequest),
                1, new MetricsOptions(filter: "NonExistant"));
        }
 
        #region Test Perspectives
        private void TestGetTailMetricsForPerspective(T view, Perspective persp) =>
            AssertApi.MethodIsAllowed(() => GetTailMetricsAction(1, new MetricsOptions(perspective: persp))(view),
                $"Get TailMetrics for perspective {persp}");
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_IAPIResourceView_GET_TailMetrics_Perspective_Main()
        {
            Test_IAPIResourceView_Action_Succeeds(view => TestSuite_Perspective.TestPerspectives.ToList().ForEach(perspective =>
                    TestGetTailMetricsForPerspective(view, perspective)));
        }
 
        [TestMethod, TestCategory(TypeName)]
        [Obsolete("Tests an obsolete factory method for constructing legacy perspectives")]
        public virtual void Test_IAPIResourceView_GET_TailMetrics_Perspective_LossNetOfAggregateTermsAnd()
        {
            Test_IAPIResourceView_Action_Succeeds(view => TestSuite_Perspective.LegacyTestPerspectives.ToList().ForEach(perspective =>
                    TestGetTailMetricsForPerspective(view, perspective)));
        }
        #endregion Test Perspectives
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_IAPIResourceView_GET_TailMetrics_Currency()
        {
            Test_IAPIResourceView_GET_TailMetrics_Succeeds(1, new MetricsOptions("GBP"));
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_IAPIResourceView_GET_TailMetrics_CurrencyUnavailable()
        {
            Test_IAPIResourceView_GET_TailMetrics_Fails(
                AssertApi.ApiExceptionTest(HttpStatusCode.BadRequest),
                1, new MetricsOptions("ALL"));
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_IAPIResourceView_GET_TailMetrics_OEP()
        {
            Test_IAPIResourceView_GET_TailMetrics_Succeeds(0.95d,
                new MetricsOptions(aggregation_method: AggregationMethod.OEP));
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_IAPIResourceView_GET_TailMetrics_SecondaryUncertainty()
        {
            Test_IAPIResourceView_GET_TailMetrics_Succeeds(1 / 3d,
                new MetricsOptions(secondary_uncertainty: true));
 
            Test_IAPIResourceView_GET_TailMetrics_Succeeds(1 / 3d,
                new MetricsOptions(secondary_uncertainty: false));
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_IAPIResourceView_GET_TailMetrics_ReportingPeriod()
        {
            Test_IAPIResourceView_GET_TailMetrics_Succeeds(1 / 3d, new MetricsOptions(
                reporting_period: new ReportingPeriod(DateTime.UtcNow, DateTime.UtcNow.AddYears(1))));
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_IAPIResourceView_GET_TailMetrics_ApplyParticipation()
        {
            Test_IAPIResourceView_GET_TailMetrics_Succeeds(1 / 3d,
                new MetricsOptions(apply_participation: true));
 
            Test_IAPIResourceView_GET_TailMetrics_Succeeds(1 / 3d,
                new MetricsOptions(apply_participation: false));
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_IAPIResourceView_GET_ExpectedLoss()
        {
            Test_IAPIResourceView_Action_Succeeds(delegate (T view)
            {
                double expectedLoss = API.PollUntilReady(
                    () => view.GetSubResource<double>(@"el"), SimulationPolling);
                TailMetrics metrics = view.tail_metrics_blocking(1,
                    MetricsOptions.Default, SimulationPolling);
                AssertApi.DoublesAreEqual(expectedLoss, metrics.mean);
            });
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_IAPIResourceView_GET_Tvar()
        {
            Test_IAPIResourceView_Action_Succeeds(delegate (T view)
            {
                double tvar = API.PollUntilReady(
                    () => view.GetSubResource<double>(@"tvar/0.5"), SimulationPolling);
                TailMetrics metrics = view.tail_metrics_blocking(0.5,
                    MetricsOptions.Default, SimulationPolling);
                AssertApi.DoublesAreEqual(tvar, metrics.mean);
            });
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_IAPIResourceView_GET_TailMetrics_Vectorized()
        {
            POST_ThenDoAction(TestResource, view =>
            {
                List<TailMetrics> result = view.tail_metrics_blocking(
                    new List<double> { 0.1, 1, 0.5, 0.25 },
                    MetricsOptions.Default, SimulationPolling);
 
                // Assertions that should be met as part of any successful tail metrics result
                Assert.AreEqual(4, result.Count, "Expected 4 TailMetrics responses");
                // TODO: Guarantee order once ARE-3264 is complete
                /*
                AssertApi.DoublesAreEqual(1, result.First().context.probability);
                AssertApi.DoublesAreEqual(0.5, result.Skip(1).First().context.probability);
                AssertApi.DoublesAreEqual(0.25, result.Skip(2).First().context.probability);
                AssertApi.DoublesAreEqual(0.1, result.Skip(3).First().context.probability);
                */
            });
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_IAPIResourceView_GET_TailMetrics_Vectorized_ListOfOne()
        {
            // Check that even though the server will return a non array response,
            // we can still handle it and put it into the expected list response.
            POST_ThenDoAction(TestResource, view =>
            {
                List<TailMetrics> result = view.tail_metrics_blocking(
                    new List<double> { 0.1 }, MetricsOptions.Default, SimulationPolling);
 
                Assert.AreEqual(1, result.Count, "Expected 1 TailMetrics response in a list");
                AssertApi.DoublesAreEqual(0.1, result.First().context.probability);
            });
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_IAPIResourceView_GET_TailMetrics_Overloads()
        {
            // Test the ability to invoke all overloads and extension methods that "route"
            // to tail_metrics, including any type conversions or inferences meant to be supported.
            Test_IAPIResourceView_Action_Succeeds(arg =>
            {
                MetricsOptions options = MetricsOptions.Default;
                arg.tail_metrics_blocking(1, options);
                arg.tail_metrics_blocking(0.5, options);
                arg.tail_metrics_blocking(new[] { 1d }, options);
                arg.tail_metrics_blocking(new List<double> { 1, 0.5, 0.25 }, options);
                arg.tail_metrics_blocking(new HashSet<double> { 1, 0.5, 0.25 }, options);
                arg.tail_metrics_blocking(Enumerable.Range(1, 10).Select(i => 1d / i), options);
                arg.tail_metrics(1, options);
                arg.tail_metrics(0.5, options);
                arg.tail_metrics(new[] { 1d }, options);
                arg.tail_metrics(new List<double> { 1, 0.5, 0.25 }, options);
                arg.tail_metrics(new HashSet<double> { 1, 0.5, 0.25 }, options);
                arg.tail_metrics(Enumerable.Range(1, 10).Select(i => 1d / i), options);
                arg.expected_loss(options);
                arg.var(0.5, options);
                arg.tvar(0.5, options);
            });
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_IAPIResourceView_GET_Tail_Metrics_API_Endpoint()
        {
            // ARE-7344 /tail_metrics/ can be used to get tail metrics using the API.RequestAndParse method, which
            // then should be successfully casted to the TailMetrics object
            Test_IAPIResourceView_Action_Succeeds(delegate (T view)
            {
                Double probability = 0.25;
                TailMetrics regular_metrics = view.tail_metrics_blocking(probability,
                    MetricsOptions.Default, SimulationPolling);
                TailMetrics endpoint_metrics = API.RequestAndParse<TailMetrics>(
                    $"/{view.collection_name}/{view.id}/tail_metrics/{probability}",
                    Method.GET, MetricsOptions.Default.GetParameters());
                Assert.AreEqual(regular_metrics.context.probability, endpoint_metrics.context.probability);
                Assert.AreEqual(regular_metrics.context.max_probability, endpoint_metrics.context.max_probability);
                Assert.AreEqual(regular_metrics.context.min_probability, endpoint_metrics.context.min_probability);
                Assert.AreEqual(regular_metrics.mean, endpoint_metrics.mean);
                Assert.AreEqual(regular_metrics.variance, endpoint_metrics.variance);
                Assert.AreEqual(regular_metrics.skewness, endpoint_metrics.skewness);
                Assert.AreEqual(regular_metrics.kurtosis, endpoint_metrics.kurtosis);
            });
        }
        #endregion Test Methods
        #endregion TailMetrics
 
        #region WindowMetrics
        #region Helper Methods
        private void Test_IAPIResourceView_GET_WindowMetrics_Succeeds(
            ProbabilityWindow range, MetricsOptions options = null)
        {
            Test_IAPIResourceView_Action_Succeeds(
                arg => GetWindowMetricsAction(range, options)(arg));
        }
 
        private void Test_IAPIResourceView_GET_WindowMetrics_Fails<TException>(
            Action<TException> exceptionTest, ProbabilityWindow range, MetricsOptions options = null)
            where TException : Exception
        {
            Test_IAPIResourceView_Action_Fails(
                arg => GetWindowMetricsAction(range, options)(arg), exceptionTest);
        }
 
        private static Func<T, WindowMetrics> GetWindowMetricsAction(
            ProbabilityWindow range, MetricsOptions options = null)
        {
            return view =>
            {
                WindowMetrics result = view.window_metrics_blocking(
                    range, options, SimulationPolling);
                // Check that metrics results were filled in correctly
                AssertTailDistributionMetricsExist(result);
                // Check that tail metrics context properties were filled in appropriately
                RunWindowMetricsContextAssertions(view, range, options, result.context);
                return result;
            };
        }
 
        private static void RunWindowMetricsContextAssertions(
            T view, ProbabilityWindow range, MetricsOptions options, WindowMetrics.Context context)
        {
            // If no options were supplied, compare result context to a default set of options.
            options = options ?? new MetricsOptions();
 
            // Assertions that should be met as part of any successful tail metrics result
            AssertBasicOptionsMatchContext(view, options, context);
            AssertApi.DoublesAreEqual(range.min_probability, context.min_probability);
            AssertApi.DoublesAreEqual(range.max_probability, context.max_probability);
            Assert.AreEqual(options.currency ?? view.target_currency, context.currency);
 
            // If this is a PortfolioView, participation is always applied regardless of
            // the request parameter.
            if (view is PortfolioView)
                Assert.IsTrue(context.apply_participation);
            // If this is a LayerView, apply_participation defaults to false if not supplied.
            else
                Assert.AreEqual(options.apply_participation ?? false, context.apply_participation);
        }
        #endregion Helper Methods
 
        #region Test Methods
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_IAPIResourceView_GET_WindowMetrics_Probability_ValidValues()
        {
            Test_IAPIResourceView_GET_WindowMetrics_Succeeds(ProbabilityWindow.All);
            Test_IAPIResourceView_GET_WindowMetrics_Succeeds(new ProbabilityWindow(0.01, 1));
            // Test a high precision value survives the round trip.
            Test_IAPIResourceView_GET_WindowMetrics_Succeeds(new ProbabilityWindow(Math.PI / 10d, Math.PI / 4d));
            // Test a very small probability maintains precision
            Test_IAPIResourceView_GET_WindowMetrics_Succeeds(ProbabilityWindow.Tail(1.234556789E-12));
            Test_IAPIResourceView_GET_WindowMetrics_Succeeds(new ProbabilityWindow(0, 1.234556789E-12));
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_IAPIResourceView_GET_WindowMetrics_ProbabilityWindow_InvalidValues()
        {
            void TestBadProbability(double min, double max)
            {
                // Test that the appropriate client-side validation occurs when creating this probability range:
                AssertApi.ExceptionThrown(() => _ = new ProbabilityWindow(min, max), ProbabilityError(min, max));
                // Circumvent client-side validation and assert that the server returns an error:
                Test_IAPIResourceView_Action_Fails(
                    arg => arg.GetSubResource<WindowMetrics>($"window_metrics/{min}_{max}/"),
                    AssertApi.ApiExceptionTest(HttpStatusCode.BadRequest));
            }
 
            TestBadProbability(0, 0);
            TestBadProbability(1, 1);
            TestBadProbability(0, 1.00000000000001);
            TestBadProbability(0, 2);
            TestBadProbability(-.1, 0);
            TestBadProbability(0, Double.MaxValue);
            TestBadProbability(Double.MinValue, 0);
            TestBadProbability(0, Double.MinValue);
            TestBadProbability(Double.MaxValue, 0);
            TestBadProbability(.5, .4);
            TestBadProbability(1, 0);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_IAPIResourceView_GET_WindowMetrics_Filter_Existing()
        {
            Test_IAPIResourceView_Action_Succeeds(delegate (T view)
            {
                List<IReference<LossFilter>> availableFilters =
                    Reflection.Resolve(view.analysis_profile).loss_filters;
                foreach (IReference<LossFilter> lf in availableFilters)
                    GetWindowMetricsAction(ProbabilityWindow.All,
                        new MetricsOptions(filter: Reflection.Resolve(lf).name))(view);
            });
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_IAPIResourceView_GET_WindowMetrics_Filter_NonExistant()
        {
            Test_IAPIResourceView_GET_WindowMetrics_Fails(
                AssertApi.ApiExceptionTest(HttpStatusCode.BadRequest),
                ProbabilityWindow.All, new MetricsOptions(filter: "NonExistant"));
        }
 
        #region Test Perspectives
        private void TestGetWindowMetricsForPerspective(T view, Perspective persp) =>
            AssertApi.MethodIsAllowed(() => GetWindowMetricsAction(ProbabilityWindow.All,
                new MetricsOptions(perspective: persp))(view), $"Get WindowMetrics for perspective {persp}");
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_IAPIResourceView_GET_WindowMetrics_Perspective_Main()
        {
            Test_IAPIResourceView_Action_Succeeds(view => TestSuite_Perspective.TestPerspectives.ToList().ForEach(perspective =>
                    TestGetWindowMetricsForPerspective(view, perspective)));
        }
 
        [TestMethod, TestCategory(TypeName)]
        [Obsolete("Tests an obsolete factory method for constructing legacy perspectives")]
        public virtual void Test_IAPIResourceView_GET_WindowMetrics_Perspective_LossNetOfAggregateTermsAnd()
        {
            Test_IAPIResourceView_Action_Succeeds(view => TestSuite_Perspective.LegacyTestPerspectives.ToList().ForEach(perspective =>
                    TestGetWindowMetricsForPerspective(view, perspective)));
        }
        #endregion Test Perspectives
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_IAPIResourceView_GET_WindowMetrics_Currency()
        {
            Test_IAPIResourceView_GET_WindowMetrics_Succeeds(ProbabilityWindow.All, new MetricsOptions("GBP"));
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_IAPIResourceView_GET_WindowMetrics_CurrencyUnavailable()
        {
            Test_IAPIResourceView_GET_WindowMetrics_Fails(
                AssertApi.ApiExceptionTest(HttpStatusCode.BadRequest),
                ProbabilityWindow.All, new MetricsOptions("ALL"));
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_IAPIResourceView_GET_WindowMetrics_OEP()
        {
            Test_IAPIResourceView_GET_WindowMetrics_Succeeds(ProbabilityWindow.Tail(0.95d),
                new MetricsOptions(aggregation_method: AggregationMethod.OEP));
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_IAPIResourceView_GET_WindowMetrics_SecondaryUncertainty()
        {
            Test_IAPIResourceView_GET_WindowMetrics_Succeeds(ProbabilityWindow.Tail(1 / 3d),
                new MetricsOptions(secondary_uncertainty: true));
 
            Test_IAPIResourceView_GET_WindowMetrics_Succeeds(ProbabilityWindow.Tail(1 / 3d),
                new MetricsOptions(secondary_uncertainty: false));
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_IAPIResourceView_GET_WindowMetrics_ReportingPeriod()
        {
            Test_IAPIResourceView_GET_WindowMetrics_Succeeds(ProbabilityWindow.Tail(1 / 3d), new MetricsOptions(
                reporting_period: new ReportingPeriod(DateTime.UtcNow, DateTime.UtcNow.AddYears(1))));
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_IAPIResourceView_GET_WindowMetrics_ApplyParticipation()
        {
            Test_IAPIResourceView_GET_WindowMetrics_Succeeds(ProbabilityWindow.Tail(1 / 3d),
                new MetricsOptions(apply_participation: true));
 
            Test_IAPIResourceView_GET_WindowMetrics_Succeeds(ProbabilityWindow.Tail(1 / 3d),
                new MetricsOptions(apply_participation: false));
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_IAPIResourceView_GET_Window_ExpectedLoss()
        {
            Test_IAPIResourceView_Action_Succeeds(delegate (T view)
            {
                double expectedLoss = API.PollUntilReady(
                    () => view.GetSubResource<double>(@"el"), SimulationPolling);
                WindowMetrics metrics = view.window_metrics_blocking(ProbabilityWindow.All,
                    MetricsOptions.Default, SimulationPolling);
                AssertApi.DoublesAreEqual(expectedLoss, metrics.mean);
            });
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_IAPIResourceView_GET_Window_Tvar()
        {
            Test_IAPIResourceView_Action_Succeeds(delegate (T view)
            {
                double tvar = API.PollUntilReady(
                    () => view.GetSubResource<double>(@"tvar/0.5"), SimulationPolling);
                WindowMetrics metrics = view.window_metrics_blocking(ProbabilityWindow.Tail(0.5),
                    MetricsOptions.Default, SimulationPolling);
                AssertApi.DoublesAreEqual(tvar, metrics.mean);
            });
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_IAPIResourceView_GET_WindowMetrics_Vectorized()
        {
            POST_ThenDoAction(TestResource, view =>
            {
                List<WindowMetrics> result = view.window_metrics_blocking(
                    new List<ProbabilityWindow> {
                        ProbabilityWindow.Tail(0.1),
                        ProbabilityWindow.All,
                        ProbabilityWindow.Tail(0.5),
                        ProbabilityWindow.Tail(0.25),
                    },
                    MetricsOptions.Default, SimulationPolling);
 
                // Assertions that should be met as part of any successful tail metrics result
                Assert.AreEqual(4, result.Count, "Expected 4 WindowMetrics responses");
                // TODO: Guarantee order once ARE-3264 is complete
            });
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_IAPIResourceView_GET_WindowMetrics_Vectorized_ListOfOne()
        {
            // Check that even though the server will return a non array response,
            // we can still handle it and put it into the expected list response.
            POST_ThenDoAction(TestResource, view =>
            {
                List<WindowMetrics> result = view.window_metrics_blocking(
                    new List<ProbabilityWindow> { ProbabilityWindow.Tail(0.1) },
                    MetricsOptions.Default, SimulationPolling);
 
                Assert.AreEqual(1, result.Count, "Expected 1 WindowMetrics response in a list");
                AssertApi.DoublesAreEqual(0, result.First().context.min_probability);
                AssertApi.DoublesAreEqual(0.1, result.First().context.max_probability);
            });
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_IAPIResourceView_GET_WindowMetrics_Overloads()
        {
            // Test the ability to invoke all overloads and extension methods of window_metrics,
            // including any type conversions or inferences meant to be supported.
            Test_IAPIResourceView_Action_Succeeds(arg =>
            {
                MetricsOptions options = MetricsOptions.Default;
                arg.window_metrics_blocking(new[] { ProbabilityWindow.All }, options);
                arg.window_metrics_blocking(new List<ProbabilityWindow> { ProbabilityWindow.All,
                    ProbabilityWindow.Tail(0.5), new ProbabilityWindow(0.25, 0.75) }, options);
                arg.window_metrics_blocking(new HashSet<ProbabilityWindow> { ProbabilityWindow.All,
                    ProbabilityWindow.Tail(0.5), new ProbabilityWindow(0.25, 0.75) }, options);
                arg.window_metrics_blocking(Enumerable.Range(1, 10).Select(i => ProbabilityWindow.Tail(1d / i)), options);
                arg.window_metrics(new[] { ProbabilityWindow.All }, options);
                arg.window_metrics(new List<ProbabilityWindow> { ProbabilityWindow.All,
                    ProbabilityWindow.Tail(0.5), new ProbabilityWindow(0.25, 0.75) }, options);
                arg.window_metrics(new HashSet<ProbabilityWindow> { ProbabilityWindow.All,
                    ProbabilityWindow.Tail(0.5), new ProbabilityWindow(0.25, 0.75) }, options);
                arg.window_metrics(Enumerable.Range(1, 10).Select(i => ProbabilityWindow.Tail(1d / i)), options);
            });
        }
 
        [TestMethod, TestCategory(TypeName)]
        [Obsolete("Tests an obsolete method for backwards compatibility.")]
        public virtual void Test_IAPIResourceView_GET_WindowMetrics_Legacy_Overloads()
        {
            // Test the ability to invoke all obsolete overloads and extension methods of
            // window_metrics, including any type conversions or inferences meant to be supported.
            Test_IAPIResourceView_Action_Succeeds(arg =>
            {
                MetricsOptions options = MetricsOptions.Default;
                arg.window_metrics_blocking(1, options);
                arg.window_metrics_blocking(0.5, options);
                arg.window_metrics(1, options);
                arg.window_metrics(0.5, options);
            });
        }
        #endregion Test Methods
        #endregion WindowMetrics
 
        #region ExceedanceProbability
        #region Helper Methods
        protected void Test_IAPIResourceView_GET_ExceedanceProbability_Succeeds(
            double threshold, ExceedanceProbabilityOptions options = null)
        {
            Test_IAPIResourceView_Action_Succeeds(
                arg => GetExceedanceProbabilityAction(threshold, options)(arg));
        }
 
        private void Test_IAPIResourceView_GET_ExceedanceProbability_Fails<TException>(
            Action<TException> exceptionTest, double threshold, ExceedanceProbabilityOptions options)
            where TException : Exception
        {
            Test_IAPIResourceView_Action_Fails(
                arg => GetExceedanceProbabilityAction(threshold, options)(arg), exceptionTest);
        }
 
        private static Func<T, ExceedanceProbability> GetExceedanceProbabilityAction(
            double threshold, ExceedanceProbabilityOptions options)
        {
            return view =>
            {
                ExceedanceProbability result = view.exceedance_probability_blocking(
                    threshold, options, SimulationPolling);
                // Check that the probability was set
                Assert.AreNotEqual(Double.NaN, result.probability, "probability was not assigned a value.");
                // Check that exceedance probability context properties are filled in appropriately
                RunExceedanceProbContextAssertions(view, threshold, options, result.context);
                return result;
            };
        }
 
        private static void RunExceedanceProbContextAssertions(
            T view, double threshold, ExceedanceProbabilityOptions options,
            ExceedanceProbability.Context context)
        {
            // If no options were supplied, compare result context to a default set of options.
            options = options ?? new ExceedanceProbabilityOptions();
 
            // Assertions that should be met as part of any successful exceedance probabilities result
            AssertBasicOptionsMatchContext(view, options, context);
            AssertApi.DoublesAreEqual(threshold, context.threshold);
            Assert.AreEqual(options.inclusive_threshold ?? false, context.inclusive_threshold);
            Assert.AreEqual(options.threshold_currency ?? view.target_currency, context.threshold_currency);
 
            // If this is a PortfolioView, participation is always applied regardless of
            // the request parameter.
            if (view is PortfolioView)
                Assert.IsTrue(context.threshold_includes_participation);
            // If this is a LayerView, apply_participation defaults to false if not supplied.
            else
                Assert.AreEqual(options.threshold_includes_participation ?? false,
                    context.threshold_includes_participation);
        }
        #endregion Helper Methods
 
        #region Test Methods
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_IAPIResourceView_GET_ExceedanceProbability_Threshold_ValidValues()
        {
            Test_IAPIResourceView_GET_ExceedanceProbability_Succeeds(0);
            Test_IAPIResourceView_GET_ExceedanceProbability_Succeeds(1000000);
            Test_IAPIResourceView_GET_ExceedanceProbability_Succeeds(-100);
            Test_IAPIResourceView_GET_ExceedanceProbability_Succeeds(Math.PI * 1e-100d);
            Test_IAPIResourceView_GET_ExceedanceProbability_Succeeds(Math.PI * 1e100d);
            Test_IAPIResourceView_GET_ExceedanceProbability_Succeeds(Int32.MinValue);
            Test_IAPIResourceView_GET_ExceedanceProbability_Succeeds(Int32.MaxValue);
            // In theory, Double.Min to Double.Max are supported, but the string representation
            // of these numbers is necessarily limited and rounds to invalid doubles,
            // so to illustrate getting very close to these boundaries, use 99% of min and max
            Test_IAPIResourceView_GET_ExceedanceProbability_Succeeds(Double.MinValue * 0.99);
            Test_IAPIResourceView_GET_ExceedanceProbability_Succeeds(Double.MaxValue * 0.99);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_IAPIResourceView_GET_ExceedanceProbability_Filter_Existing()
        {
            Test_IAPIResourceView_Action_Succeeds(delegate (T view)
            {
                List<IReference<LossFilter>> availableFilters =
                    Reflection.Resolve(view.analysis_profile).loss_filters;
                ExceedanceProbabilityOptions options = new ExceedanceProbabilityOptions();
                foreach (IReference<LossFilter> lf in availableFilters)
                    GetExceedanceProbabilityAction(0, options.Change(o => o.filter,
                        Reflection.Resolve(lf).name))(view);
            });
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_IAPIResourceView_GET_ExceedanceProbability_Filter_NonExistant()
        {
            Test_IAPIResourceView_GET_ExceedanceProbability_Fails(
                AssertApi.ApiExceptionTest(HttpStatusCode.BadRequest),
                1, new ExceedanceProbabilityOptions(filter: "NonExistant"));
        }
 
        #region Test Perspectives
        private void TestGetExceedanceProbabilityForPerspective(T view, Perspective persp) =>
            AssertApi.MethodIsAllowed(() => GetExceedanceProbabilityAction(0,
                    new ExceedanceProbabilityOptions(perspective: persp))(view),
                $"Get ExceedanceProbability for perspective {persp}");
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_IAPIResourceView_GET_ExceedanceProbability_Perspective_Main()
        {
            Test_IAPIResourceView_Action_Succeeds(view => TestSuite_Perspective.TestPerspectives.ToList().ForEach(perspective =>
                    TestGetExceedanceProbabilityForPerspective(view, perspective)));
        }
 
        [TestMethod, TestCategory(TypeName)]
        [Obsolete("Tests an obsolete factory method for constructing legacy perspectives")]
        public virtual void Test_IAPIResourceView_GET_ExceedanceProbability_Perspective_LossNetOfAggregateTermsAnd()
        {
            Test_IAPIResourceView_Action_Succeeds(view => TestSuite_Perspective.LegacyTestPerspectives.ToList().ForEach(perspective =>
                    TestGetExceedanceProbabilityForPerspective(view, perspective)));
        }
        #endregion Test Perspectives
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_IAPIResourceView_GET_ExceedanceProbability_Inclusive()
        {
            Test_IAPIResourceView_Action_Succeeds(delegate (T view)
            {
                ExceedanceProbabilityOptions exclusiveOptions = ExceedanceProbabilityOptions.Default
                    .Change(o => o.inclusive_threshold, false);
                double exclusive = GetExceedanceProbabilityAction(0, exclusiveOptions)(view).probability;
 
                ExceedanceProbabilityOptions inclusiveOptions = ExceedanceProbabilityOptions.Default
                    .Change(o => o.inclusive_threshold, true);
                double inclusive = GetExceedanceProbabilityAction(0, inclusiveOptions)(view).probability;
                Console.WriteLine("Exceedance Probability for a threshold of 0 - " +
                    $"Inclusive: {exclusive:P2} Exclusive: {inclusive:P2}");
 
                // Get the largest trial loss for this view. We should be able to test
                // that results when including and excluding it are different
                double max = view.tail_metrics_blocking(1.0, MetricsOptions.Default).max;
                exclusive = GetExceedanceProbabilityAction(max, exclusiveOptions)(view).probability;
                Assert.AreEqual(0, exclusive, "Expected the exclusive exceedance probability " +
                    $"of {max} to be 0%, because it is the largest loss (nothing exceeds it).");
 
                // Verify that the inclusive probability is different.
                inclusive = GetExceedanceProbabilityAction(max, inclusiveOptions)(view).probability;
                Console.WriteLine($"Exceedance Probability for a threshold of {max} - " +
                    $"Inclusive: {exclusive:P2} Exclusive: {inclusive:P2}");
                Assert.AreNotEqual(exclusive, inclusive, "Expected the inclusive and " +
                    "exclusive exceedance probabilities to be different.");
 
                // Check that by default, the value returned is exclusive.
                ExceedanceProbabilityOptions defaultOptions = ExceedanceProbabilityOptions.Default;
                double defaultV = GetExceedanceProbabilityAction(max, defaultOptions)(view).probability;
                Assert.AreEqual(defaultV, exclusive,
                    "Expected the default result to match the result of " +
                    "explicitly excluding the threshold for the exceedance probability.");
            });
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_IAPIResourceView_GET_ExceedanceProbability_ThresholdCurrency()
        {
            Test_IAPIResourceView_GET_ExceedanceProbability_Succeeds(1,
                new ExceedanceProbabilityOptions(threshold_currency: "GBP"));
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_IAPIResourceView_GET_ExceedanceProbability_ThresholdCurrencyInvalid()
        {
            Test_IAPIResourceView_GET_ExceedanceProbability_Fails(
                AssertApi.ApiExceptionTest(HttpStatusCode.BadRequest), 1,
                new ExceedanceProbabilityOptions(threshold_currency: "ALL"));
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_IAPIResourceView_GET_ExceedanceProbability_OEP()
        {
            Test_IAPIResourceView_GET_ExceedanceProbability_Succeeds(1,
                new ExceedanceProbabilityOptions(aggregation_method: AggregationMethod.OEP));
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_IAPIResourceView_GET_ExceedanceProbability_SecondaryUncertainty()
        {
            Test_IAPIResourceView_GET_ExceedanceProbability_Succeeds(1,
                new ExceedanceProbabilityOptions(secondary_uncertainty: true));
 
            Test_IAPIResourceView_GET_ExceedanceProbability_Succeeds(1,
                new ExceedanceProbabilityOptions(secondary_uncertainty: false));
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_IAPIResourceView_GET_ExceedanceProbability_ReportingPeriod()
        {
            Test_IAPIResourceView_GET_ExceedanceProbability_Succeeds(1, new ExceedanceProbabilityOptions(
                reporting_period: new ReportingPeriod(DateTime.UtcNow, DateTime.UtcNow.AddYears(1))));
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_IAPIResourceView_GET_ExceedanceProbability_ParticipationThreshold()
        {
            Test_IAPIResourceView_GET_ExceedanceProbability_Succeeds(1,
                new ExceedanceProbabilityOptions(threshold_includes_participation: true));
 
            Test_IAPIResourceView_GET_ExceedanceProbability_Succeeds(1,
                new ExceedanceProbabilityOptions(threshold_includes_participation: false));
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_IAPIResourceView_GET_ExceedanceProbability_Vectorized()
        {
            POST_ThenDoAction(TestResource, view =>
            {
                List<ExceedanceProbability> result = view.exceedance_probability_blocking(
                    new List<double> { 10000, 0, 100, 1000 },
                    ExceedanceProbabilityOptions.Default, SimulationPolling);
 
                // Assertions that should be met as part of any successful tail metrics result
                Assert.AreEqual(4, result.Count, "Expected 4 TailMetrics responses");
                // TODO: Guarantee order once ARE-3264 is complete
                /*
                AssertApi.DoublesAreEqual(0, result.First().context.threshold);
                AssertApi.DoublesAreEqual(100, result.Skip(1).First().context.threshold);
                AssertApi.DoublesAreEqual(1000, result.Skip(2).First().context.threshold);
                AssertApi.DoublesAreEqual(10000, result.Skip(3).First().context.threshold);
                */
            });
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_IAPIResourceView_GET_ExceedanceProbability_Overloads()
        {
            // Test the ability to invoke all overloads and extension methods of window_metrics,
            // including any type conversions or inferences meant to be supported.
            Test_IAPIResourceView_Action_Succeeds(arg =>
            {
                ExceedanceProbabilityOptions options = ExceedanceProbabilityOptions.Default;
                arg.exceedance_probability_blocking(1, options);
                arg.exceedance_probability_blocking(1.23E6, options);
                arg.exceedance_probability_blocking(new[] { 1.23E6 }, options);
                arg.exceedance_probability_blocking(new List<double> { 1, 2, 3 }, options);
                arg.exceedance_probability_blocking(new HashSet<double> { 1, 0.5, 0.25 }, options);
                arg.exceedance_probability_blocking(Enumerable.Range(1, 10).Select(i => 1d / i), options);
                arg.exceedance_probability(1, options);
                arg.exceedance_probability(1.23E6, options);
                arg.exceedance_probability(new[] { 1.23E6 }, options);
                arg.exceedance_probability(new List<double> { 1, 2, 3 }, options);
                arg.exceedance_probability(new HashSet<double> { 1, 0.5, 0.25 }, options);
                arg.exceedance_probability(Enumerable.Range(1, 10).Select(i => 1d / i), options);
            });
        }
        #endregion Test Methods
        #endregion ExceedanceProbability
 
        #region CoMetrics
        #region Helper Methods
        private IReference<ILayerView> GetLayerViewComponent()
        {
            if (EnvironmentSettings.RUN_OFFLINE)
                Assert.Inconclusive("RUN_OFFLINE = true");
            if (_layerViewComponentSingleton != null)
                return _layerViewComponentSingleton;
            CatXL component = Samples.Layer_CatXL.Unposted;
            component.description = "Component Layer";
            ILayerView<CatXL> lv = LayerViews.Create(component,
                TestResource.analysis_profile).Post();
            _layerViewComponentSingleton = lv.ToReference();
            return _layerViewComponentSingleton;
        }
 
        private IReference<PortfolioView> GetPortfolioViewComponent()
        {
            if (EnvironmentSettings.RUN_OFFLINE)
                Assert.Inconclusive("RUN_OFFLINE = true");
            IReference<ILayerView> layerView = GetLayerViewComponent();
            PortfolioView pv = new PortfolioView
            {
                layer_views = new HashSet<IReference<ILayerView>> { layerView },
                analysis_profile = TestResource.analysis_profile
            };
            return pv.Post().ToReference();
        }
 
        private void Test_IAPIResourceView_GET_CoMetrics_Succeeds(ProbabilityWindow range,
            IReference<IAPIResourceView> component, CoMetricsOptions options = null,
            Action<CoMetrics> additionalAssertions = null)
        {
            Test_IAPIResourceView_Action_Succeeds(arg =>
            {
                CoMetrics response = GetCoMetricsAction(range, component, options)(arg);
                additionalAssertions?.Invoke(response);
            });
        }
 
        private void Test_IAPIResourceView_GET_CoMetrics_Fails<TException>(
            Action<TException> exceptionTest, ProbabilityWindow range,
            IReference<IAPIResourceView> component, CoMetricsOptions options = null)
            where TException : Exception
        {
            Test_IAPIResourceView_Action_Fails(
                arg => GetCoMetricsAction(range, component, options)(arg), exceptionTest);
        }
 
        private static Func<T, CoMetrics> GetCoMetricsAction(ProbabilityWindow range,
            IReference<IAPIResourceView> component, CoMetricsOptions options = null)
        {
            return view =>
            {
                CoMetrics result = view.co_metrics_blocking(
                    range, component, options, SimulationPolling);
                // Check that all co-metrics result properties are filled in.
                AssertConditionalDistributionMetricsExist(result.component_metrics);
                // Check that co-metrics context properties are filled in appropriately
                RunCoMetricsContextAssertions(view, range, component, options, result.context);
                // If the primary metrics were requested, ensure they were all filled in.
                if (options?.include_primary_metrics ?? false)
                    AssertTailDistributionMetricsExist(result.primary_metrics);
                return result;
            };
        }
 
        private static void AssertConditionalDistributionMetricsExist(ConditionalDistributionMetrics result)
        {
            Assert.IsNotNull(result);
            Assert.AreNotEqual(Double.NaN, result.min, "min was not assigned a value.");
            Assert.AreNotEqual(Double.NaN, result.mean, "mean was not assigned a value.");
            Assert.AreNotEqual(Double.NaN, result.covariance, "covariance was not assigned a value.");
            Assert.AreNotEqual(Double.NaN, result.correlation, "correlation was not assigned a value.");
        }
 
        private static void RunCoMetricsContextAssertions(
            T view, ProbabilityWindow range, IReference<IAPIResourceView> component,
            CoMetricsOptions options, CoMetrics.Context context)
        {
            // First, all of the same assertions made in the TailMetrics response should hold true
            RunWindowMetricsContextAssertions(view, range, options, context);
 
            // If no options were supplied, compare result context to a default set of options.
            options = options ?? new CoMetricsOptions();
 
            // Additional assertions that should be met as part of any successful co-metrics result
            // Component references should be equivalent.
            Assert.AreEqual(component, context.component);
            // Component filter should match,
            // or default to the primary filter if no component filter was specified,
            // or default to the Analysis Profile AnyFilter if neither was specified.
            string expectedComponentFilter = options.component_filter ?? options.filter ?? TestSuite_AnalysisProfile_Base.GetDefaultFilterNameForAnalysisProfile(view.analysis_profile);
            Assert.AreEqual(expectedComponentFilter, context.component_filter);
            // Component perspective should match,
            // or default to the primary perspective if no component filter was specified,
            // or default to LossNetOfAggregateTerms if neither was specified.
            Perspective expectedComponentPerspective = options.component_perspective ??
                options.perspective ?? TestSuite_Perspective.GetDefaultPerspectiveForAnalysisProfile(view.analysis_profile);
            Assert.AreEqual(expectedComponentPerspective, context.component_perspective);
 
            // Check that component reporting period matches within tolerance (if set),
            // or defaults to the primary reporting period if it was set.
            AssertApi.DatesAreEqual(options.component_reporting_period?.begin ??
                options.reporting_period?.begin, context.component_reporting_period_begin);
            AssertApi.DatesAreEqual(options.component_reporting_period?.end ??
                options.reporting_period?.end, context.component_reporting_period_end);
 
            Assert.AreEqual(options.include_primary_metrics ?? false,
                context.include_primary_metrics);
 
            // If this is a PortfolioView, participation is always applied regardless of
            // the request parameter.
            if (view is PortfolioView)
                Assert.IsTrue(context.apply_participation);
            // If this is a LayerView, apply_participation defaults to false if not supplied.
            else
                Assert.AreEqual(options.apply_participation ?? false, context.apply_participation);
        }
        #endregion Helper Methods
 
        #region Test Methods
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_IAPIResourceView_GET_CoMetrics_LayerView_ValidValues()
        {
            Test_IAPIResourceView_GET_CoMetrics_Succeeds(ProbabilityWindow.All, GetLayerViewComponent());
            Test_IAPIResourceView_GET_CoMetrics_Succeeds(ProbabilityWindow.Tail(0.01), GetLayerViewComponent());
            // Test a high precision value survives the round trip.
            Test_IAPIResourceView_GET_CoMetrics_Succeeds(ProbabilityWindow.Tail(Math.PI / 4d), GetLayerViewComponent());
            Test_IAPIResourceView_GET_CoMetrics_Succeeds(new ProbabilityWindow(Math.PI / 4d, 1), GetLayerViewComponent());
            // Test a very small probability maintains precision
            Test_IAPIResourceView_GET_CoMetrics_Succeeds(new ProbabilityWindow(0, 1.234556789E-12), GetLayerViewComponent());
            Test_IAPIResourceView_GET_CoMetrics_Succeeds(ProbabilityWindow.Tail(1.234556789E-12), GetLayerViewComponent());
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_IAPIResourceView_GET_CoMetrics_PortfolioView_ValidValues()
        {
            Test_IAPIResourceView_GET_CoMetrics_Succeeds(ProbabilityWindow.All, GetPortfolioViewComponent());
            Test_IAPIResourceView_GET_CoMetrics_Succeeds(new ProbabilityWindow(0, 0.01), GetLayerViewComponent());
            // Test a high precision value survives the round trip.
            Test_IAPIResourceView_GET_CoMetrics_Succeeds(new ProbabilityWindow(0, Math.PI / 4d), GetPortfolioViewComponent());
            Test_IAPIResourceView_GET_CoMetrics_Succeeds(new ProbabilityWindow(Math.PI / 4d, 1), GetPortfolioViewComponent());
            // Test a very small probability maintains precision
            Test_IAPIResourceView_GET_CoMetrics_Succeeds(new ProbabilityWindow(0, 1.234556789E-12), GetPortfolioViewComponent());
            Test_IAPIResourceView_GET_CoMetrics_Succeeds(ProbabilityWindow.Tail(1.234556789E-12), GetPortfolioViewComponent());
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_IAPIResourceView_GET_CoMetrics_ProbabilityWindow_InvalidValues()
        {
            void TestBadProbability(double min, double max)
            {
                // Test that the appropriate client-side validation occurs when creating this probability range:
                AssertApi.ExceptionThrown(() => _ = new ProbabilityWindow(min, max), ProbabilityError(min, max));
                // Circumvent client-side validation and assert that the server returns an error:
                Test_IAPIResourceView_Action_Fails(
                    arg => arg.GetSubResource<WindowMetrics>($"window_co_metrics/{min}_{max}/" +
                        $"?component_id={arg.id}&component_type=LayerView"),
                    AssertApi.ApiExceptionTest(HttpStatusCode.BadRequest));
            }
 
            TestBadProbability(0, 0);
            TestBadProbability(1, 1);
            TestBadProbability(0, 1.00000000000001);
            TestBadProbability(0, 2);
            TestBadProbability(-.1, 0);
            TestBadProbability(0, Double.MaxValue);
            TestBadProbability(Double.MinValue, 0);
            TestBadProbability(0, Double.MinValue);
            TestBadProbability(Double.MaxValue, 0);
            TestBadProbability(.5, .4);
            TestBadProbability(1, 0);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_IAPIResourceView_GET_Tail_CoMetrics_API_Endpoint()
        {
            // ARE-7344 /co_metrics/ can be used to get tail metrics using the API.RequestAndParse method, which
            // then should be successfully casted to the CoMetrics object identical to the object returned by the
            // co_metrics_blocking method.
            Test_IAPIResourceView_Action_Succeeds(delegate (T view)
            {
                Double probability = 0.25;
                CoMetrics regular_metrics = view.co_metrics_blocking(ProbabilityWindow.Tail(0.25), GetLayerViewComponent(),
                    CoMetricsOptions.Default, SimulationPolling);
                var queryParams = CoMetricsOptions.Default.GetParameters();
                queryParams.AddParameter("component_id", GetLayerViewComponent().ref_id, RestSharp.ParameterType.QueryString);
                queryParams.AddParameter("component_type", "LayerView", RestSharp.ParameterType.QueryString);
                CoMetrics endpoint_metrics = API.RequestAndParse<CoMetrics>($"/{view.collection_name}/{view.id}/co_metrics/{probability}",
                    Method.GET, queryParams);
 
                Assert.AreEqual(regular_metrics.context.probability, endpoint_metrics.context.probability);
                Assert.AreEqual(regular_metrics.context.max_probability, endpoint_metrics.context.max_probability);
                Assert.AreEqual(regular_metrics.context.min_probability, endpoint_metrics.context.min_probability);
                Assert.AreEqual(regular_metrics.component_metrics.mean, endpoint_metrics.component_metrics.mean);
                Assert.AreEqual(regular_metrics.component_metrics.covariance, endpoint_metrics.component_metrics.covariance);
                Assert.AreEqual(regular_metrics.component_metrics.correlation, endpoint_metrics.component_metrics.correlation);
            });
        }
 
        #region Filter Tests
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_IAPIResourceView_GET_CoMetrics_Filter_Existing()
        {
            IReference<IAPIResourceView>[] components = {
                GetLayerViewComponent(), GetPortfolioViewComponent()
            };
            Test_IAPIResourceView_Action_Succeeds(delegate (T view)
            {
                List<IReference<LossFilter>> availableFilters =
                    Reflection.Resolve(view.analysis_profile).loss_filters;
                foreach (IReference<IAPIResourceView> component in components)
                    foreach (IReference<LossFilter> lf in availableFilters)
                    {
                        string filterName = Reflection.Resolve(lf).name;
                        GetCoMetricsAction(ProbabilityWindow.All, component,
                            new CoMetricsOptions(filter: filterName))(view);
                        GetCoMetricsAction(ProbabilityWindow.All, component,
                            new CoMetricsOptions(filterName))(view);
                    }
            });
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_IAPIResourceView_GET_CoMetrics_Filter_NonExistant()
        {
            Test_IAPIResourceView_GET_CoMetrics_Fails(
                AssertApi.ApiExceptionTest(HttpStatusCode.BadRequest), ProbabilityWindow.All,
                GetLayerViewComponent(), new CoMetricsOptions(filter: "NonExistant"));
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_IAPIResourceView_GET_CoMetrics_ComponentFilter_NonExistant()
        {
            Test_IAPIResourceView_GET_CoMetrics_Fails(
                AssertApi.ApiExceptionTest(HttpStatusCode.BadRequest), ProbabilityWindow.All,
                GetLayerViewComponent(), new CoMetricsOptions("NonExistant"));
        }
        // TODO: Test where filter and component_filter are different
        #endregion Filter Tests
 
        #region Perspective Tests
        private void TestGetCoMetricsForPerspective(T view, IReference<IAPIResourceView> component, Perspective persp)
        {
            // Test Setting just the primary perspective to this
            GetCoMetricsAction(ProbabilityWindow.All, component,
                new CoMetricsOptions(perspective: persp))(view);
            // Test Setting just the component perspective to this
            GetCoMetricsAction(ProbabilityWindow.All, component,
                new CoMetricsOptions(component_perspective: persp))(view);
            // Test setting every possible component perspective while the primary is set to this
            // TODO: This next test is over-kill, causing co_metrics tests to make O(n^2) requests
            //       and run a lot longer (30s to 1min) each. So I have disable testing every single
            //       possible combination of primary and component perspective.
            //foreach (Perspective componentPerspective in TestSuite_Perspective.TestPerspectives)
            //    GetCoMetricsAction(ProbabilityWindow.All, component, new CoMetricsOptions(
            //        perspective: persp, component_perspective: componentPerspective))(view);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_IAPIResourceView_GET_CoMetrics_Perspective_Main()
        {
            List<IReference<IAPIResourceView>> testComponents =
                new List<IReference<IAPIResourceView>> { GetLayerViewComponent(), GetPortfolioViewComponent() };
            Test_IAPIResourceView_Action_Succeeds(view =>
                testComponents.ForEach(component => TestSuite_Perspective.TestPerspectives.ToList().ForEach(perspective =>
                        TestGetCoMetricsForPerspective(view, component, perspective))));
        }
 
        [TestMethod, TestCategory(TypeName)]
        [Obsolete("Tests an obsolete factory method for constructing legacy perspectives")]
        public virtual void Test_IAPIResourceView_GET_CoMetrics_Perspective_LossNetOfAggregateTermsAnd()
        {
            List<IReference<IAPIResourceView>> testComponents =
                new List<IReference<IAPIResourceView>> { GetLayerViewComponent(), GetPortfolioViewComponent() };
            Test_IAPIResourceView_Action_Succeeds(view =>
                testComponents.ForEach(component => TestSuite_Perspective.LegacyTestPerspectives.ToList().ForEach(perspective =>
                        TestGetCoMetricsForPerspective(view, component, perspective))));
        }
        #endregion Perspective Tests
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_IAPIResourceView_GET_CoMetrics_Currency()
        {
            Test_IAPIResourceView_GET_CoMetrics_Succeeds(ProbabilityWindow.All,
                GetLayerViewComponent(), new CoMetricsOptions(currency: "GBP"));
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_IAPIResourceView_GET_CoMetrics_CurrencyUnavailable()
        {
            Test_IAPIResourceView_GET_CoMetrics_Fails(
                AssertApi.ApiExceptionTest(HttpStatusCode.BadRequest), ProbabilityWindow.All,
                GetLayerViewComponent(), new CoMetricsOptions(currency: "ALL"));
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_IAPIResourceView_GET_CoMetrics_IncludePrimaryMetrics_true()
        {
            Test_IAPIResourceView_GET_CoMetrics_Succeeds(ProbabilityWindow.All,
                GetLayerViewComponent(), new CoMetricsOptions(include_primary_metrics: true),
                cometrics => Assert.IsNotNull(cometrics.primary_metrics));
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_IAPIResourceView_GET_CoMetrics_IncludePrimaryMetrics_false()
        {
            Test_IAPIResourceView_GET_CoMetrics_Succeeds(ProbabilityWindow.All,
                GetLayerViewComponent(), new CoMetricsOptions(include_primary_metrics: false),
                cometrics => Assert.IsNull(cometrics.primary_metrics));
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_IAPIResourceView_GET_CoMetrics_AggregationMethods()
        {
            foreach (AggregationMethod aggMethod in Enum<AggregationMethod>.Values)
            {
                Test_IAPIResourceView_GET_CoMetrics_Succeeds(ProbabilityWindow.All,
                    GetLayerViewComponent(), new CoMetricsOptions(aggregation_method: aggMethod));
            }
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_IAPIResourceView_GET_CoMetrics_SecondaryUncertainty()
        {
            Test_IAPIResourceView_GET_CoMetrics_Succeeds(ProbabilityWindow.All,
                GetLayerViewComponent(), new CoMetricsOptions(secondary_uncertainty: true));
 
            Test_IAPIResourceView_GET_CoMetrics_Succeeds(ProbabilityWindow.All,
                GetLayerViewComponent(), new CoMetricsOptions(secondary_uncertainty: false));
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_IAPIResourceView_GET_CoMetrics_ReportingPeriod()
        {
            Test_IAPIResourceView_GET_CoMetrics_Succeeds(ProbabilityWindow.All, GetLayerViewComponent(),
                new CoMetricsOptions(reporting_period:
                    new ReportingPeriod(DateTime.UtcNow, DateTime.UtcNow.AddYears(1))));
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_IAPIResourceView_GET_CoMetrics_ComponentReportingPeriod()
        {
            Test_IAPIResourceView_GET_CoMetrics_Succeeds(ProbabilityWindow.All, GetLayerViewComponent(),
                new CoMetricsOptions(component_reporting_period:
                    new ReportingPeriod(DateTime.UtcNow, DateTime.UtcNow.AddYears(1))));
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_IAPIResourceView_GET_CoMetrics_ApplyParticipation()
        {
            Test_IAPIResourceView_GET_CoMetrics_Succeeds(ProbabilityWindow.All,
                GetLayerViewComponent(), new CoMetricsOptions(apply_participation: true));
 
            Test_IAPIResourceView_GET_CoMetrics_Succeeds(ProbabilityWindow.All,
                GetLayerViewComponent(), new CoMetricsOptions(apply_participation: false));
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_IAPIResourceView_GET_CoMetrics_ReportingPeriod_PrimaryAndComponentSet()
        {
            DateTime now = DateTime.UtcNow;
            // Server should maintain both periods separately, regardless of how they intersect.
            Test_IAPIResourceView_GET_CoMetrics_Succeeds(ProbabilityWindow.All, GetLayerViewComponent(),
                new CoMetricsOptions(
                    reporting_period: new ReportingPeriod(now.AddYears(-1), now.AddYears(1)),
                    component_reporting_period: new ReportingPeriod(now, now.AddMonths(3))),
                    result =>
                    {
                        AssertApi.DatesAreEqual(now.AddYears(-1), result.context.reporting_period_begin);
                        AssertApi.DatesAreEqual(now.AddYears(1), result.context.reporting_period_end);
                        AssertApi.DatesAreEqual(now, result.context.component_reporting_period_begin);
                        AssertApi.DatesAreEqual(now.AddMonths(3), result.context.component_reporting_period_end);
                    });
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_IAPIResourceView_GET_CoMetrics_ReportingPeriod_PartialComponentSet()
        {
            DateTime now = DateTime.UtcNow;
            // Server should default reporting period begin and end separately if only one is set.
            Test_IAPIResourceView_GET_CoMetrics_Succeeds(ProbabilityWindow.All, GetLayerViewComponent(),
                new CoMetricsOptions(
                    reporting_period: new ReportingPeriod(now, null),
                    component_reporting_period: new ReportingPeriod(null, now.AddMonths(3))),
                    result =>
                    {
                        AssertApi.DatesAreEqual(now, result.context.reporting_period_begin);
                        AssertApi.DatesAreEqual(now, result.context.component_reporting_period_begin);
                        Assert.IsNull(result.context.reporting_period_end);
                        AssertApi.DatesAreEqual(now.AddMonths(3), result.context.component_reporting_period_end);
                    });
            Test_IAPIResourceView_GET_CoMetrics_Succeeds(ProbabilityWindow.All, GetLayerViewComponent(),
                new CoMetricsOptions(
                    reporting_period: new ReportingPeriod(now.AddYears(-1), now.AddYears(1)),
                    component_reporting_period: new ReportingPeriod(now, null)),
                    result =>
                    {
                        AssertApi.DatesAreEqual(now.AddYears(-1), result.context.reporting_period_begin);
                        AssertApi.DatesAreEqual(now.AddYears(1), result.context.reporting_period_end);
                        AssertApi.DatesAreEqual(now, result.context.component_reporting_period_begin);
                        AssertApi.DatesAreEqual(now.AddYears(1), result.context.component_reporting_period_end);
                    });
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_IAPIResourceView_GET_CoMetrics_ReportingPeriod_ComponentDefaultInvalid()
        {
            DateTime now = DateTime.UtcNow;
            // If the user just sets part of the component reporting period, and the other
            // part defaults such that the date range is invalid, the server should raise an error.
            Test_IAPIResourceView_GET_CoMetrics_Fails(
                AssertApi.ApiExceptionTest(HttpStatusCode.BadRequest), ProbabilityWindow.All, GetLayerViewComponent(),
                new CoMetricsOptions(
                    reporting_period: new ReportingPeriod(now, null),
                    // Normally a valid reporting period, but the component reporting period begin
                    // will default to the primary begin, resulting in an invalid reporting period
                    component_reporting_period: new ReportingPeriod(null, now.AddDays(-1))));
            Test_IAPIResourceView_GET_CoMetrics_Fails(
                AssertApi.ApiExceptionTest(HttpStatusCode.BadRequest), ProbabilityWindow.All, GetLayerViewComponent(),
                new CoMetricsOptions(
                    reporting_period: new ReportingPeriod(now, now.AddYears(1)),
                    component_reporting_period: new ReportingPeriod(now.AddYears(2), null)));
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_IAPIResourceView_GET_CoMetrics_Vectorized()
        {
            POST_ThenDoAction(TestResource, view =>
            {
                List<CoMetrics> result = view.co_metrics_blocking(
                    new List<ProbabilityWindow> {
                        ProbabilityWindow.Tail(0.1),
                        ProbabilityWindow.All,
                        ProbabilityWindow.Tail(0.5),
                        ProbabilityWindow.Tail(0.25)
                    },
                    GetLayerViewComponent(), CoMetricsOptions.Default, SimulationPolling);
 
                // Assertions that should be met as part of any successful tail metrics result
                Assert.AreEqual(4, result.Count, "Expected 4 TailMetrics responses");
                // TODO: Guarantee order once ARE-3264 is complete
                /*
                AssertApi.DoublesAreEqual(1, result.First().context.probability);
                AssertApi.DoublesAreEqual(0.5, result.Skip(1).First().context.probability);
                AssertApi.DoublesAreEqual(0.25, result.Skip(2).First().context.probability);
                AssertApi.DoublesAreEqual(0.1, result.Skip(3).First().context.probability);
                */
            });
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_IAPIResourceView_GET_CoMetrics_Overloads()
        {
            // Test the ability to invoke all overloads and extension methods of window_metrics,
            // including any type conversions or inferences meant to be supported.
            Test_IAPIResourceView_Action_Succeeds(arg =>
            {
                CoMetricsOptions options = CoMetricsOptions.Default;
                arg.co_metrics_blocking(new[] { ProbabilityWindow.All }, arg.ToReference(), options);
                arg.co_metrics_blocking(new List<ProbabilityWindow> { ProbabilityWindow.All,
                    ProbabilityWindow.Tail(0.5), new ProbabilityWindow(0.25, 0.75) }, arg.ToReference(), options);
                arg.co_metrics_blocking(new HashSet<ProbabilityWindow> { ProbabilityWindow.All,
                    ProbabilityWindow.Tail(0.5), new ProbabilityWindow(0.25, 0.75) }, arg.ToReference(), options);
                arg.co_metrics_blocking(Enumerable.Range(1, 10).Select(i => ProbabilityWindow.Tail(1d / i)),
                    arg.ToReference(), options);
                arg.co_metrics(new[] { ProbabilityWindow.All }, arg.ToReference(), options);
                arg.co_metrics(new List<ProbabilityWindow> { ProbabilityWindow.All,
                    ProbabilityWindow.Tail(0.5), new ProbabilityWindow(0.25, 0.75) }, arg.ToReference(), options);
                arg.co_metrics(new HashSet<ProbabilityWindow> { ProbabilityWindow.All,
                    ProbabilityWindow.Tail(0.5), new ProbabilityWindow(0.25, 0.75) }, arg.ToReference(), options);
                arg.co_metrics(Enumerable.Range(1, 10).Select(i => ProbabilityWindow.Tail(1d / i)),
                    arg.ToReference(), options);
            });
        }
        #endregion Test Methods
 
        #region Legacy Test Methods
        #region Helper Methods
        [Obsolete("Tests an obsolete method for backwards compatibility.")]
        private void Test_IAPIResourceView_GET_CoMetrics_Legacy_Succeeds(double probability,
            IReference<IAPIResourceView> component, CoMetricsOptions options = null,
            Action<CoMetrics> additionalAssertions = null)
        {
            Test_IAPIResourceView_Action_Succeeds(arg =>
            {
                CoMetrics response = GetCoMetricsLegacyAction(probability, component, options)(arg);
                additionalAssertions?.Invoke(response);
            });
        }
 
        [Obsolete("Tests an obsolete method for backwards compatibility.")]
        private static Func<T, CoMetrics> GetCoMetricsLegacyAction(double probability,
            IReference<IAPIResourceView> component, CoMetricsOptions options = null)
        {
            return view =>
            {
                CoMetrics result = view.co_metrics_blocking(
                    probability, component, options, SimulationPolling);
                // Check that all co-metrics result properties are filled in.
                AssertConditionalDistributionMetricsExist(result.component_metrics);
                // Check that co-metrics context properties are filled in appropriately
                RunCoMetricsContextAssertions(view, probability, component, options, result.context);
                // If the primary metrics were requested, ensure they were all filled in.
                if (options?.include_primary_metrics ?? false)
                    AssertTailDistributionMetricsExist(result.primary_metrics);
                return result;
            };
        }
 
        [Obsolete("Tests an obsolete method for backwards compatibility.")]
        private static void RunCoMetricsContextAssertions(
            T view, double probability, IReference<IAPIResourceView> component,
            CoMetricsOptions options, CoMetrics.Context context)
        {
            // First, all of the same assertions made in the TailMetrics response should hold true
            RunTailMetricsContextAssertions(view, probability, options, context);
 
            RunCoMetricsContextAssertions(view, ProbabilityWindow.Tail(probability),
                component, options, context);
        }
        #endregion Helper Methods
 
        [TestMethod, TestCategory(TypeName)]
        [Obsolete("Tests an obsolete method for backwards compatibility.")]
        public virtual void Test_IAPIResourceView_GET_CoMetrics_Legacy_LayerView_ValidValues()
        {
            Test_IAPIResourceView_GET_CoMetrics_Legacy_Succeeds(1, GetLayerViewComponent());
            Test_IAPIResourceView_GET_CoMetrics_Legacy_Succeeds(0.01, GetLayerViewComponent());
            // Test a high precision value survives the round trip.
            Test_IAPIResourceView_GET_CoMetrics_Legacy_Succeeds(Math.PI / 4d, GetLayerViewComponent());
            // Test a very small probability maintains precision
            Test_IAPIResourceView_GET_CoMetrics_Legacy_Succeeds(1.234556789E-12, GetLayerViewComponent());
        }
 
        [TestMethod, TestCategory(TypeName)]
        [Obsolete("Tests an obsolete method for backwards compatibility.")]
        public virtual void Test_IAPIResourceView_GET_CoMetrics_Legacy_PortfolioView_ValidValues()
        {
            Test_IAPIResourceView_GET_CoMetrics_Legacy_Succeeds(1, GetPortfolioViewComponent());
            Test_IAPIResourceView_GET_CoMetrics_Legacy_Succeeds(0.01, GetPortfolioViewComponent());
            // Test a high precision value survives the round trip.
            Test_IAPIResourceView_GET_CoMetrics_Legacy_Succeeds(Math.PI / 4d, GetPortfolioViewComponent());
            // Test a very small probability maintains precision
            Test_IAPIResourceView_GET_CoMetrics_Legacy_Succeeds(1.234556789E-12, GetPortfolioViewComponent());
        }
 
        [TestMethod, TestCategory(TypeName)]
        [Obsolete("Tests an obsolete method for backwards compatibility.")]
        public virtual void Test_IAPIResourceView_GET_CoMetrics_Legacy_Probability_InvalidValues()
        {
            IReference<ILayerView> component = GetLayerViewComponent();
            void TestBadProbability(double probability) =>
                // Test that the appropriate client-side validation occurs
                Test_IAPIResourceView_Action_Fails(
                    arg => GetCoMetricsLegacyAction(probability, component, CoMetricsOptions.Default)(arg),
                    ProbabilityError(0, probability));
 
            TestBadProbability(0);
            TestBadProbability(1.00000000000001);
            TestBadProbability(2);
            TestBadProbability(-0.5);
            TestBadProbability(Double.MinValue);
            TestBadProbability(Double.MaxValue);
        }
 
        [TestMethod, TestCategory(TypeName)]
        [Obsolete("Tests an obsolete method for backwards compatibility.")]
        public virtual void Test_IAPIResourceView_GET_CoMetrics_Legacy_Vectorized()
        {
            POST_ThenDoAction(TestResource, view =>
            {
                List<CoMetrics> result = view.co_metrics_blocking(
                    new List<double> { 0.1, 1, 0.5, 0.25 },
                    GetLayerViewComponent(), CoMetricsOptions.Default, SimulationPolling);
 
                // Assertions that should be met as part of any successful tail metrics result
                Assert.AreEqual(4, result.Count, "Expected 4 TailMetrics responses");
            });
        }
        #endregion Legacy Test Methods
        #endregion CoMetrics
        #endregion Metrics
 
        #region File Download Endpoints
        #region Legacy Back-Allocation
        [Obsolete("Tests the legacy back_allocations endpoint")]
        protected void VerifyBackAllocationSuccess(BackAllocations result)
        {
            Assert.IsNotNull(result.layer_view);
            Assert.IsNotNull(result.layer_view.ref_id);
            // Verify that the reference can be resolved
            ILayerView back_allocated_layer = result.layer_view.GetValue();
            Assert.AreEqual(result.layer_view.ref_id, back_allocated_layer.id);
        }
 
        [TestMethod, TestCategory(TypeName), Obsolete("Tests the legacy back_allocations endpoint")]
        public virtual void Test_IAPIResourceView_GET_BackAllocations_Self()
        {
            // Simplest case: Test back-allocating a view to itself.
            Test_IAPIResourceView_Action_Succeeds(view =>
            {
                BackAllocations result = view.back_allocations_blocking(view.id, SimulationPolling);
                VerifyBackAllocationSuccess(result);
            });
        }
 
        [TestMethod, TestCategory(TypeName), Obsolete("Tests the legacy back_allocations endpoint")]
        public virtual void Test_IAPIResourceView_GET_BackAllocations_SourceID_Invalid()
        {
            Test_IAPIResourceView_Action_Fails(view =>
                    _ = view.back_allocations_blocking(Samples.Valid_NonExistant_UUID, SimulationPolling),
                AssertApi.ApiExceptionTest(HttpStatusCode.BadRequest));
        }
        #endregion Legacy Back-Allocation
 
        #region YLT
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_IAPIResourceView_GET_YLT()
        {
            Test_IAPIResourceView_Action_Succeeds(view =>
            {
                string result = view.ylt.Get(MetricsOptions.Default, true);
                Assert.IsNotNull(result);
                // TODO: Test that the YLT is in an expected format
            });
        }
 
        // TODO: Test YLT GET Parameters
        #endregion YLT
 
        #region YELT
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_IAPIResourceView_GET_YELT()
        {
            Test_IAPIResourceView_Action_Succeeds(view =>
            {
                IRestResponse result = view.yelt.GetStream(stream =>
                {
                    using (StreamReader reader = new StreamReader(stream))
                    {
                        string fullYELT = reader.ReadToEnd();
                        Assert.IsNotNull(fullYELT);
                        Console.WriteLine(fullYELT);
                        // TODO: Test that the YELT is in an expected format
                    }
                }, YELTOptions.Default, true);
                Assert.AreEqual(ResponseStatus.Completed, result.ResponseStatus);
                Assert.AreEqual(HttpStatusCode.OK, result.StatusCode);
            });
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_IAPIResourceView_GET_YELT_Start_End_Trial()
        {
            Test_IAPIResourceView_Action_Succeeds(view =>
            {
                IRestResponse result = view.yelt.GetStream(stream =>
                {
                    using (StreamReader reader = new StreamReader(stream))
                    {
                        reader.ReadLine(); // Skip header
                        for (string line = reader.ReadLine(); line != null; line = reader.ReadLine())
                        {
                            string trial = line.Split(',').ElementAt(0);
                            Assert.IsTrue(trial == "2" || trial == "3");
                        }
                    }
                }, new YELTOptions(start_trial: 2, end_trial: 3), true);
                Assert.AreEqual(ResponseStatus.Completed, result.ResponseStatus);
                Assert.AreEqual(HttpStatusCode.OK, result.StatusCode);
            });
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_IAPIResourceView_GET_YELT_AdditionalColumns()
        {
            YELTOptions.AdditionalColumns[] additionalColumns = new[]{
                YELTOptions.AdditionalColumns.RecordType,
                YELTOptions.AdditionalColumns.ReinstatementBrokerage};
 
            Test_IAPIResourceView_Action_Succeeds(view =>
            {
                IRestResponse result = view.yelt.GetStream(stream =>
                {
                    using (StreamReader reader = new StreamReader(stream))
                    {
                        string headerLine = reader.ReadLine();
                        string[] headers = headerLine.Split(',');
                        Assert.IsTrue(additionalColumns.All(c => headers.Any(h => h.Contains(c.ToString("G")))));
 
                        for (string line = reader.ReadLine(); line != null; line = reader.ReadLine())
                        {
                            int field_count = line.Count(c => c == ',') + 1;
                            Assert.AreEqual(4 + additionalColumns.Length, field_count);
                        }
                    }
                }, new YELTOptions(additional_columns: additionalColumns.Aggregate((l, r) => l | r)), true);
                Assert.AreEqual(ResponseStatus.Completed, result.ResponseStatus);
                Assert.AreEqual(HttpStatusCode.OK, result.StatusCode);
            });
        }
 
        // TODO: Test YELT POST Parameters
        #endregion YELT
        #endregion File Download Endpoints
    }
}