Test_OptimizationView.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.Linq;
 
using AnalyzeRe;
using AnalyzeRe.APITypes;
using AnalyzeRe.Layers;
using AnalyzeRe.Metrics;
using AnalyzeRe.Optimization;
using AnalyzeReTesting.Base;
using AnalyzeReTesting.Utilities;
 
#if MSTEST
using Microsoft.VisualStudio.TestTools.UnitTesting;
#elif NUNIT
using NUnit.Framework;
using TestClass = NUnit.Framework.TestFixtureAttribute;
using TestMethod = NUnit.Framework.TestAttribute;
using TestCategory = NUnit.Framework.CategoryAttribute;
#endif
 
namespace AnalyzeReTesting.Tests.Model
{
    [TestClass]
    public sealed class TestSuite_OptimizationView_Base : BaseAbstractStoredResourceTestSuite<OptimizationView>
    {
        protected override bool PUT_Allowed => false;
        protected override IResourceCollection<OptimizationView> collection_source => API.OptimizationViews;
 
        public TestSuite_OptimizationView_Base()
        {
            // Increase the request timeout for OptimizationView requests since can be slow.
            AddCommonTestInitializeAction(() =>
                API.DefaultRequestTimeout = API.DefaultRequestTimeoutCollections =
                    EnvironmentSettings.OPTIMIZATION_TIMEOUTS);
        }
    }
 
    [TestClass]
    public sealed class TestSuite_OptimizationView : BaseImmutableResourceTestSuite<OptimizationView>
    {
        #region Set Up and Configuration
        private const string TypeName = "OptimizationView";
        protected override bool DELETE_Allowed => true;
 
        protected override IInjectableResource<OptimizationView> TestInjectableResource =>
            Samples.OptimizationView_Simulated;
 
        public override void AdditionalValidResourceTests(OptimizationView posted) =>
            WaitForOptimizationResult(posted);
 
        public TestSuite_OptimizationView()
        {
            // Increase the request timeout for OptimizationView requests since can be slow.
            AddCommonTestInitializeAction(() =>
                API.DefaultRequestTimeout = API.DefaultRequestTimeoutCollections =
                    EnvironmentSettings.OPTIMIZATION_TIMEOUTS);
        }
        #endregion Set Up and Configuration
 
        [TestMethod, TestCategory(TypeName)]
        public override void Test_Resource_GET_AllPropertiesRecognized()
        {
            // In the case of the OptimizationView - even after the resource is posted the properties
            // may change as the OptimizationView's job gets "run". The Get_AllPropertiesRecognized
            // method requires making two different GETs where all property values are identical -
            // hence we must ensure the OptimizationView is done running before we run this test.
            TestResource_Existing.PollUntilReady(OptimizationPolling);
            base.Test_Resource_GET_AllPropertiesRecognized();
        }
 
