public void TestCreateDeals_CheckCorrectCount()
        {
            List <Deal> ListofDeals       = Deal.CreateDeals();
            int         TotalNumerOfDeals = ListofDeals.Count;

            Assert.AreEqual(TotalNumerOfDeals, 3);
        }
        public void TestCalculateLossForEvent2_MatchOneDeal()
        {
            List <Deal> ListofDeals = Deal.CreateDeals();

            int[] Event = new[] { 2, 3, 2, 500 }; //event2
            List <DealLossResult> reInsureanceLossResultList = ReinsuranceCalculations.CalculateLossForEvent(Event, ListofDeals);

            Assert.AreEqual <int>(reInsureanceLossResultList.Count, 1);
        }
        public void TestCalculateLossForNewEventWithNewRegionAndPeril_NoDealIsmatched()
        {
            List <Deal> ListofDeals = Deal.CreateDeals();

            int[] Event = new[] { 5, 4, 4, 2000 }; //event5
            List <DealLossResult> reInsureanceLossResultList = ReinsuranceCalculations.CalculateLossForEvent(Event, ListofDeals);

            Assert.AreEqual <int>(0, reInsureanceLossResultList.Count);
        }
        public void TestCalculateLossForEvent2_MatchsDeal3ID()
        {
            List <Deal> ListofDeals = Deal.CreateDeals();

            int[] Event = new[] { 2, 3, 2, 500 }; //event2
            List <DealLossResult> reInsureanceLossResultList = ReinsuranceCalculations.CalculateLossForEvent(Event, ListofDeals);
            DealLossResult        dlr = reInsureanceLossResultList.FirstOrDefault();

            Assert.AreEqual <int>(3, dlr.DealId);
        }
        public void TestCalculateLossForEvent1_ReturnsLoss500()
        {
            List <Deal> ListofDeals = Deal.CreateDeals();

            int[] Event = new[] { 1, 2, 1, 1000 }; //event1
            List <DealLossResult> reInsureanceLossResultList = ReinsuranceCalculations.CalculateLossForEvent(Event, ListofDeals);
            DealLossResult        dlr = reInsureanceLossResultList.FirstOrDefault();

            Assert.AreEqual <int>(500, dlr.DealLoss);
        }
        public void TestCalculateLossForEvent4_MatchsDeal3()
        {
            List <Deal> ListofDeals = Deal.CreateDeals();

            int[] Event = new[] { 4, 1, 3, 2000 }; //event4
            List <DealLossResult>        reInsureanceLossResultList          = ReinsuranceCalculations.CalculateLossForEvent(Event, ListofDeals);
            IEnumerable <DealLossResult> reInsureanceLossResultListWithDeal3 = reInsureanceLossResultList.Where(d => d.DealId == 3);

            Assert.IsTrue(reInsureanceLossResultListWithDeal3.ToList().Count > 0, "Event 4 does not match with deal 3");
        }
        public void TestCalculateLossForEvent3_ReturnsEventID3()
        {
            List <Deal> ListofDeals = Deal.CreateDeals();

            int[] Event = new[] { 3, 3, 3, 750 }; //event3
            List <DealLossResult> reInsureanceLossResultList = ReinsuranceCalculations.CalculateLossForEvent(Event, ListofDeals);
            DealLossResult        dlr = reInsureanceLossResultList.FirstOrDefault();

            Assert.AreEqual <int>(3, dlr.EventId);
        }
        public void TestCalculateLossForEvent4_MatchDeal3ReturnsLoss250()
        {
            List <Deal> ListofDeals = Deal.CreateDeals();

            int[] Event = new[] { 4, 1, 3, 2000 }; //event4
            List <DealLossResult>        reInsureanceLossResultList          = ReinsuranceCalculations.CalculateLossForEvent(Event, ListofDeals);
            IEnumerable <DealLossResult> reInsureanceLossResultListWithDeal3 = reInsureanceLossResultList.Where(d => d.DealId == 3);
            DealLossResult dlr = reInsureanceLossResultListWithDeal3.ToList().FirstOrDefault();

            Assert.AreEqual <int>(250, dlr.DealLoss);
        }
        public void TestCreateDeals_Deal3Limit_retentionIsNotNull()
        {
            List <Deal> ListofDeals = Deal.CreateDeals();

            if (ListofDeals.Count > 0)
            {
                Deal   Deal3           = ListofDeals[2];
                string Limit_retention = Deal3.Limit_retention;
                Assert.IsNotNull(Limit_retention);
            }
            else
            {
                Assert.Fail("CreateDeals returns empty list");
            }
        }
        public void TestCreateDeals_Deal1IDIsNotZero()
        {
            List <Deal> ListofDeals = Deal.CreateDeals();

            if (ListofDeals.Count > 0)
            {
                Deal Deal1   = ListofDeals[0];
                int  Deal1ID = Deal1.ID;
                Assert.AreNotEqual <int>(0, Deal1ID);
            }
            else
            {
                Assert.Fail("CreateDeals returns empty list");
            }
        }
        public void TestCreateDeals_Deal1ListOfPerilsValuesIsNotGreaterThan3()
        {
            List <Deal> ListofDeals = Deal.CreateDeals();

            if (ListofDeals.Count > 0)
            {
                Deal       Deal1          = ListofDeals[0];
                List <int> Deal1Perils    = Deal1.ListOfPerils;
                int        MaxDeal1Perils = Deal1Perils.Max();
                Assert.IsTrue(MaxDeal1Perils <= 3, "Peril for Deal is greater than 3");
            }
            else
            {
                Assert.Fail("CreateDeals returns empty list");
            }
        }
        public void TestCreateDeals_Deal1ListOfRegionsValuesIsNotlessThan1()
        {
            List <Deal> ListofDeals = Deal.CreateDeals();

            if (ListofDeals.Count > 0)
            {
                Deal       Deal1          = ListofDeals[0];
                List <int> Deal1Regions   = Deal1.ListOfRegions;
                int        MinDeal1Region = Deal1Regions.Min();
                Assert.IsTrue(MinDeal1Region >= 1, "Region for Deal is less than 1");
            }
            else
            {
                Assert.Fail("CreateDeals returns empty list");
            }
        }
        public void TestCreateDeals_Deal3ListOfPerilsValuesIsNotLessThan1()
        {
            List <Deal> ListofDeals = Deal.CreateDeals();

            if (ListofDeals.Count > 0)
            {
                Deal       Deal3          = ListofDeals[2];
                List <int> Deal3Perils    = Deal3.ListOfPerils;
                int        MinDeal3Perils = Deal3Perils.Min();
                Assert.IsTrue(MinDeal3Perils >= 1, "Peril for Deal is less than 1");
            }
            else
            {
                Assert.Fail("CreateDeals returns empty list");
            }
        }
        public void TestCreateDeals_Deal3ListOfRegionsValuesIsNotGreaterThan3()
        {
            List <Deal> ListofDeals = Deal.CreateDeals();

            if (ListofDeals.Count > 0)
            {
                Deal       Deal3          = ListofDeals[2];
                List <int> Deal3Regions   = Deal3.ListOfRegions;
                int        MaxDeal3Region = Deal3Regions.Max();
                Assert.IsTrue(MaxDeal3Region <= 3, "Region for Deal is greater than 3");
            }
            else
            {
                Assert.Fail("CreateDeals returns empty list");
            }
        }
        public void TestCalculateLossForEvent4_ReturnsEventID4()
        {
            bool        EventIDIs4  = true;
            List <Deal> ListofDeals = Deal.CreateDeals();

            int[] Event = new[] { 4, 1, 3, 2000 }; //event4
            List <DealLossResult> reInsureanceLossResultList = ReinsuranceCalculations.CalculateLossForEvent(Event, ListofDeals);

            foreach (DealLossResult dlr in reInsureanceLossResultList)
            {
                if (dlr.EventId != 4)
                {
                    EventIDIs4 = false;
                }
            }
            Assert.IsTrue(EventIDIs4, "Event ID is not 4");
        }