//-------------------------------------------------------------------------
        public virtual void test_cashFlowEquivalentAndSensitivity()
        {
            ResolvedSwap swap = ResolvedSwap.of(IBOR_LEG, FIXED_LEG);
            ImmutableMap <Payment, PointSensitivityBuilder> computedFull = CashFlowEquivalentCalculator.cashFlowEquivalentAndSensitivitySwap(swap, PROVIDER);
            ImmutableList <Payment> keyComputedFull = computedFull.Keys.asList();
            ImmutableList <PointSensitivityBuilder>         valueComputedFull = computedFull.values().asList();
            ImmutableMap <Payment, PointSensitivityBuilder> computedIborLeg   = CashFlowEquivalentCalculator.cashFlowEquivalentAndSensitivityIborLeg(IBOR_LEG, PROVIDER);
            ImmutableMap <Payment, PointSensitivityBuilder> computedFixedLeg  = CashFlowEquivalentCalculator.cashFlowEquivalentAndSensitivityFixedLeg(FIXED_LEG, PROVIDER);

            assertEquals(computedFixedLeg.Keys.asList(), keyComputedFull.subList(0, 2));
            assertEquals(computedIborLeg.Keys.asList(), keyComputedFull.subList(2, 6));
            assertEquals(computedFixedLeg.values().asList(), valueComputedFull.subList(0, 2));
            assertEquals(computedIborLeg.values().asList(), valueComputedFull.subList(2, 6));

            double eps = 1.0e-7;
            RatesFiniteDifferenceSensitivityCalculator calc = new RatesFiniteDifferenceSensitivityCalculator(eps);
            int size = keyComputedFull.size();

            for (int i = 0; i < size; ++i)
            {
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final int index = i;
                int index = i;
                CurrencyParameterSensitivities expected = calc.sensitivity(PROVIDER, p => ((NotionalExchange)CashFlowEquivalentCalculator.cashFlowEquivalentSwap(swap, p).PaymentEvents.get(index)).PaymentAmount);
                SwapPaymentEvent               @event   = CashFlowEquivalentCalculator.cashFlowEquivalentSwap(swap, PROVIDER).PaymentEvents.get(index);
                PointSensitivityBuilder        point    = computedFull.get(((NotionalExchange)@event).Payment);
                CurrencyParameterSensitivities computed = PROVIDER.parameterSensitivity(point.build());
                assertTrue(computed.equalWithTolerance(expected, eps * NOTIONAL));
            }
        }
        public virtual void test_cashFlowEquivalent_pv()
        {
            ResolvedSwap                 swap       = ResolvedSwap.of(IBOR_LEG, FIXED_LEG);
            ResolvedSwapLeg              cfe        = CashFlowEquivalentCalculator.cashFlowEquivalentSwap(swap, PROVIDER);
            DiscountingSwapLegPricer     pricerLeg  = DiscountingSwapLegPricer.DEFAULT;
            DiscountingSwapProductPricer pricerSwap = DiscountingSwapProductPricer.DEFAULT;
            CurrencyAmount               pvCfe      = pricerLeg.presentValue(cfe, PROVIDER);
            MultiCurrencyAmount          pvSwap     = pricerSwap.presentValue(swap, PROVIDER);

            assertEquals(pvCfe.Amount, pvSwap.getAmount(GBP).Amount, TOLERANCE_PV);
        }
        public virtual void test_cashFlowEquivalent_wrongSwap()
        {
            ResolvedSwap swap1 = ResolvedSwap.of(IBOR_LEG, FIXED_LEG, IBOR_LEG);

            assertThrowsIllegalArg(() => CashFlowEquivalentCalculator.cashFlowEquivalentSwap(swap1, PROVIDER));
            ResolvedSwap swap2 = ResolvedSwap.of(FIXED_LEG, FIXED_LEG);

            assertThrowsIllegalArg(() => CashFlowEquivalentCalculator.cashFlowEquivalentSwap(swap2, PROVIDER));
            ResolvedSwap swap3 = ResolvedSwap.of(FIXED_LEG, CashFlowEquivalentCalculator.cashFlowEquivalentIborLeg(IBOR_LEG, PROVIDER));

            assertThrowsIllegalArg(() => CashFlowEquivalentCalculator.cashFlowEquivalentSwap(swap3, PROVIDER));
        }
        public virtual void test_cashFlowEquivalent_compounding()
        {
            RatePaymentPeriod iborCmp    = RatePaymentPeriod.builder().paymentDate(PAYMENT2).accrualPeriods(IBOR1, IBOR2).dayCount(ACT_365F).currency(GBP).notional(-NOTIONAL).build();
            ResolvedSwapLeg   iborLegCmp = ResolvedSwapLeg.builder().type(IBOR).payReceive(PAY).paymentPeriods(iborCmp).build();
            ResolvedSwap      swap1      = ResolvedSwap.of(iborLegCmp, FIXED_LEG);

            assertThrowsIllegalArg(() => CashFlowEquivalentCalculator.cashFlowEquivalentSwap(swap1, PROVIDER));
            RatePaymentPeriod fixedCmp    = RatePaymentPeriod.builder().paymentDate(PAYMENT2).accrualPeriods(FIXED1, FIXED2).dayCount(ACT_365F).currency(GBP).notional(NOTIONAL).build();
            ResolvedSwapLeg   fixedLegCmp = ResolvedSwapLeg.builder().type(FIXED).payReceive(RECEIVE).paymentPeriods(fixedCmp).build();
            ResolvedSwap      swap2       = ResolvedSwap.of(IBOR_LEG, fixedLegCmp);

            assertThrowsIllegalArg(() => CashFlowEquivalentCalculator.cashFlowEquivalentSwap(swap2, PROVIDER));
        }
        public virtual void test_cashFlowEquivalent()
        {
            ResolvedSwap    swap             = ResolvedSwap.of(IBOR_LEG, FIXED_LEG);
            ResolvedSwapLeg computed         = CashFlowEquivalentCalculator.cashFlowEquivalentSwap(swap, PROVIDER);
            ResolvedSwapLeg computedIborLeg  = CashFlowEquivalentCalculator.cashFlowEquivalentIborLeg(IBOR_LEG, PROVIDER);
            ResolvedSwapLeg computedFixedLeg = CashFlowEquivalentCalculator.cashFlowEquivalentFixedLeg(FIXED_LEG, PROVIDER);

            assertEquals(computedFixedLeg.PaymentEvents, computed.PaymentEvents.subList(0, 2));
            assertEquals(computedIborLeg.PaymentEvents, computed.PaymentEvents.subList(2, 6));

            // expected payments from fixed leg
            NotionalExchange fixedPayment1 = NotionalExchange.of(CurrencyAmount.of(GBP, NOTIONAL * RATE * PAY_YC1), PAYMENT1);
            NotionalExchange fixedPayment2 = NotionalExchange.of(CurrencyAmount.of(GBP, NOTIONAL * RATE * PAY_YC2), PAYMENT2);
            // expected payments from ibor leg
            LocalDate        fixingSTART1       = GBP_LIBOR_3M.calculateEffectiveFromFixing(FIXING1, REF_DATA);
            double           fixedYearFraction1 = GBP_LIBOR_3M.DayCount.relativeYearFraction(fixingSTART1, GBP_LIBOR_3M.calculateMaturityFromEffective(fixingSTART1, REF_DATA));
            double           beta1              = (1d + fixedYearFraction1 * PROVIDER.iborIndexRates(GBP_LIBOR_3M).rate(GBP_LIBOR_3M_COMP1.Observation)) * PROVIDER.discountFactor(GBP, PAYMENT1) / PROVIDER.discountFactor(GBP, fixingSTART1);
            NotionalExchange iborPayment11      = NotionalExchange.of(CurrencyAmount.of(GBP, -NOTIONAL * beta1 * PAY_YC1 / fixedYearFraction1), fixingSTART1);
            NotionalExchange iborPayment12      = NotionalExchange.of(CurrencyAmount.of(GBP, NOTIONAL * PAY_YC1 / fixedYearFraction1), PAYMENT1);
            LocalDate        fixingSTART2       = GBP_LIBOR_3M.calculateEffectiveFromFixing(FIXING2, REF_DATA);
            double           fixedYearFraction2 = GBP_LIBOR_3M.DayCount.relativeYearFraction(fixingSTART2, GBP_LIBOR_3M.calculateMaturityFromEffective(fixingSTART2, REF_DATA));
            double           beta2              = (1d + fixedYearFraction2 * PROVIDER.iborIndexRates(GBP_LIBOR_3M).rate(GBP_LIBOR_3M_COMP2.Observation)) * PROVIDER.discountFactor(GBP, PAYMENT2) / PROVIDER.discountFactor(GBP, fixingSTART2);
            NotionalExchange iborPayment21      = NotionalExchange.of(CurrencyAmount.of(GBP, -NOTIONAL * beta2 * PAY_YC2 / fixedYearFraction2), fixingSTART2);
            NotionalExchange iborPayment22      = NotionalExchange.of(CurrencyAmount.of(GBP, NOTIONAL * PAY_YC2 / fixedYearFraction2), PAYMENT2);

            ResolvedSwapLeg expected = ResolvedSwapLeg.builder().type(OTHER).payReceive(RECEIVE).paymentEvents(fixedPayment1, fixedPayment2, iborPayment11, iborPayment12, iborPayment21, iborPayment22).build();

            double eps = 1.0e-12;

            assertEquals(computed.PaymentEvents.size(), expected.PaymentEvents.size());
            for (int i = 0; i < 6; ++i)
            {
                NotionalExchange payCmp = (NotionalExchange)computed.PaymentEvents.get(i);
                NotionalExchange payExp = (NotionalExchange)expected.PaymentEvents.get(i);
                assertEquals(payCmp.Currency, payExp.Currency);
                assertEquals(payCmp.PaymentDate, payExp.PaymentDate);
                assertTrue(DoubleMath.fuzzyEquals(payCmp.PaymentAmount.Amount, payExp.PaymentAmount.Amount, NOTIONAL * eps));
            }
        }