        #region POST
        #region analysis_profile
        [TestMethod, TestCategory(TypeName)]
        public void Test_OptimizationView_POST_AnalysisProfile_Null()
        {
            POST_Attribute_Null(l => l.analysis_profile);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_OptimizationView_POST_AnalysisProfile_Reference_NullId()
        {
            POST_Reference_NullId(l => l.analysis_profile);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_OptimizationView_POST_AnalysisProfile_Reference_EmptyStringId()
        {
            POST_Reference_EmptyStringId(l => l.analysis_profile);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_OptimizationView_POST_AnalysisProfile_Reference_NonExistantId()
        {
            POST_Reference_NonExistantId(l => l.analysis_profile);
        }
        #endregion analysis_profile
 
        #region iterations
        [TestMethod, TestCategory(TypeName)]
        public void Test_OptimizationView_POST_Iterations_TooLow()
        {
            POST_WithValue(l => l.iterations, 0, false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_OptimizationView_POST_Iterations_Minimum()
        {
            // Min iterations is 1
            POST_WithValue(l => l.iterations, 1, true);
        }
        //Test Takes too long to run.
        //[TestMethod, TestCategory(TypeName)]
        //public void Test_OptimizationView_POST_Iterations_Maximum()
        //{
        //    // Max iterations is 10,000
        //    POST_WithValue(l => l.iterations, 10000, shouldSucceed: true);
        //}
        [TestMethod, TestCategory(TypeName)]
        public void Test_OptimizationView_POST_Iterations_TooHigh()
        {
            POST_WithValue(l => l.iterations, 10001, false);
        }
        #endregion iterations
 
        #region population_size
        [TestMethod, TestCategory(TypeName)]
        public void Test_OptimizationView_POST_PopulationSize_TooLow()
        {
            POST_WithValue(l => l.population_size, 0, false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_OptimizationView_POST_PopulationSize_Minimum()
        {
            // Min population size is 1
            Skip.Indefinitely("ARE-4575");
            POST_WithValue(l => l.population_size, 1, true);
        }
        //Test Takes too long to run.
        //[TestMethod, TestCategory(TypeName)]
        //public void Test_OptimizationView_POST_PopulationSize_Maximum()
        //{
        //    // Max population size is 10,000
        //    POST_WithValue(l => l.population_size, 10000, shouldSucceed: true);
        //}
        [TestMethod, TestCategory(TypeName)]
        public void Test_OptimizationView_POST_PopulationSize_TooHigh()
        {
            POST_WithValue(l => l.population_size, 10001, false);
        }
        #endregion population_size
 
        #region custom_parameters
        [TestMethod, TestCategory(TypeName)]
        public void Test_OptimizationView_POST_CustomParameters_Null()
        {
            // Task #1162 (in Redmine) describes why requiring custom_parameters is overly strict
            POST_Attribute_Null(l => l.custom_parameters);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_OptimizationView_POST_CustomParameters_Empty()
        {
            // Currently Requires several custom parameters, so fail
            POST_WithValue(l => l.custom_parameters,
                new Dictionary<string, object>(), false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_OptimizationView_POST_CustomParameters_MixedTypes()
        {
            OptimizationView modified = TestResource;
            modified.custom_parameters["Test1"] = "TestValue";
            modified.custom_parameters["Test2"] = 2;
            modified.custom_parameters["Test3"] = 3.33;
            GenericTest.POST_ValidResource(modified);
        }
 
        #region Discretization
        [TestMethod, TestCategory(TypeName)]
        public void Test_OptimizationView_POST_CustomParameters_Discretization_TooLow()
        {
            OptimizationView modified = TestResource;
            modified.custom_parameters["Discretization"] = -0.001;
            GenericTest.POST_InvalidResource_Fails(modified);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_OptimizationView_POST_CustomParameters_Discretization_Minimum()
        {
            OptimizationView modified = TestResource;
            modified.custom_parameters["Discretization"] = 0;
            GenericTest.POST_ValidResource(modified);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_OptimizationView_POST_CustomParameters_Discretization_Maximum()
        {
            OptimizationView modified = TestResource;
            // Discretization can be no larger than the smallest difference
            // between min and max share (excluding locked layers)
            double maxDiscretization = modified.domains.Where(d => !d.min.Equals(d.max)).Min(d => d.max - d.min);
            modified.custom_parameters["Discretization"] = maxDiscretization;
            GenericTest.POST_ValidResource(modified);
 
            // Now try exceeding this value
            modified.custom_parameters["Discretization"] = maxDiscretization + 0.01;
            GenericTest.POST_InvalidResource_Fails(modified);
        }
        #endregion Discretization
 
        #region Return_Period
        [TestMethod, TestCategory(TypeName)]
        public void Test_OptimizationView_POST_CustomParameters_Return_Period_TooLow()
        {
            OptimizationView modified = TestResource;
            modified.custom_parameters["Objective 2 - Return Period"] = 0;
            GenericTest.POST_InvalidResource_Fails(modified);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_OptimizationView_POST_CustomParameters_Return_Period_Minimum()
        {
            OptimizationView modified = TestResource;
            modified.custom_parameters["Objective 2 - Return Period"] = 1e-15;
            GenericTest.POST_ValidResource(modified);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_OptimizationView_POST_CustomParameters_Return_Period_Maximum()
        {
            OptimizationView modified = TestResource;
            modified.custom_parameters["Objective 2 - Return Period"] = 1;
            GenericTest.POST_ValidResource(modified);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_OptimizationView_POST_CustomParameters_Return_Period_TooHigh()
        {
            OptimizationView modified = TestResource;
            modified.custom_parameters["Objective 2 - Return Period"] = 2.001;
            GenericTest.POST_InvalidResource_Fails(modified);
        }
        #endregion Return_Period
        #endregion custom_parameters
 
        #region domain
        [TestMethod, TestCategory(TypeName)]
        public void Test_OptimizationView_POST_Domain_Null()
        {
            POST_Attribute_Null(l => l.domains);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_OptimizationView_POST_Domain_Empty()
        {
            POST_ListAttribute_Empty(l => l.domains);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_OptimizationView_POST_Domain_InvalidLayerId()
        {
            DomainEntry _withInvalidLayer = new DomainEntry
            {
                layer = new Reference<Generic>(Samples.Valid_NonExistant_UUID),
                min = 0,
                max = 1
            };
            POST_WithValue(l => l.domains,
                new List<DomainEntry> { _withInvalidLayer }, false);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_OptimizationView_POST_Domain_MaxLessThanMin()
        {
            OptimizationView modified = TestResource;
            modified.domains.First().min = 0.5;
            modified.domains.First().max = 0.4;
            GenericTest.POST_InvalidResource_Fails(modified);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_OptimizationView_POST_Domain_MinAndMax_Limit()
        {
            OptimizationView modified = TestResource;
            modified.domains.First().min = Int32.MinValue;
            modified.domains.First().max = Int32.MaxValue;
            GenericTest.POST_ValidResource(modified);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_OptimizationView_POST_Domain_AllowExclude()
        {
            OptimizationView modified = TestResource;
            modified.domains.First().allow_exclude = true;
            GenericTest.POST_ValidResource(modified);
        }
 
        public static readonly HashSet<Type> UnsupportedOptimizationLayerTypes = new HashSet<Type>
        {
            typeof(Filter), typeof(FixedRateCurrencyConverter), typeof(IndustryLossWarranty),
            typeof(Nested), typeof(SurplusShare), typeof(LossRank), typeof(NoClaimsBonus),
            typeof(ValueAllocator), typeof(BackAllocatedLayer),
            typeof(FixedDatePayment), typeof(DelayedPayment)
        };
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_OptimizationView_POST_Domain_Layer_ValidTypes()
        {
            IEnumerable<IInjectableResource<ILayer>> supportedTypes =
                Samples.AllLayerTypesTestList.Where(t =>
                    !UnsupportedOptimizationLayerTypes.Contains(t.UnderlyingType));
            foreach (IInjectableResource<ILayer> layer in supportedTypes)
            {
                OptimizationView modified = TestResource;
                modified.domains.Add(new DomainEntry { layer = layer.AsReference, min = 0, max = 1 });
                POST_ThenDoAction(modified, optimizationView =>
                {
                    optimizationView = WaitForOptimizationResult(optimizationView);
                    Assert.AreEqual(TaskStatus.Success, optimizationView.status);
                });
            }
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_OptimizationView_POST_Domain_Layer_InvalidTypes()
        {
            IEnumerable<IInjectableResource<ILayer>> unsupportedTypes =
                Samples.AllSaveableLayerTypesTestList.Where(t =>
                    UnsupportedOptimizationLayerTypes.Contains(t.UnderlyingType));
            foreach (IInjectableResource<ILayer> layer in unsupportedTypes)
            {
                OptimizationView modified = TestResource;
                modified.domains.Add(new DomainEntry { layer = layer.AsReference, min = 0, max = 1 });
                GenericTest.POST_InvalidResource_Fails(modified);
            }
        }
        #endregion domain
 
        #region CreatedAndModified
        [TestMethod, TestCategory(TypeName)]
        public override void Test_Resource_POST_CreatedAndModified()
        {
            POST_ThenDoAction(TestResource, posted =>
            {
                Assert.IsNotNull(posted.created, "Expected a 'created' date to be assigned.");
                Assert.IsNotNull(posted.modified, "Expected a 'modified' date to be assigned.");
            });
        }
        #endregion CreatedAndModified
 
        #region target_currency
        [TestMethod, TestCategory(TypeName)]
        public void Test_OptimizationView_POST_TargetCurrency_Null()
        {
            POST_Attribute_Null(l => l.target_currency);
        }
        #endregion target_currency
        #endregion POST
 
        #region Results
        public static readonly PollingOptions OptimizationPolling = new PollingOptions(
            maxPollInterval: EnvironmentSettings.POLLING_INTERVAL,
            maxPollTotalTime: EnvironmentSettings.OPTIMIZATION_TIMEOUTS
        );
 
        private static OptimizationView WaitForOptimizationResult(OptimizationView optimization)
        {
            // TODO: Currently so long because the OE can get hung up (Story #1631)
            // Result should only take about 3 seconds, but allow up to 20 for now since first run
            // always takes longer as Julia code must compile or something...
            try
            {
                return optimization.PollUntilReady(OptimizationPolling);
            }
            catch (NotWaitingException ex)
            {
                string message = $"Waited {ex.TimeWaited} seconds for " +
                    "the optimization job to complete, but it never did.\n";
                Exception toPrint = ex;
                while (toPrint != null)
                {
                    message = message + Environment.NewLine + ex;
                    toPrint = toPrint.InnerException;
                }
                Assert.Fail(message);
                return null;
            }
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_OptimizationView_GET_Results_Succeeds()
        {
            POST_ThenDoAction(TestResource, optimizationView =>
            {
                optimizationView = WaitForOptimizationResult(optimizationView);
                // Once the optimization is done, the initial portfolio metrics should be present.
                OptimizationResult initialPortfolioMetrics = optimizationView.GetInitialPortfolioMetrics();
                Assert.IsNotNull(initialPortfolioMetrics);
                // Our test optimization had 2 objectives, so we expect two metrics.
                Assert.AreEqual(2, initialPortfolioMetrics.objectives.Count);
                // Check that there is at least one candidate result.
                Assert.IsTrue(optimizationView.GetCandidateResultsCount() >= 1,
                    "Expected at least one candidate in the results.");
                // Get the first optimization result and demonstrate that it's not null.
                Candidate result = optimizationView.GetCandidateResult(0);
                Assert.IsNotNull(result.objectives, "First candidate's objective results were null");
            });
        }
 
        [TestMethod, TestCategory(TypeName)]
        [Obsolete("2018-04-23: This tests an obsolete feature that will be removed in the future.")]
        public void Test_OptimizationView_GET_LegacyResults_Succeeds()
        {
            POST_ThenDoAction(TestResource, optimizationView =>
            {
                optimizationView = WaitForOptimizationResult(optimizationView);
                // Once the optimization is done, the initial portfolio metrics should be present.
                optimizationView = optimizationView.Get();
                Assert.IsNotNull(optimizationView.initial_portfolio_metrics);
                // Our test optimization had 2 objectives, so we expect two metrics.
                Assert.AreEqual(2, optimizationView.initial_portfolio_metrics.Count);
                // Get the (legacy) results endpoint and demonstrate that it's not null.
                CandidateResultsList result = optimizationView.result.Get();
                Assert.IsNotNull(result, "optimization_view result was null");
                Assert.IsTrue(result.candidates.Count >= 1, "Expected at least one candidate");
            });
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_OptimizationView_GET_InitialPortfolio_Succeeds()
        {
            POST_ThenDoAction(TestResource, optimizationView =>
            {
                optimizationView = WaitForOptimizationResult(optimizationView);
                OptimizationResult initialPortfolio = optimizationView.GetInitialPortfolioMetrics();
                Assert.IsNotNull(initialPortfolio);
                // Our test optimization had 2 objectives, so we expect two metrics.
                Assert.AreEqual(2, initialPortfolio.objectives.Count);
                // Our test optimization had 3 constraints, so we expect three metrics.
                Assert.AreEqual(3, initialPortfolio.constraints.Count);
                // Our initial portfolio is not feasible, so we expect this to be false.
                Assert.IsFalse(initialPortfolio.feasible);
                // Test that we can also get the initial portfolio from the endpoint object
                OptimizationResult fromEndpoint = optimizationView.initial_portfolio_result.Get();
                Assert.IsNotNull(fromEndpoint);
            });
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_OptimizationView_GET_Results_Candidates_Succeeds()
        {
            POST_ThenDoAction(TestResource, optimizationView =>
            {
                optimizationView = WaitForOptimizationResult(optimizationView);
                // Assert that we can get a candidate via paging the sub-collection endpoint
                ICollectionResponse<Candidate> result = optimizationView.candidates.List(0, 1);
                long collectionCount = result.meta.total_count;
                Assert.IsTrue(collectionCount >= 1, "Expected at least one candidate");
                // Assert that we can also get the candidate by its index.
                Candidate first = optimizationView.candidates.GetItem(result.items.First().id);
                Assert.IsNotNull(first.index, "Expected the candidate index to be set.");
                Assert.AreEqual(result.items.First().index, first.index);
 
                // Assert that we can also get a candidate via helper methods on the optimization
                Assert.AreEqual(collectionCount, optimizationView.GetCandidateResultsCount());
                Candidate fromParent = optimizationView.GetCandidateResult(first.index.Value);
                Assert.AreEqual(first.index, fromParent.index);
                Assert.IsNotNull(fromParent.optimization_view);
                Assert.IsNotNull(fromParent.parameterization);
                Assert.IsNotNull(fromParent.objectives);
                Assert.IsNotNull(fromParent.constraints);
                Assert.IsNotNull(fromParent.feasible);
            });
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_OptimizationView_GET_Results_Candidate_PortfolioView_Succeeds()
        {
            POST_ThenDoAction(TestResource, optimizationView =>
            {
                optimizationView = WaitForOptimizationResult(optimizationView);
                ICollectionResponse<Candidate> result = optimizationView.candidates.List(0, 1);
                Assert.IsTrue(result.meta.total_count >= 1, "Expected at least one candidate");
                // Get the first candidate by its index.
                Candidate first = optimizationView.candidates.GetItem(result.items.First().id);
                // Assert that we can get the portfolio_view for a candidate
                PortfolioView candidate_portfolio_view = first.portfolio_view.Get();
                Assert.IsNotNull(candidate_portfolio_view.id);
                // Assert that we can get metrics for this portfolio_view
                TailMetrics metrics = candidate_portfolio_view.tail_metrics_blocking(1,
                    MetricsOptions.Default, OptimizationPolling);
                Assert.IsNotNull(metrics);
                Assert.AreEqual(1, metrics.context.probability);
 
                // Assert that we can also get the candidate portfolio_view using the helper method
                PortfolioView fromHelper = optimizationView.GetCandidatePortfolioView(0);
                Assert.IsNotNull(fromHelper);
                // It should be identical to the above method
                Assert.AreEqual(candidate_portfolio_view.id, fromHelper.id);
            });
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_OptimizationView_GET_Results_Summary_Succeeds()
        {
            POST_ThenDoAction(TestResource, optimizationView =>
            {
                optimizationView = WaitForOptimizationResult(optimizationView);
                string result = optimizationView.csv.Get();
                Assert.IsFalse(String.IsNullOrWhiteSpace(result), "optimization_view csv result was empty");
            });
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_OptimizationView_GET_Results_Mixed_Currencies_Fails()
        {
            // ARE-4557: If even one layer or loss set has a different currency,
            //           the whole thing falls apart.
            POST_WithValue(ov => ov.domains, new List<DomainEntry>
            {
                new DomainEntry
                {
                    layer = Samples.Layer_CatXL.Unposted.Change(l => l.limit,
                        new MonetaryUnit(100, "EUR")).Post().ToReference(),
                    min = 0.0,
                    max = 1.0
                }
            }, false);
        }
        #endregion Results
 
        #region Sensitivity Analysis
        [TestMethod, TestCategory(TypeName)]
        public void Test_OptimizationView_GET_Sensitivity_Analysis_Succeeds_No_Candidates()
        {
            POST_ThenDoAction(TestResource, optimizationView =>
            {
                optimizationView = WaitForOptimizationResult(optimizationView);
                SensitivityAnalysis sa = optimizationView.GetSensitivityAnalysis();
 
                Assert.IsNotNull(sa, "Sensitivity Analysis cannot be null");
                Assert.IsNotNull(sa.sensitivities, "Analysis should contain list of sensitivities");
                Assert.IsTrue(sa.sensitivities.Count > 0,
                    "Number of sensitivities for the test should be at least 1");
                Assert.AreEqual(sa.sensitivities.Count, optimizationView.domains.Count,
                    "Number of sensitivities should be equal to the number of domains");
                foreach (SensitivityAnalysis.LayerSensitivity s in sa.sensitivities)
                {
                    Assert.IsNotNull(s.min, "Min value should exist");
                    Assert.IsNotNull(s.max, "Max value should exist");
                    Assert.IsNotNull(s.mean, "Mean value should exist");
                    Assert.IsNotNull(s.ref_id, "Reference ID should exist");
                    Assert.IsNotNull(s.normalized_standard_deviation, "Standard deviation should exist");
                    Assert.IsNotNull(s.normalized_interquartile_range, "Interquartile range should exist");
                    Assert.IsNotNull(s.hist, "Histogram should exist");
                    Assert.AreEqual(20, s.hist.Count, "Histogram should have 20 bins");
                }
            });
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_OptimizationView_GET_Sensitivity_Analysis_Succeeds_With_Candidates()
        {
            POST_ThenDoAction(TestResource, optimizationView =>
            {
                optimizationView = WaitForOptimizationResult(optimizationView);
                SensitivityAnalysis sa = optimizationView.GetSensitivityAnalysis(new List<int> { 0 });
 
                Assert.IsNotNull(sa, "Sensitivity Analysis cannot be null");
                Assert.IsNotNull(sa.sensitivities, "Analysis should contain list of sensitivities");
                Assert.IsTrue(sa.sensitivities.Count > 0,
                    "Number of sensitivities for the test should be at least 1");
                Assert.AreEqual(sa.sensitivities.Count, optimizationView.domains.Count,
                    "Number of sensitivities should be equal to the number of domains");
                foreach (SensitivityAnalysis.LayerSensitivity s in sa.sensitivities)
                {
                    Assert.IsNotNull(s.min, "Min value should exist");
                    Assert.IsNotNull(s.max, "Max value should exist");
                    Assert.IsNotNull(s.mean, "Mean value should exist");
                    Assert.IsNotNull(s.ref_id, "Reference ID should exist");
                    Assert.IsNotNull(s.normalized_standard_deviation, "Standard deviation should exist");
                    Assert.IsNotNull(s.normalized_interquartile_range, "Interquartile range should exist");
                    Assert.IsNotNull(s.hist, "Histogram should exist");
                    Assert.AreEqual(20, s.hist.Count, "Histogram should have 20 bins");
                }
            });
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_OptimizationView_GET_Sensitivity_Analysis_Succeeds_Non_Existing_Candidates()
        {
            POST_ThenDoAction(TestResource, optimizationView =>
            {
                optimizationView = WaitForOptimizationResult(optimizationView);
                // we do not expect to have 9999999 candidates for a view, such candidate should not exist
                SensitivityAnalysis sa = optimizationView.GetSensitivityAnalysis(new List<int> { 9999099 });
                
                Assert.IsNotNull(sa, "Sensitivity Analysis cannot be null");
                Assert.IsNotNull(sa.sensitivities, "Analysis should contain list of sensitivities");
                Assert.AreEqual(sa.sensitivities.Count, 0, "Number of sensitivities for this test should be 0");
            });
        }
        #endregion Sensitivity Analysis
    }
}