Test_DataTypes.cs

Go to the documentation of this file.

using System.Collections.Generic;
using AnalyzeRe;
using AnalyzeRe.Fees;
using AnalyzeRe.Layers;
using AnalyzeReTesting.Base;
 
#if MSTEST
using Microsoft.VisualStudio.TestTools.UnitTesting;
#elif NUNIT
using NUnit.Framework;
using TestClass = NUnit.Framework.TestFixtureAttribute;
using TestMethod = NUnit.Framework.TestAttribute;
#endif
 
namespace AnalyzeReTesting.Tests.Model.DataTypes
{
    [TestClass]
    public sealed class TestSuite_DataTypes : BaseClientTestSuite
    {
        [TestMethod]
        public void Test_Policy_Equatable()
        {
            Policy first = Samples.Policy;
            Assert.IsTrue(first.Equals(first));
            Policy second = Samples.Policy.DeepCopy();
            Assert.IsTrue(first.Equals(second));
            Assert.IsTrue(second.Equals(first));
            Assert.AreEqual(first.GetHashCode(), second.GetHashCode());
 
            second = Samples.ForwardAllPolicy;
            Assert.IsFalse(first.Equals(second));
            Assert.AreNotEqual(first.GetHashCode(), second.GetHashCode());
 
            first = Samples.TransformAllPolicy;
            Assert.IsFalse(first.Equals(second));
            Assert.AreNotEqual(first.GetHashCode(), second.GetHashCode());
 
            // Assert that order of RecordType lists doesn't matter
            first = new Policy
            {
                transform_records = new HashSet<RecordType> { RecordType.Loss, RecordType.FixedExpense }
            };
            second = new Policy
            {
                transform_records = new HashSet<RecordType> { RecordType.FixedExpense, RecordType.Loss }
            };
            Assert.IsTrue(first.Equals(second));
            Assert.AreEqual(first.GetHashCode(), second.GetHashCode());
 
            first.forward_records.Add(RecordType.ProportionalExpense);
            second.forward_records.Add(RecordType.NoClaimsBonus);
            Assert.IsFalse(first.Equals(second));
            Assert.AreNotEqual(first.GetHashCode(), second.GetHashCode());
 
            first.forward_records.Add(RecordType.NoClaimsBonus);
            second.forward_records.Add(RecordType.ProportionalExpense);
            Assert.IsTrue(first.Equals(second));
            Assert.AreEqual(first.GetHashCode(), second.GetHashCode());
        }
 
        [TestMethod]
        public void Test_Fee_Equatable()
        {
            Fee first = Samples.Fees.ProportionalExpense;
            Assert.IsTrue(first.Equals(first));
            Fee second = first.DeepCopy();
            Assert.IsTrue(first.Equals(second));
            Assert.IsTrue(second.Equals(first));
            Assert.AreEqual(first.GetHashCode(), second.GetHashCode());
 
            second = Samples.Fees.FixedExpense;
            Assert.IsFalse(first.Equals(second));
            Assert.AreNotEqual(first.GetHashCode(), second.GetHashCode());
 
            first = Samples.Fees.ProfitCommission;
            Assert.IsFalse(first.Equals(second));
            Assert.AreNotEqual(first.GetHashCode(), second.GetHashCode());
 
            // Assert that order of fee reference lists doesn't matter
            first = new ProfitCommission
            {
                premiums = new List<FeeReference>{ FeeReference.Premium, FeeReference.ReinstatementPremium }
            };
            second = new ProfitCommission
            {
                premiums = new List<FeeReference> { FeeReference.ReinstatementPremium, FeeReference.Premium }
            };
            Assert.IsTrue(first.Equals(second));
            Assert.AreEqual(first.GetHashCode(), second.GetHashCode());
        }
 
