Test_Distribution.cs

Go to the documentation of this file.

using System;
 
using AnalyzeRe;
using AnalyzeRe.APITypes;
using AnalyzeRe.Distributions;
using AnalyzeRe.LossSets;
using AnalyzeRe.Utilities;
using AnalyzeReTesting.Base;
using AnalyzeReTesting.Utilities;
 
#if MSTEST
using Microsoft.VisualStudio.TestTools.UnitTesting;
#elif NUNIT
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_Distribution_Base : BaseAbstractStoredResourceTestSuite<IDistribution>
    {
        protected override IResourceCollection<IDistribution> collection_source => API.Distributions;
 
        public static double MaxSafeFrequencyDistributionMean = 1000;
 
        public static void Test_Distribution_Simulatable(Distribution posted)
        {
            Console.WriteLine("Verifying that we can safely post a new " +
                $"ParametricLossSet with a reference to this {posted.GetType().NiceTypeName()}");
 
            // 1. Create a new ParametricLossSet containing this distribution
            ParametricLossSet lossSet = Samples.LossSet_ParametricLossSet.Unposted;
            // If distribution is one of the custom distribution types, assign it accordingly
            if (posted is CustomSeverityDistribution asCustomSeverityDistribution)
                lossSet.severity = asCustomSeverityDistribution.ToReference();
            else if (posted is CustomSeasonalityDistribution asCustomSeasonalityDistribution)
                lossSet.seasonality = asCustomSeasonalityDistribution.ToReference();
            else if (posted is CustomFrequencyDistribution asCustomFrequencyDistribution)
            {
                if (!IsFrequencyDistributionSafeToSimulate(asCustomFrequencyDistribution))
                    return;
                lossSet.frequency = asCustomFrequencyDistribution.ToReference();
            }
            // Any other continuous distribution can be safely used as the severity
            else if (posted is IContinuousDistribution asContinuous)
                lossSet.severity = asContinuous.ToReference();
            // Otherwise, discrete distributions can only be used as a frequency distribution
            else if (posted is IDiscreteDistribution asDiscrete)
            {
                if (!IsFrequencyDistributionSafeToSimulate(asDiscrete))
                    return;
                lossSet.frequency = asDiscrete.ToReference();
            }
            else
                throw new ArgumentException($"Unhandled distribution type {posted.GetType()} " +
                    "does not appear to be Continuous or Discrete. Unsure how to use it.");
 
            // Test that the distribution can be referenced in a Parametric loss set without issue.
            lossSet = lossSet.Post();
            // Now test that our new loss set can be simulated.
            TestSuite_LossSet_Base.Test_LossSet_Simulatable(lossSet);
        }
 
        public static bool IsFrequencyDistributionSafeToSimulate(IDiscreteDistribution frequencyDistribution)
        {
            // Catch any distributions that might lead to the Bug ARE-5686 
            if (frequencyDistribution.min_val.HasValue && frequencyDistribution.min_val.Value < 0)
                throw new ArgumentException("This distribution is decidedly invalid, " +
                    "because it can only be tested as a frequency distribution, and its " +
                    "profile suggests that it might generate a negative number of occurrences:\n" +
                    frequencyDistribution.Serialize(true));
            // Frequency distributions with a large mean will run for too long.
            if (frequencyDistribution.mean_val.HasValue &&
                frequencyDistribution.mean_val.Value > MaxSafeFrequencyDistributionMean)
            {
                Console.WriteLine("Cannot safely determine whether this distribution can be simulated, " +
                    "because it can only be tested as a frequency distribution, and its " +
                    "profile suggests that it would generate a large number of occurrences:\n" +
                    frequencyDistribution.Serialize(true));
                return false;
            }
            // Distrust frequency distributions that do not report their mean value (ARE-7227)
            if (!frequencyDistribution.mean_val.HasValue)
            {
                // The exception is if there is a modulo in place to cap its maximum value
                if (frequencyDistribution.modulo.HasValue &&
                    frequencyDistribution.modulo.Value <= MaxSafeFrequencyDistributionMean)
                    return true;
                Console.WriteLine("Cannot safely determine that this distribution can be simulated, " +
                    "because it can only be tested as a frequency distribution, and its " +
                    "profile gives no indication of how many occurrences it might generate:\n" +
                    frequencyDistribution.Serialize(true));
                return false;
            }
            return true;
        }
    }
 
    #region CustomDistribution Derived Types Test Classes
    [TestClass]
    public sealed class TestSuite_Distribution_CustomFrequencyDistribution
        : TestSuite_CustomDistribution<CustomFrequencyDistribution>
    {
        #region Set Up and Configuration
        private const string TypeName = "CustomFrequencyDistribution";
        protected override IInjectableResource<CustomFrequencyDistribution>
            TestInjectableResource => Samples.Distribution_CustomFrequencyDistribution;
 
        protected override string POSTData => Samples.CSV.CustomFrequencyDistribution_Data;
        #endregion Set Up and Configuration
    }
 
    [TestClass]
    public sealed class TestSuite_Distribution_CustomSeasonalityDistribution
        : TestSuite_CustomDistribution<CustomSeasonalityDistribution>
    {
        #region Set Up and Configuration
        private const string TypeName = "CustomSeasonalityDistribution";
        protected override IInjectableResource<CustomSeasonalityDistribution>
            TestInjectableResource => Samples.Distribution_CustomSeasonalityDistribution;
 
        protected override string POSTData => Samples.CSV.CustomSeasonalityDistribution_Data;
        #endregion Set Up and Configuration
    }
 
    [TestClass]
    public sealed class TestSuite_Distribution_CustomSeverityDistribution
        : TestSuite_CustomDistribution<CustomSeverityDistribution>
    {
        #region Set Up and Configuration
        private const string TypeName = "CustomSeverityDistribution";
        protected override IInjectableResource<CustomSeverityDistribution>
            TestInjectableResource => Samples.Distribution_CustomSeverityDistribution;
 
        protected override string POSTData => Samples.CSV.CustomSeverityDistribution_Data;
        #endregion Set Up and Configuration
    }
    #endregion CustomDistribution Derived Types Test Classes
 
    #region Other Distribution Test Classes
    [TestClass]
    public sealed class TestSuite_Distribution_BinomialDistribution
        : TestSuite_Distribution<BinomialDistribution>
    {
        #region Set Up and Configuration
        private const string TypeName = "BinomialDistribution";
        protected override IInjectableResource<BinomialDistribution>
            TestInjectableResource => Samples.Distribution_BinomialDistribution;
        #endregion Set Up and Configuration
 
        #region POST
        #region n
        [TestMethod, TestCategory(TypeName)]
        public void Test_BinomialDistribution_POST_N_ValidDomain()
        {
            POST_WithValue(d => d.n, Int32.MaxValue, true);
            POST_WithValue(d => d.n, 0, true);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_BinomialDistribution_POST_N_InvalidDomain()
        {
            POST_WithValue(d => d.n, -1, false);
            POST_WithValue(d => d.n, Int32.MinValue, false);
        }
        #endregion n
 
        #region p
        [TestMethod, TestCategory(TypeName)]
        public void Test_BinomialDistribution_POST_P_ValidDomain()
        {
            POST_WithValue(d => d.p, 1d, true);
            POST_WithValue(d => d.p, 0d, true);
            POST_WithValue(d => d.p, HighPrecisionValue, true);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_BinomialDistribution_POST_P_InvalidDomain()
        {
            // Greater than allowed domain
            POST_WithValue(d => d.p, 1.01, false);
            // Smaller than allowed domain
            POST_WithValue(d => d.p, SmallNegativeDoubleValue, false);
            // Forbidden Special Values
            POST_WithValue(d => d.p, Double.PositiveInfinity, false);
            POST_WithValue(d => d.p, Double.NaN, false);
            POST_WithValue(d => d.p, Double.NegativeInfinity, false);
        }
        #endregion p
        #endregion POST
    }
 
    [TestClass]
    public sealed class TestSuite_Distribution_LogNormalDistribution
        : TestSuite_Distribution<LogNormalDistribution>
    {
        #region Set Up and Configuration
        private const string TypeName = "LogNormalDistribution";
        protected override IInjectableResource<LogNormalDistribution> TestInjectableResource =>
            Samples.Distribution_LogNormalDistribution;
        #endregion Set Up and Configuration
 
        #region POST
        #region location
        [TestMethod, TestCategory(TypeName), TestCategory("Skipped")]
        public void Test_LogNormalDistribution_POST_Location_MaxValue()
        {
            Skip.Indefinitely("ARE-6046: +/-Inf in distributions cause internal errors.");
            POST_WithValue(d => d.location, Double.MaxValue, true);
        }
        [TestMethod, TestCategory(TypeName), TestCategory("Skipped")]
        public void Test_LogNormalDistribution_POST_Location_MinValue()
        {
            Skip.Indefinitely("ARE-6046: +/-Inf in distributions cause internal errors.");
            POST_WithValue(d => d.location, Double.MinValue, true);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_LogNormalDistribution_POST_Location_ValidDomain()
        {
            //POST_WithValue(d => d.location, Double.MaxValue, true);
            POST_WithValue(d => d.location, LargePostiveDoubleValue, true);
            POST_WithValue(d => d.location, HighPrecisionValue, true);
            POST_WithValue(d => d.location, 0d, true);
            POST_WithValue(d => d.location, LargeNegativeDoubleValue, true);
            //POST_WithValue(d => d.location, Double.MinValue, true);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_LogNormalDistribution_POST_Location_InvalidDomain()
        {
            // Forbidden Special Values
            POST_WithValue(d => d.location, Double.PositiveInfinity, false);
            POST_WithValue(d => d.location, Double.NaN, false);
            POST_WithValue(d => d.location, Double.NegativeInfinity, false);
        }
        #endregion location
 
        #region scale
        [TestMethod, TestCategory(TypeName), TestCategory("Skipped")]
        public void Test_LogNormalDistribution_POST_Scale_MaxValue()
        {
            Skip.Indefinitely("ARE-6046: +/-Inf in distributions cause internal errors.");
            POST_WithValue(d => d.scale, Double.MaxValue, true);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_LogNormalDistribution_POST_Scale_ValidDomain()
        {
            //POST_WithValue(d => d.scale, Double.MaxValue, true);
            POST_WithValue(d => d.scale, LargePostiveDoubleValue, true);
            POST_WithValue(d => d.scale, SmallPositiveDoubleValue, true);
            POST_WithValue(d => d.scale, HighPrecisionValue, true);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_LogNormalDistribution_POST_Scale_InvalidDomain()
        {
            // Start of forbidden domain
            POST_WithValue(d => d.scale, 0, false);
            // Forbidden Special Values
            POST_WithValue(d => d.scale, Double.PositiveInfinity, false);
            POST_WithValue(d => d.scale, Double.NaN, false);
            POST_WithValue(d => d.scale, Double.NegativeInfinity, false);
        }
        #endregion scale
        #endregion POST
    }
 
    [TestClass]
    public sealed class TestSuite_Distribution_NegativeBinomialDistribution
        : TestSuite_Distribution<NegativeBinomialDistribution>
    {
        #region Set Up and Configuration
        private const string TypeName = "NegativeBinomialDistribution";
        protected override IInjectableResource<NegativeBinomialDistribution>
            TestInjectableResource => Samples.Distribution_NegativeBinomialDistribution;
        #endregion Set Up and Configuration
 
        #region POST
        #region r
        [TestMethod, TestCategory(TypeName)]
        public void Test_NegativeBinomialDistribution_POST_R_ValidDomain()
        {
            POST_WithValue(d => d.r, Double.MaxValue, true);
            POST_WithValue(d => d.r, SmallPositiveDoubleValue, true);
            POST_WithValue(d => d.r, HighPrecisionValue, true);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_NegativeBinomialDistribution_POST_R_InvalidDomain()
        {
            // Start of forbidden domain
            POST_WithValue(d => d.r, 0, false);
            // Forbidden Special Values
            POST_WithValue(d => d.r, Double.PositiveInfinity, false);
            POST_WithValue(d => d.r, Double.NaN, false);
            POST_WithValue(d => d.r, Double.NegativeInfinity, false);
        }
        #endregion r
 
        #region p
        [TestMethod, TestCategory(TypeName)]
        public void Test_NegativeBinomialDistribution_POST_P_ValidDomain()
        {
            POST_WithValue(d => d.p, 1d, true);
            POST_WithValue(d => d.p, 0d, true);
            POST_WithValue(d => d.p, HighPrecisionValue, true);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_NegativeBinomialDistribution_POST_P_InvalidDomain()
        {
            // Greater than allowed domain
            POST_WithValue(d => d.p, 1.01, false);
            // Smaller than allowed domain
            POST_WithValue(d => d.p, SmallNegativeDoubleValue, false);
            // Forbidden Special Values
            POST_WithValue(d => d.r, Double.PositiveInfinity, false);
            POST_WithValue(d => d.r, Double.NaN, false);
            POST_WithValue(d => d.r, Double.NegativeInfinity, false);
        }
        #endregion p
        #endregion POST
    }
 
    [TestClass]
    public sealed class TestSuite_Distribution_NormalDistribution
        : TestSuite_Distribution<NormalDistribution>
    {
        #region Set Up and Configuration
        private const string TypeName = "NormalDistribution";
        protected override IInjectableResource<NormalDistribution> TestInjectableResource =>
            Samples.Distribution_NormalDistribution;
        #endregion Set Up and Configuration
 
        #region POST
        #region mean
        [TestMethod, TestCategory(TypeName), TestCategory("Skipped")]
        public void Test_NormalDistribution_POST_Mean_MaxValue()
        {
            // TODO: Consolidate with the 'ValidDomain' test when bug is fixed.
            Skip.Indefinitely("ARE-6046: +/-Inf in distributions cause internal errors.");
            POST_WithValue(d => d.mean, Double.MaxValue, true);
        }
        [TestMethod, TestCategory(TypeName), TestCategory("Skipped")]
        public void Test_NormalDistribution_POST_Mean_MinValue()
        {
            // TODO: Consolidate with the 'ValidDomain' test when bug is fixed.
            Skip.Indefinitely("ARE-6046: +/-Inf in distributions cause internal errors.");
            POST_WithValue(d => d.mean, Double.MinValue, false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_NormalDistribution_POST_Mean_ValidDomain()
        {
            POST_WithValue(d => d.mean, LargePostiveDoubleValue, true);
            POST_WithValue(d => d.mean, LargeNegativeDoubleValue, true);
            POST_WithValue(d => d.mean, HighPrecisionValue, true);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_NormalDistribution_POST_Mean_InvalidDomain()
        {
            // Forbidden Special Values
            POST_WithValue(d => d.mean, Double.PositiveInfinity, false);
            POST_WithValue(d => d.mean, Double.NaN, false);
            POST_WithValue(d => d.mean, Double.NegativeInfinity, false);
        }
        #endregion mean
 
        #region stddev
        [TestMethod, TestCategory(TypeName), TestCategory("Skipped")]
        public void Test_NormalDistribution_POST_Stddev_MaxValue()
        {
            // TODO: Consolidate with the 'ValidDomain' test when bug is fixed.
            Skip.Indefinitely("ARE-6046: +/-Inf in distributions cause internal errors.");
            POST_WithValue(d => d.stddev, Double.MaxValue, true);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_NormalDistribution_POST_Stddev_ValidDomain()
        {
            POST_WithValue(d => d.stddev, LargePostiveDoubleValue, true);
            POST_WithValue(d => d.stddev, SmallPositiveDoubleValue, true);
            POST_WithValue(d => d.stddev, HighPrecisionValue, true);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_NormalDistribution_POST_Stddev_InvalidDomain()
        {
            // Start of forbidden domain
            POST_WithValue(d => d.stddev, 0, false);
            // Forbidden Special Values
            POST_WithValue(d => d.stddev, Double.PositiveInfinity, false);
            POST_WithValue(d => d.stddev, Double.NaN, false);
            POST_WithValue(d => d.stddev, Double.NegativeInfinity, false);
        }
        #endregion stddev
        #endregion POST
    }
 
    [TestClass]
    public sealed class TestSuite_Distribution_DiracDistribution
        : TestSuite_Distribution<DiracDistribution>
    {
        #region Set Up and Configuration
        private const string TypeName = "DiracDistribution";
        protected override IInjectableResource<DiracDistribution> TestInjectableResource =>
            Samples.Distribution_DiracDistribution;
        #endregion Set Up and Configuration
 
        #region POST
        #region value
        [TestMethod, TestCategory(TypeName)]
        public void Test_DiracDistribution_POST_Value_ValidDomain()
        {
            POST_WithValue(d => d.value, Double.MaxValue, true);
            POST_WithValue(d => d.value, 0d, true);
            POST_WithValue(d => d.value, Double.MinValue, true);
            POST_WithValue(d => d.value, HighPrecisionValue, true);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_DiracDistribution_POST_Value_InvalidDomain()
        {
            // Forbidden Special Values
            POST_WithValue(d => d.value, Double.PositiveInfinity, false);
            POST_WithValue(d => d.value, Double.NaN, false);
            POST_WithValue(d => d.value, Double.NegativeInfinity, false);
        }
        #endregion value
        #endregion POST
    }
 
    [TestClass]
    public sealed class TestSuite_Distribution_ParetoDistribution
        : TestSuite_Distribution<ParetoDistribution>
    {
        #region Set Up and Configuration
        private const string TypeName = "ParetoDistribution";
        protected override IInjectableResource<ParetoDistribution> TestInjectableResource =>
            Samples.Distribution_ParetoDistribution;
        #endregion Set Up and Configuration
 
        #region POST
        #region shape
        [TestMethod, TestCategory(TypeName), TestCategory("Skipped")]
        public void Test_ParetoDistribution_POST_Shape_MaxValue()
        {
            // TODO: Consolidate with the 'ValidDomain' test when bug is fixed.
            Skip.Indefinitely("ARE-6046: +/-Inf in distributions cause internal errors.");
            POST_WithValue(d => d.shape, Double.MaxValue, true);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_ParetoDistribution_POST_Shape_ValidDomain()
        {
            POST_WithValue(d => d.shape, LargePostiveDoubleValue, true);
            POST_WithValue(d => d.shape, SmallPositiveDoubleValue, true);
            POST_WithValue(d => d.shape, HighPrecisionValue, true);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_ParetoDistribution_POST_Shape_InvalidDomain()
        {
            // Start of forbidden domain
            POST_WithValue(d => d.shape, 0, false);
            // Forbidden Special Values
            POST_WithValue(d => d.shape, Double.PositiveInfinity, false);
            POST_WithValue(d => d.shape, Double.NaN, false);
            POST_WithValue(d => d.shape, Double.NegativeInfinity, false);
        }
        #endregion shape
 
        #region scale
        [TestMethod, TestCategory(TypeName), TestCategory("Skipped")]
        public void Test_ParetoDistribution_POST_Scale_MaxValue()
        {
            // TODO: Consolidate with the 'ValidDomain' test when bug is fixed.
            Skip.Indefinitely("ARE-6046: +/-Inf in distributions cause internal errors.");
            POST_WithValue(d => d.scale, Double.MaxValue, true);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_ParetoDistribution_POST_Scale_ValidDomain()
        {
            POST_WithValue(d => d.scale, LargePostiveDoubleValue, true);
            POST_WithValue(d => d.scale, SmallPositiveDoubleValue, true);
            POST_WithValue(d => d.scale, HighPrecisionValue, true);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_ParetoDistribution_POST_Scale_InvalidDomain()
        {
            // Start of forbidden domain
            POST_WithValue(d => d.scale, 0, false);
            // Forbidden Special Values
            POST_WithValue(d => d.scale, Double.PositiveInfinity, false);
            POST_WithValue(d => d.scale, Double.NaN, false);
            POST_WithValue(d => d.scale, Double.NegativeInfinity, false);
        }
        #endregion scale
        #endregion POST
    }
 
    [TestClass]
    public sealed class TestSuite_Distribution_PoissonDistribution
        : TestSuite_Distribution<PoissonDistribution>
    {
        #region Set Up and Configuration
        private const string TypeName = "PoissonDistribution";
        protected override IInjectableResource<PoissonDistribution> TestInjectableResource =>
            Samples.Distribution_PoissonDistribution;
 
        #endregion Set Up and Configuration
 
        #region POST
        #region mean
        [TestMethod, TestCategory(TypeName)]
        public void Test_PoissonDistribution_POST_Mean_ValidDomain()
        {
            POST_WithValue(d => d.mean, Double.MaxValue, true);
            POST_WithValue(d => d.mean, LargePostiveDoubleValue, true);
            POST_WithValue(d => d.mean, SmallPositiveDoubleValue, true);
            POST_WithValue(d => d.mean, HighPrecisionValue, true);
        }
        [TestMethod, TestCategory(TypeName), TestCategory("Skipped")]
        public void Test_PoissonDistribution_POST_Mean_Zero()
        {
            // TODO: Consolidate with the 'InvalidDomain' test when bug is fixed.
            Skip.UntilRelease.Validation("ARE-6286 - PoissonDistribution.mean " +
                "should not be equal to zero (but API allows it).");
            POST_WithValue(d => d.mean, 0d, false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_PoissonDistribution_POST_Mean_InvalidDomain()
        {
            // Start of forbidden domain
            //POST_WithValue(d => d.mean, 0d, false);
            POST_WithValue(d => d.mean, SmallNegativeDoubleValue, false);
            // Forbidden Special Values
            POST_WithValue(d => d.mean, Double.NaN, false);
            POST_WithValue(d => d.mean, Double.PositiveInfinity, false);
        }
        #endregion mean
        #endregion POST
    }
 
    [TestClass]
    public sealed class TestSuite_Distribution_UniformDistribution
        : TestSuite_Distribution<UniformDistribution>
    {
        #region Set Up and Configuration
        private const string TypeName = "UniformDistribution";
        protected override IInjectableResource<UniformDistribution> TestInjectableResource =>
            Samples.Distribution_UniformDistribution;
        #endregion Set Up and Configuration
 
        #region POST
        #region lower
        [TestMethod, TestCategory(TypeName)]
        public void Test_UniformDistribution_POST_Lower_ValidDomain()
        {
            // Note: We're conscientious not to test with any values >= TestResource.upper
            POST_WithValue(d => d.lower, LargeNegativeDoubleValue, true);
            POST_WithValue(d => d.lower, HighPrecisionValue, true);
            POST_WithValue(d => d.lower, SmallPositiveDoubleValue, true);
            POST_WithValue(d => d.lower, SmallNegativeDoubleValue, true);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_UniformDistribution_POST_Lower_MinValue()
        {
            // TODO: Consolidate with the 'ValidDomain' test when bug is fixed.
            Skip.Indefinitely("ARE-6046: +/-Inf in distributions cause internal errors.");
            POST_WithValue(d => d.lower, Double.MinValue, true);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_UniformDistribution_POST_Lower_InvalidDomain()
        {
            // Forbidden Special Values
            POST_WithValue(d => d.lower, Double.NegativeInfinity, false);
            POST_WithValue(d => d.lower, Double.NaN, false);
        }
        #endregion lower
 
        #region upper
        [TestMethod, TestCategory(TypeName)]
        public void Test_UniformDistribution_POST_Upper_MaxValue()
        {
            // TODO: Consolidate with the 'ValidDomain' test when bug is fixed.
            Skip.Indefinitely("ARE-6046: +/-Inf in distributions cause internal errors.");
            POST_WithValue(d => d.upper, Double.MaxValue, true);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_UniformDistribution_POST_Upper_ValidDomain()
        {
            // Note: We're conscientious not to test with any values <= TestResource.lower
            POST_WithValue(d => d.upper, LargePostiveDoubleValue, true);
            POST_WithValue(d => d.upper, Math.PI, true);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_UniformDistribution_POST_Upper_InvalidDomain()
        {
            // Forbidden Special Values
            POST_WithValue(d => d.upper, Double.PositiveInfinity, false);
            POST_WithValue(d => d.upper, Double.NaN, false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_UniformDistribution_POST_LowerGreaterThanOrEqualToUpper()
        {
            POST_WithValue(d => d.upper, TestResource.lower, false);
            POST_WithValue(d => d.upper, TestResource.lower - 1, false);
            POST_WithValue(d => d.upper, Double.NegativeInfinity, false);
        }
        #endregion upper
        #endregion POST
    }
 
    [TestClass]
    public sealed class TestSuite_Distribution_UniformIntDistribution
        : TestSuite_Distribution<UniformIntDistribution>
    {
        #region Set Up and Configuration
        private const string TypeName = "UniformIntDistribution";
        protected override IInjectableResource<UniformIntDistribution> TestInjectableResource =>
            Samples.Distribution_UniformIntDistribution;
        #endregion Set Up and Configuration
        
        #region POST
        #region lower
        [TestMethod, TestCategory(TypeName)]
        public void Test_UniformIntDistribution_POST_Lower_ValidDomain()
        {
            // Note: We're conscientious not to test with any values >= TestResource.upper
            POST_WithValue(d => d.lower, 1, true);
            POST_WithValue(d => d.lower, 0, true);
        }
 
        [TestMethod, TestCategory(TypeName), TestCategory("Skipped")]
        public void Test_UniformIntDistribution_POST_Lower_InvalidDomain()
        {
            Skip.UntilRelease.Validation("ARE-6282: UniformIntDistribution.lower " +
                "less than 1 is allowed, but causes internal errors.");
            POST_WithValue(d => d.lower, -1, false);
            POST_WithValue(d => d.lower, Int32.MinValue, false);
        }
        #endregion lower
 
        #region upper
        [TestMethod, TestCategory(TypeName)]
        public void Test_UniformIntDistribution_POST_Upper_ValidDomain()
        {
            // Note: We're conscientious not to test with any values <= TestResource.lower
            POST_WithValue(d => d.upper, TestResource.lower + 1, true);
            POST_WithValue(d => d.upper, Int32.MaxValue, true);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_UniformIntDistribution_POST_LowerGreaterThanOrEqualToUpper()
        {
            POST_WithValue(d => d.upper, TestResource.lower, false);
            POST_WithValue(d => d.upper, TestResource.lower - 1, false);
            POST_WithValue(d => d.upper, Int32.MinValue, false);
        }
        #endregion upper
        #endregion POST
    }
    #endregion Other Distribution Test Classes
 
    #region Abstract Base Test Classes
    [TestClass]
    public abstract class TestSuite_CustomDistribution<T> : BaseResourceWithDataTestSuite<T>
        where T : CustomDistribution
    {
        private const string TypeName = "CustomDistribution";
 
        public override void AdditionalValidResourceWithDataTests(T posted) =>
            TestSuite_Distribution_Base.Test_Distribution_Simulatable(posted);
 
        #region POST
        #region modulo
        [TestMethod, TestCategory(TypeName)]
        public void Test_Distribution_POST_Modulo_Null()
        {
            POST_Attribute_Null(d => d.modulo);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Distribution_POST_Modulo_ValidDomain()
        {
            POST_WithValue(d => d.modulo, Double.MaxValue, true);
            POST_WithValue(d => d.modulo, TestSuite_Distribution<T>.HighPrecisionValue, true);
            POST_WithValue(d => d.modulo, TestSuite_Distribution<T>.SmallPositiveDoubleValue, true);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Distribution_POST_Modulo_InvalidDomain()
        {
            // Start of forbidden domain
            POST_WithValue(d => d.modulo, 0d, false);
            // Forbidden Special Values
            POST_WithValue(d => d.modulo, Double.PositiveInfinity, false);
            POST_WithValue(d => d.modulo, Double.NaN, false);
        }
        #endregion modulo
 
        #region interpolate
        // Nothing to test on post, Booleans are pretty simple
        #endregion interpolate
        #endregion POST
 
        #region PUT
        #region modulo
        [TestMethod, TestCategory(TypeName)]
        public void Test_CustomDistribution_PUT_Modulo_Null()
        {
            PUT_Attribute_Null(d => d.modulo);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_CustomDistribution_PUT_Modulo()
        {
            PUT_WithValue(d => d.modulo, 1234.56789, true);
        }
        #endregion modulo
 
        #region interpolate
        [TestMethod, TestCategory(TypeName)]
        public void Test_CustomDistribution_PUT_Interpolate()
        {
            PUT_WithValue(d => d.interpolate, !TestResource.interpolate, true);
        }
        #endregion interpolate
        #endregion PUT
    }
 
    [TestClass]
    public abstract class TestSuite_Distribution<T> : BaseImmutableResourceTestSuite<T> where T : Distribution
    {
        private const string TypeName = "Distribution";
 
        // Constants used for boundary testing
        public const double LargePostiveDoubleValue = 1e100;
        public const double SmallPositiveDoubleValue = 1e-100;
        public const double LargeNegativeDoubleValue = -1e100;
        public const double SmallNegativeDoubleValue = -1e-100;
        public const double HighPrecisionValue = Math.PI / 1E12;
 
        public override void AdditionalValidResourceTests(T posted) =>
            TestSuite_Distribution_Base.Test_Distribution_Simulatable(posted);
 
        #region POST
        #region modulo
        [TestMethod, TestCategory(TypeName)]
        public void Test_Distribution_POST_Modulo_Null()
        {
            POST_Attribute_Null(d => d.modulo);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Distribution_POST_Modulo_ValidDomain()
        {
            POST_WithValue(d => d.modulo, HighPrecisionValue, true);
            POST_WithValue(d => d.modulo, Double.MaxValue, true);
            POST_WithValue(d => d.modulo, SmallPositiveDoubleValue, true);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_Distribution_POST_Modulo_InvalidDomain()
        {
            // Start of forbidden domain
            POST_WithValue(d => d.modulo, 0d, false);
            // Forbidden Special Values
            POST_WithValue(d => d.modulo, Double.PositiveInfinity, false);
            POST_WithValue(d => d.modulo, Double.NaN, false);
        }
        #endregion modulo
        #endregion POST
    }
    #endregion Abstract Base Test Classes
}