// Checks that the NDF present value is coherent with the standard FX forward present value. public virtual void test_presentValueVsForex() { CurrencyAmount pvNDF = PRICER.presentValue(NDF, PROVIDER); MultiCurrencyAmount pvFX = PRICER_FX.presentValue(FOREX, PROVIDER); assertEquals(pvNDF.Amount, pvFX.getAmount(USD).Amount + pvFX.getAmount(KRW).Amount *FX_MATRIX.fxRate(KRW, USD), NOMINAL_USD * TOL); }
// Checks that the NDF currency exposure is coherent with the standard FX forward present value. public virtual void test_currencyExposureVsForex() { MultiCurrencyAmount pvNDF = PRICER.currencyExposure(NDF, PROVIDER); MultiCurrencyAmount pvFX = PRICER_FX.currencyExposure(FOREX, PROVIDER); assertEquals(pvNDF.getAmount(USD).Amount, pvFX.getAmount(USD).Amount, NOMINAL_USD * TOL); assertEquals(pvNDF.getAmount(KRW).Amount, pvFX.getAmount(KRW).Amount, NOMINAL_USD * TOL * FX_MATRIX.fxRate(USD, KRW)); }
public virtual void test_currencyExposure() { MultiCurrencyAmount ceComputed = PRICER_TRADE.currencyExposure(OPTION_TRADE, RATES_PROVIDER, VOLS); MultiCurrencyAmount ceExpected = PRICER_PRODUCT.currencyExposure(OPTION_PRODUCT, RATES_PROVIDER, VOLS).plus(PRICER_PAYMENT.presentValue(PREMIUM, RATES_PROVIDER)); assertEquals(ceComputed.size(), 2); assertEquals(ceComputed.getAmount(EUR).Amount, ceExpected.getAmount(EUR).Amount, TOL * NOTIONAL); assertEquals(ceComputed.getAmount(USD).Amount, ceExpected.getAmount(USD).Amount, TOL * NOTIONAL); }
public virtual void test_presentValue() { MultiCurrencyAmount computed = PRICER.presentValue(FWD, PROVIDER); double expected1 = NOMINAL_USD * PROVIDER.discountFactor(USD, PAYMENT_DATE); double expected2 = -NOMINAL_USD *FX_RATE *PROVIDER.discountFactor(KRW, PAYMENT_DATE); assertEquals(computed.getAmount(USD).Amount, expected1, NOMINAL_USD * TOL); assertEquals(computed.getAmount(KRW).Amount, expected2, NOMINAL_USD * TOL); }
//------------------------------------------------------------------------- public virtual void test_currencyExposure() { MultiCurrencyAmount computedPricer = PRICER.currencyExposure(CALL_OTM, RATES_PROVIDER, VOLS); CurrencyAmount pv = PRICER.presentValue(CALL_OTM, RATES_PROVIDER, VOLS); PointSensitivities point = PRICER.presentValueSensitivityRatesStickyStrike(CALL_OTM, RATES_PROVIDER, VOLS); MultiCurrencyAmount computedPoint = RATES_PROVIDER.currencyExposure(point).plus(pv); assertEquals(computedPricer.getAmount(EUR).Amount, computedPoint.getAmount(EUR).Amount, NOTIONAL * TOL); assertEquals(computedPricer.getAmount(USD).Amount, computedPoint.getAmount(USD).Amount, NOTIONAL * TOL); }
public virtual void test_currencyExposure_from_pt_sensitivity_inverse() { MultiCurrencyAmount ceDirect = PRICER.currencyExposure(NDF_INVERSE, PROVIDER); PointSensitivities pts = PRICER.presentValueSensitivity(NDF_INVERSE, PROVIDER); MultiCurrencyAmount cePts = PROVIDER.currencyExposure(pts); CurrencyAmount cePv = PRICER.presentValue(NDF_INVERSE, PROVIDER); MultiCurrencyAmount ceExpected = cePts.plus(cePv); assertEquals(ceDirect.getAmount(USD).Amount, ceExpected.getAmount(USD).Amount, NOMINAL_USD * TOL); assertEquals(ceDirect.getAmount(KRW).Amount, ceExpected.getAmount(KRW).Amount, NOMINAL_USD * TOL * FX_MATRIX.fxRate(USD, KRW)); }
public virtual void test_currencyExposure() { MultiCurrencyAmount ceComputed = PRICER_TRADE.currencyExposure(OPTION_TRADE, RATES_PROVIDER, VOLS); PointSensitivities point = PRICER_TRADE.presentValueSensitivityRatesStickyStrike(OPTION_TRADE, RATES_PROVIDER, VOLS); MultiCurrencyAmount pv = PRICER_TRADE.presentValue(OPTION_TRADE, RATES_PROVIDER, VOLS); MultiCurrencyAmount ceExpected = RATES_PROVIDER.currencyExposure(point).plus(pv); assertEquals(ceComputed.size(), 2); assertEquals(ceComputed.getAmount(EUR).Amount, ceExpected.getAmount(EUR).Amount, TOL * NOTIONAL); assertEquals(ceComputed.getAmount(USD).Amount, ceExpected.getAmount(USD).Amount, TOL * NOTIONAL); }
//------------------------------------------------------------------------- public virtual void test_presentValue_beforeStart() { MultiCurrencyAmount computed = PRICER.presentValue(SWAP_PRODUCT, PROVIDER); double expected_usd = NOMINAL_USD * (PROVIDER.discountFactor(USD, PAYMENT_DATE_NEAR) - PROVIDER.discountFactor(USD, PAYMENT_DATE_FAR)); double expected_krw = NOMINAL_USD * (-FX_RATE * PROVIDER.discountFactor(KRW, PAYMENT_DATE_NEAR) + (FX_RATE + FX_FWD_POINTS) * PROVIDER.discountFactor(KRW, PAYMENT_DATE_FAR)); assertEquals(computed.getAmount(USD).Amount, expected_usd, NOMINAL_USD * TOL); assertEquals(computed.getAmount(KRW).Amount, expected_krw, NOMINAL_USD * FX_RATE * TOL); // currency exposure MultiCurrencyAmount exposure = PRICER.currencyExposure(SWAP_PRODUCT, PROVIDER); assertEquals(exposure, computed); }
public virtual void test_presentValue_started() { ResolvedFxSwap product = ResolvedFxSwap.ofForwardPoints(CurrencyAmount.of(USD, NOMINAL_USD), KRW, FX_RATE, FX_FWD_POINTS, PAYMENT_DATE_PAST, PAYMENT_DATE_NEAR); MultiCurrencyAmount computed = PRICER.presentValue(product, PROVIDER); double expected_usd = -NOMINAL_USD *PROVIDER.discountFactor(USD, PAYMENT_DATE_NEAR); double expected_krw = NOMINAL_USD * (FX_RATE + FX_FWD_POINTS) * PROVIDER.discountFactor(KRW, PAYMENT_DATE_NEAR); assertEquals(computed.getAmount(USD).Amount, expected_usd, NOMINAL_USD * TOL); assertEquals(computed.getAmount(KRW).Amount, expected_krw, NOMINAL_USD * FX_RATE * TOL); // currency exposure MultiCurrencyAmount exposure = PRICER.currencyExposure(product, PROVIDER); assertEquals(exposure, computed); }
//------------------------------------------------------------------------- public virtual void currency_exposure_premium_forward() { CurrencyAmount pv = PRICER_TRADE.presentValue(SWAPTION_PREFWD_LONG_REC, MULTI_USD, NORMAL_VOLS_USD); MultiCurrencyAmount ce = PRICER_TRADE.currencyExposure(SWAPTION_PREFWD_LONG_REC, MULTI_USD, NORMAL_VOLS_USD); assertEquals(pv.Amount, ce.getAmount(USD).Amount, TOLERANCE_PV); }
//------------------------------------------------------------------------- public virtual void currency_exposure_premium_forward() { CurrencyAmount pv = PRICER_TRADE.presentValue(SWAPTION_PREFWD_LONG_REC, RATE_PROVIDER, VOLS); MultiCurrencyAmount ce = PRICER_TRADE.currencyExposure(SWAPTION_PREFWD_LONG_REC, RATE_PROVIDER, VOLS); assertEquals(pv.Amount, ce.getAmount(USD).Amount, NOTIONAL * TOL); }
//------------------------------------------------------------------------- public virtual void test_currencyExposure() { for (int i = 0; i < NB_STRIKES; ++i) { CurrencyAmount pvCall = PRICER.presentValue(CALLS[i], RATES_PROVIDER, VOLS); PointSensitivityBuilder pvSensiCall = PRICER.presentValueSensitivityRatesStickyStrike(CALLS[i], RATES_PROVIDER, VOLS); MultiCurrencyAmount computedCall = PRICER.currencyExposure(CALLS[i], RATES_PROVIDER, VOLS); MultiCurrencyAmount expectedCall = RATES_PROVIDER.currencyExposure(pvSensiCall.build()).plus(pvCall); assertEquals(computedCall.getAmount(EUR).Amount, expectedCall.getAmount(EUR).Amount, NOTIONAL * TOL); assertEquals(computedCall.getAmount(USD).Amount, expectedCall.getAmount(USD).Amount, NOTIONAL * TOL); CurrencyAmount pvPut = PRICER.presentValue(PUTS[i], RATES_PROVIDER, VOLS); PointSensitivityBuilder pvSensiPut = PRICER.presentValueSensitivityRatesStickyStrike(PUTS[i], RATES_PROVIDER, VOLS); MultiCurrencyAmount computedPut = PRICER.currencyExposure(PUTS[i], RATES_PROVIDER, VOLS); MultiCurrencyAmount expectedPut = RATES_PROVIDER.currencyExposure(pvSensiPut.build()).plus(pvPut); assertEquals(computedPut.getAmount(EUR).Amount, expectedPut.getAmount(EUR).Amount, NOTIONAL * TOL); assertEquals(computedPut.getAmount(USD).Amount, expectedPut.getAmount(USD).Amount, NOTIONAL * TOL); } }
//------------------------------------------------------------------------- public virtual void test_currencyExposureFromCleanPrice() { MultiCurrencyAmount computed = PRICER.currencyExposureFromCleanPrice(TRADE_STANDARD, RATES_PROVIDER, ISSUER_RATES_PROVIDER, REF_DATA, TRADE_PRICE); PointSensitivities point = PRICER.presentValueSensitivityFromCleanPrice(TRADE_STANDARD, RATES_PROVIDER, ISSUER_RATES_PROVIDER, REF_DATA, TRADE_PRICE); MultiCurrencyAmount expected = RATES_PROVIDER.currencyExposure(point).plus(PRICER.presentValueFromCleanPrice(TRADE_STANDARD, RATES_PROVIDER, ISSUER_RATES_PROVIDER, REF_DATA, TRADE_PRICE)); assertEquals(computed.Amounts.size(), 1); assertEquals(computed.getAmount(USD).Amount, expected.getAmount(USD).Amount, NOTIONAL * QUANTITY * TOL); }
public virtual void test_currencyExposureWithZSpread() { MultiCurrencyAmount computed = PRICER.currencyExposureWithZSpread(TRADE_STANDARD, RATES_PROVIDER, ISSUER_RATES_PROVIDER, Z_SPREAD, PERIODIC, PERIOD_PER_YEAR); PointSensitivities point = PRICER.presentValueSensitivityWithZSpread(TRADE_STANDARD, RATES_PROVIDER, ISSUER_RATES_PROVIDER, Z_SPREAD, PERIODIC, PERIOD_PER_YEAR); MultiCurrencyAmount expected = RATES_PROVIDER.currencyExposure(point).plus(PRICER.presentValueWithZSpread(TRADE_STANDARD, RATES_PROVIDER, ISSUER_RATES_PROVIDER, Z_SPREAD, PERIODIC, PERIOD_PER_YEAR)); assertEquals(computed.Amounts.size(), 1); assertEquals(computed.getAmount(USD).Amount, expected.getAmount(USD).Amount, NOTIONAL * QUANTITY * TOL); }
public virtual void test_currencyExposure() { PointSensitivities point = PRICER.presentValueSensitivityRates(FUTURE_TRADE, RATE_PROVIDER, HW_PROVIDER); MultiCurrencyAmount expected = RATE_PROVIDER.currencyExposure(point).plus(PRICER.presentValue(FUTURE_TRADE, RATE_PROVIDER, HW_PROVIDER, LAST_PRICE)); MultiCurrencyAmount computed = PRICER.currencyExposure(FUTURE_TRADE, RATE_PROVIDER, HW_PROVIDER, LAST_PRICE); assertEquals(computed.size(), 1); assertEquals(computed.getAmount(EUR).Amount, expected.getAmount(EUR).Amount, NOTIONAL * QUANTITY * TOL); }
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_presentValueZSpread_settle_after_val() { CurrencyAmount pvComputed = PRICER_TRADE.presentValueWithZSpread(BILL_TRADE_SETTLE_AFTER_VAL, PROVIDER, Z_SPREAD, CompoundedRateType.CONTINUOUS, 0); CurrencyAmount pvExpected = PRICER_PRODUCT.presentValueWithZSpread(BILL_PRODUCT.resolve(REF_DATA), PROVIDER, Z_SPREAD, CompoundedRateType.CONTINUOUS, 0).multipliedBy(QUANTITY).plus(PRICER_PAYMENT.presentValue(BILL_TRADE_SETTLE_AFTER_VAL.Settlement.get(), PROVIDER.repoCurveDiscountFactors(BILL_PRODUCT.SecurityId, BILL_PRODUCT.LegalEntityId, BILL_PRODUCT.Currency).DiscountFactors)); assertEquals(pvComputed.Currency, EUR); assertEquals(pvComputed.Amount, pvExpected.Amount, TOLERANCE_PV); MultiCurrencyAmount ceComputed = PRICER_TRADE.currencyExposureWithZSpread(BILL_TRADE_SETTLE_AFTER_VAL, PROVIDER, Z_SPREAD, CompoundedRateType.CONTINUOUS, 0); assertEquals(ceComputed.Currencies.size(), 1); assertTrue(ceComputed.contains(EUR)); assertEquals(ceComputed.getAmount(EUR).Amount, pvExpected.Amount, TOLERANCE_PV); }
public virtual void test_presentValueZSpread_settle_on_val() { CurrencyAmount pvComputed = PRICER_TRADE.presentValueWithZSpread(BILL_TRADE_SETTLE_ON_VAL, PROVIDER, Z_SPREAD, CompoundedRateType.CONTINUOUS, 0); CurrencyAmount pvExpected = PRICER_PRODUCT.presentValueWithZSpread(BILL_PRODUCT.resolve(REF_DATA), PROVIDER, Z_SPREAD, CompoundedRateType.CONTINUOUS, 0).plus(-PRICE * NOTIONAL_AMOUNT).multipliedBy(QUANTITY); assertEquals(pvComputed.Currency, EUR); assertEquals(pvComputed.Amount, pvExpected.Amount, TOLERANCE_PV); MultiCurrencyAmount ceComputed = PRICER_TRADE.currencyExposureWithZSpread(BILL_TRADE_SETTLE_ON_VAL, PROVIDER, Z_SPREAD, CompoundedRateType.CONTINUOUS, 0); assertEquals(ceComputed.Currencies.size(), 1); assertTrue(ceComputed.contains(EUR)); assertEquals(ceComputed.getAmount(EUR).Amount, pvExpected.Amount, TOLERANCE_PV); }
public virtual void test_currencyExposure() { MultiCurrencyAmount computed1 = PRODUCT_PRICER.currencyExposure(CMS_ONE_LEG, RATES_PROVIDER, VOLATILITIES); MultiCurrencyAmount computed2 = PRODUCT_PRICER.currencyExposure(CMS_TWO_LEGS, RATES_PROVIDER, VOLATILITIES); MultiCurrencyAmount pv1 = PRODUCT_PRICER.presentValue(CMS_ONE_LEG, RATES_PROVIDER, VOLATILITIES); PointSensitivityBuilder pt1 = PRODUCT_PRICER.presentValueSensitivityRates(CMS_ONE_LEG, RATES_PROVIDER, VOLATILITIES); MultiCurrencyAmount expected1 = RATES_PROVIDER.currencyExposure(pt1.build()).plus(pv1); MultiCurrencyAmount pv2 = PRODUCT_PRICER.presentValue(CMS_TWO_LEGS, RATES_PROVIDER, VOLATILITIES); PointSensitivityBuilder pt2 = PRODUCT_PRICER.presentValueSensitivityRates(CMS_TWO_LEGS, RATES_PROVIDER, VOLATILITIES); MultiCurrencyAmount expected2 = RATES_PROVIDER.currencyExposure(pt2.build()).plus(pv2); assertEquals(computed1.getAmount(EUR).Amount, expected1.getAmount(EUR).Amount, NOTIONAL_VALUE * TOL); assertEquals(computed2.getAmount(EUR).Amount, expected2.getAmount(EUR).Amount, NOTIONAL_VALUE * TOL); }
public virtual void test_currencyExposure() { MultiCurrencyAmount computed1 = TRADE_PRICER.currencyExposure(CMS_TRADE_PREMIUM, RATES_PROVIDER, VOLATILITIES); MultiCurrencyAmount computed2 = TRADE_PRICER.currencyExposure(CMS_TRADE, RATES_PROVIDER, VOLATILITIES); MultiCurrencyAmount pv1 = TRADE_PRICER.presentValue(CMS_TRADE_PREMIUM, RATES_PROVIDER, VOLATILITIES); PointSensitivities pt1 = TRADE_PRICER.presentValueSensitivityRates(CMS_TRADE_PREMIUM, RATES_PROVIDER, VOLATILITIES); MultiCurrencyAmount expected1 = RATES_PROVIDER.currencyExposure(pt1).plus(pv1); MultiCurrencyAmount pv2 = TRADE_PRICER.presentValue(CMS_TRADE, RATES_PROVIDER, VOLATILITIES); PointSensitivities pt2 = TRADE_PRICER.presentValueSensitivityRates(CMS_TRADE, RATES_PROVIDER, VOLATILITIES); MultiCurrencyAmount expected2 = RATES_PROVIDER.currencyExposure(pt2).plus(pv2); assertEquals(computed1.getAmount(EUR).Amount, expected1.getAmount(EUR).Amount, NOTIONAL_VALUE * TOL); assertEquals(computed2.getAmount(EUR).Amount, expected2.getAmount(EUR).Amount, NOTIONAL_VALUE * TOL); }
public virtual void test_currencyExposure() { MultiCurrencyAmount computedWithPayLeg = PRICER.currencyExposure(TRADE_PAYLEG, RATES, VOLS); MultiCurrencyAmount computedWithPremium = PRICER.currencyExposure(TRADE_PREMIUM, RATES, VOLS); MultiCurrencyAmount pvWithPayLeg = PRICER.presentValue(TRADE_PAYLEG, RATES, VOLS); MultiCurrencyAmount pvWithPremium = PRICER.presentValue(TRADE_PREMIUM, RATES, VOLS); PointSensitivities pointWithPayLeg = PRICER.presentValueSensitivityRates(TRADE_PAYLEG, RATES, VOLS); PointSensitivities pointWithPremium = PRICER.presentValueSensitivityRates(TRADE_PREMIUM, RATES, VOLS); MultiCurrencyAmount expectedWithPayLeg = RATES.currencyExposure(pointWithPayLeg).plus(pvWithPayLeg); MultiCurrencyAmount expectedWithPremium = RATES.currencyExposure(pointWithPremium).plus(pvWithPremium); assertEquals(computedWithPayLeg.getAmount(EUR).Amount, expectedWithPayLeg.getAmount(EUR).Amount, NOTIONAL_VALUE * TOL); assertEquals(computedWithPremium.getAmount(EUR).Amount, expectedWithPremium.getAmount(EUR).Amount, NOTIONAL_VALUE * TOL); }
public virtual void currency_exposure_USD() { LocalDate startDate = LocalDate.of(2016, 8, 2); LocalDate fixingDate = LocalDate.of(2016, 11, 2); LocalDate endDate = LocalDate.of(2016, 11, 4); double yearFraction = 0.25; double rate = 0.10; RateAccrualPeriod accrual = RateAccrualPeriod.builder().startDate(startDate).endDate(endDate).yearFraction(yearFraction).rateComputation(FixedRateComputation.of(rate)).build(); double notional = 1000000; RatePaymentPeriod fixedFx = RatePaymentPeriod.builder().accrualPeriods(accrual).fxReset(FxReset.of(FxIndexObservation.of(FxIndices.GBP_USD_WM, fixingDate, REF_DATA), USD)).notional(notional).paymentDate(endDate).dayCount(DayCounts.ONE_ONE).currency(GBP).build(); // 1_000_000 USD paid in GBP at maturity PointSensitivityBuilder pts = PERIOD_PRICER.presentValueSensitivity(fixedFx, PROVIDER); MultiCurrencyAmount ceComputed = PERIOD_PRICER.currencyExposure(fixedFx, PROVIDER); double dfUsd = PROVIDER.discountFactor(USD, endDate); double ceUsdExpected = notional * yearFraction * rate * dfUsd; assertEquals(ceComputed.getAmount(USD).Amount, ceUsdExpected, 1.0E-6); MultiCurrencyAmount ceWithoutPvComputed = PROVIDER.currencyExposure(pts.build().convertedTo(USD, PROVIDER)); CurrencyAmount pvComputed = CurrencyAmount.of(GBP, PERIOD_PRICER.presentValue(fixedFx, PROVIDER)); MultiCurrencyAmount ceComputed2 = ceWithoutPvComputed.plus(pvComputed); assertEquals(ceComputed2.getAmount(USD).Amount, ceUsdExpected, TOLERANCE); assertEquals(ceComputed2.getAmount(GBP).Amount, 0.0, TOLERANCE); }
public virtual void test_presentValue_settle_on_val() { CurrencyAmount pvComputed = PRICER_TRADE.presentValue(BILL_TRADE_SETTLE_ON_VAL, PROVIDER); CurrencyAmount pvExpected = PRICER_PRODUCT.presentValue(BILL_PRODUCT.resolve(REF_DATA), PROVIDER).plus(-PRICE * NOTIONAL_AMOUNT).multipliedBy(QUANTITY); assertEquals(pvComputed.Currency, EUR); assertEquals(pvComputed.Amount, pvExpected.Amount, TOLERANCE_PV); MultiCurrencyAmount ceComputed = PRICER_TRADE.currencyExposure(BILL_TRADE_SETTLE_ON_VAL, PROVIDER); assertEquals(ceComputed.Currencies.size(), 1); assertTrue(ceComputed.contains(EUR)); assertEquals(ceComputed.getAmount(EUR).Amount, pvExpected.Amount, TOLERANCE_PV); CurrencyAmount cashComputed = PRICER_TRADE.currentCash(BILL_TRADE_SETTLE_ON_VAL, VAL_DATE); assertEquals(cashComputed.Currency, EUR); assertEquals(cashComputed.Amount, -PRICE * NOTIONAL_AMOUNT * QUANTITY, TOLERANCE_PV); }
public virtual void test_pv01_quote() { ScenarioMarketData md = FixedCouponBondTradeCalculationFunctionTest.marketData(); LegalEntityDiscountingProvider provider = LOOKUP.marketDataView(md.scenario(0)).discountingProvider(); DiscountingFixedCouponBondTradePricer pricer = DiscountingFixedCouponBondTradePricer.DEFAULT; PointSensitivities pvPointSens = pricer.presentValueSensitivity(RTRADE, provider); CurrencyParameterSensitivities pvParamSens = provider.parameterSensitivity(pvPointSens); CurrencyParameterSensitivities expectedPv01CalBucketed = MQ_CALC.sensitivity(pvParamSens, provider).multipliedBy(1e-4); MultiCurrencyAmount expectedPv01Cal = expectedPv01CalBucketed.total(); MultiCurrencyScenarioArray sumComputed = FixedCouponBondTradeCalculations.DEFAULT.pv01MarketQuoteSum(RTRADE, LOOKUP, md); ScenarioArray <CurrencyParameterSensitivities> bucketedComputed = FixedCouponBondTradeCalculations.DEFAULT.pv01MarketQuoteBucketed(RTRADE, LOOKUP, md); assertEquals(sumComputed.ScenarioCount, 1); assertEquals(sumComputed.get(0).Currencies, ImmutableSet.of(GBP)); assertTrue(DoubleMath.fuzzyEquals(sumComputed.get(0).getAmount(GBP).Amount, expectedPv01Cal.getAmount(GBP).Amount, 1.0e-10)); assertEquals(bucketedComputed.ScenarioCount, 1); assertTrue(bucketedComputed.get(0).equalWithTolerance(expectedPv01CalBucketed, 1.0e-10)); }