        [TestMethod]
        public void Test_FeeReference_Equatable()
        {
            FeeReference empty = new FeeReference();
            Assert.IsFalse(empty.Equals(null));
            Assert.IsTrue(empty.Equals(empty));
            Assert.IsTrue(empty.Equals(new FeeReference()));
            Assert.AreEqual(empty.GetHashCode(), empty.GetHashCode());
            Assert.AreEqual(empty.GetHashCode(), new FeeReference().GetHashCode());
 
            FeeReference sample = FeeReference.Losses;
            Assert.IsFalse(sample.Equals(null));
            Assert.IsFalse(sample.Equals(empty));
            Assert.IsTrue(sample.Equals(sample));
            Assert.IsTrue(sample.Equals(FeeReference.Losses));
            Assert.AreEqual(sample.GetHashCode(), sample.GetHashCode());
            Assert.AreEqual(sample.GetHashCode(), FeeReference.Losses.GetHashCode());
            Assert.AreNotEqual(sample.GetHashCode(), empty.GetHashCode());
            
            Assert.AreNotEqual(FeeReference.Losses, FeeReference.Premium);
            Assert.AreNotEqual(FeeReference.Losses, FeeReference.ReinstatementBrokerage);
            Assert.AreNotEqual(FeeReference.Losses, FeeReference.ReinstatementPremium);
            Assert.AreNotEqual(FeeReference.Premium, FeeReference.ReinstatementBrokerage);
            Assert.AreNotEqual(FeeReference.Premium, FeeReference.ReinstatementPremium);
            Assert.AreNotEqual(FeeReference.ReinstatementBrokerage, FeeReference.ReinstatementPremium);
 
            Assert.AreNotEqual(FeeReference.Losses.GetHashCode(), FeeReference.Premium.GetHashCode());
            Assert.AreNotEqual(FeeReference.Losses.GetHashCode(), FeeReference.ReinstatementBrokerage.GetHashCode());
            Assert.AreNotEqual(FeeReference.Losses.GetHashCode(), FeeReference.ReinstatementPremium.GetHashCode());
            Assert.AreNotEqual(FeeReference.Premium.GetHashCode(), FeeReference.ReinstatementBrokerage.GetHashCode());
            Assert.AreNotEqual(FeeReference.Premium.GetHashCode(), FeeReference.ReinstatementPremium.GetHashCode());
            Assert.AreNotEqual(FeeReference.ReinstatementBrokerage.GetHashCode(), FeeReference.ReinstatementPremium.GetHashCode());
 
            Assert.AreEqual(FeeReference.Losses, FeeReference.CreateFromPremiumOrLossName("Losses"));
            Assert.AreEqual(FeeReference.CreateFromFeeName("Losses"), FeeReference.CreateFromFeeName("Losses"));
            Assert.AreNotEqual(FeeReference.Losses, FeeReference.CreateFromFeeName("Losses"));
            Assert.AreNotEqual(FeeReference.CreateFromPremiumOrLossName("Losses"), FeeReference.CreateFromFeeName("Losses"));
        }
 
        [TestMethod]
        public void Test_Payment_Equatable()
        {
            DelayedPayment.Payment empty = new DelayedPayment.Payment();
            Assert.IsFalse(empty.Equals(null));
            Assert.IsTrue(empty.Equals(empty));
            Assert.IsTrue(empty.Equals(new DelayedPayment.Payment()));
            Assert.AreEqual(empty.GetHashCode(), empty.GetHashCode());
            Assert.AreEqual(empty.GetHashCode(), new DelayedPayment.Payment().GetHashCode());
 
            DelayedPayment.Payment sample = new DelayedPayment.Payment(123, 0.123);
            Assert.IsFalse(sample.Equals(null));
            Assert.IsFalse(sample.Equals(empty));
            Assert.IsTrue(sample.Equals(sample));
            Assert.IsTrue(sample.Equals(new DelayedPayment.Payment(123, 0.123)));
            Assert.AreEqual(sample.GetHashCode(), sample.GetHashCode());
            Assert.AreEqual(sample.GetHashCode(), new DelayedPayment.Payment(123, 0.123).GetHashCode());
            Assert.AreNotEqual(sample.GetHashCode(), empty.GetHashCode());
        }
    }
}