/// <summary> /// Test that a failure is returned if there is no config for the curve group. /// </summary> public virtual void buildMissingGroupConfig() { RatesCurveInputsMarketDataFunction marketDataFunction = new RatesCurveInputsMarketDataFunction(); RatesCurveInputsId curveInputsId = RatesCurveInputsId.of(CurveGroupName.of("curve group"), CurveName.of("curve"), ObservableSource.NONE); ScenarioMarketData emptyData = ScenarioMarketData.empty(); assertThrows(() => marketDataFunction.build(curveInputsId, MarketDataConfig.empty(), emptyData, REF_DATA), typeof(System.ArgumentException), "No configuration found for type .*"); }
/// <summary> /// Test that a failure is returned if there is config for the curve group but it doesn't contain the named curve. /// </summary> public virtual void buildMissingCurveDefinition() { RatesCurveInputsMarketDataFunction marketDataFunction = new RatesCurveInputsMarketDataFunction(); RatesCurveInputsId curveInputsId = RatesCurveInputsId.of(CurveGroupName.of("curve group"), CurveName.of("curve"), ObservableSource.NONE); RatesCurveGroupDefinition groupDefn = RatesCurveGroupDefinition.builder().name(CurveGroupName.of("curve group")).build(); MarketDataConfig marketDataConfig = MarketDataConfig.builder().add(groupDefn.Name, groupDefn).build(); ScenarioMarketData emptyData = ScenarioMarketData.empty(); assertThrows(() => marketDataFunction.build(curveInputsId, marketDataConfig, emptyData, REF_DATA), typeof(System.ArgumentException), "No curve named .*"); }
/// <summary> /// Tests that executing a function that returns a failure result returns the underlying result without wrapping it. /// </summary> public virtual void executeFailureResultValue() { SupplierFunction <Result <string> > fn = SupplierFunction.of(() => Result.failure(FailureReason.NOT_APPLICABLE, "bar")); CalculationTaskCell cell = CalculationTaskCell.of(0, 0, TestingMeasures.PRESENT_VALUE, REPORTING_CURRENCY_USD); CalculationTask task = CalculationTask.of(TARGET, fn, cell); ScenarioMarketData marketData = ScenarioMarketData.empty(); CalculationResults calculationResults = task.execute(marketData, REF_DATA); //JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET: //ORIGINAL LINE: com.opengamma.strata.collect.result.Result<?> result = calculationResults.getCells().get(0).getResult(); Result <object> result = calculationResults.Cells.get(0).Result; assertThat(result).isFailure(FailureReason.NOT_APPLICABLE).hasFailureMessageMatching("bar"); }
public virtual void test_empty() { ScenarioMarketData test = ScenarioMarketData.empty(); assertThat(test.ValuationDate).isEqualTo(MarketDataBox.empty()); assertThat(test.containsValue(ID1)).False; assertThat(test.containsValue(ID2)).False; assertThrows(() => test.getValue(ID1), typeof(MarketDataNotFoundException)); assertThrows(() => test.getValue(ID2), typeof(MarketDataNotFoundException)); assertThat(test.findValue(ID1)).Empty; assertThat(test.findValue(ID2)).Empty; assertThat(test.Ids).isEqualTo(ImmutableSet.of()); assertThat(test.getTimeSeries(ID1)).isEqualTo(LocalDateDoubleTimeSeries.empty()); assertThat(test.getTimeSeries(ID2)).isEqualTo(LocalDateDoubleTimeSeries.empty()); }
/// <summary> /// Tests that executing a function that throws an unsupported exception wraps the exception in a failure result. /// </summary> public virtual void executeException_unsupported() { SupplierFunction <string> fn = SupplierFunction.of(() => { throw new System.NotSupportedException("foo"); }); CalculationTaskCell cell = CalculationTaskCell.of(0, 0, TestingMeasures.PRESENT_VALUE, REPORTING_CURRENCY_USD); CalculationTask task = CalculationTask.of(TARGET, fn, cell); ScenarioMarketData marketData = ScenarioMarketData.empty(); CalculationResults calculationResults = task.execute(marketData, REF_DATA); //JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET: //ORIGINAL LINE: com.opengamma.strata.collect.result.Result<?> result = calculationResults.getCells().get(0).getResult(); Result <object> result = calculationResults.Cells.get(0).Result; assertThat(result).isFailure(FailureReason.UNSUPPORTED).hasFailureMessageMatching("Unsupported operation when invoking function 'SupplierFunction' for ID '123': foo"); }
/// <summary> /// Test that a failure is returned if currency conversion fails. /// </summary> public virtual void convertResultCurrencyConversionFails() { DoubleArray values = DoubleArray.of(1, 2, 3); CurrencyScenarioArray list = CurrencyScenarioArray.of(GBP, values); // Market data doesn't include FX rates, conversion to USD will fail ScenarioMarketData marketData = ScenarioMarketData.empty(); ConvertibleFunction fn = ConvertibleFunction.of(() => list, GBP); CalculationTaskCell cell = CalculationTaskCell.of(0, 0, TestingMeasures.PRESENT_VALUE, REPORTING_CURRENCY_USD); CalculationTask task = CalculationTask.of(TARGET, fn, cell); CalculationResults calculationResults = task.execute(marketData, REF_DATA); //JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET: //ORIGINAL LINE: com.opengamma.strata.collect.result.Result<?> result = calculationResults.getCells().get(0).getResult(); Result <object> result = calculationResults.Cells.get(0).Result; assertThat(result).isFailure(FailureReason.CURRENCY_CONVERSION).hasFailureMessageMatching("Failed to convert value '.*' to currency 'USD'"); }
/// <summary> /// Test that the result is returned unchanged if it is a failure. /// </summary> public virtual void convertResultCurrencyFailure() { ConvertibleFunction fn = ConvertibleFunction.of(() => { throw new Exception("This is a failure"); }, GBP); CalculationTaskCell cell = CalculationTaskCell.of(0, 0, TestingMeasures.PRESENT_VALUE, REPORTING_CURRENCY_USD); CalculationTask task = CalculationTask.of(TARGET, fn, cell); ScenarioMarketData marketData = ScenarioMarketData.empty(); CalculationResults calculationResults = task.execute(marketData, REF_DATA); //JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET: //ORIGINAL LINE: com.opengamma.strata.collect.result.Result<?> result = calculationResults.getCells().get(0).getResult(); Result <object> result = calculationResults.Cells.get(0).Result; assertThat(result).isFailure(FailureReason.CALCULATION_FAILED).hasFailureMessageMatching("Error when invoking function 'ConvertibleFunction' for ID '123': This is a failure"); }
/// <summary> /// Tests that executing a function filters the set of measures sent to function. /// </summary> public virtual void executeFilterMeasures() { // function does not support 'ParRate', so it should not be asked for it MeasureCheckFunction fn = new MeasureCheckFunction(ImmutableSet.of(TestingMeasures.PRESENT_VALUE), ("123")); CalculationTaskCell cell0 = CalculationTaskCell.of(0, 0, TestingMeasures.PRESENT_VALUE, REPORTING_CURRENCY_USD); CalculationTaskCell cell1 = CalculationTaskCell.of(0, 1, TestingMeasures.PAR_RATE, REPORTING_CURRENCY_USD); CalculationTask task = CalculationTask.of(TARGET, fn, cell0, cell1); ScenarioMarketData marketData = ScenarioMarketData.empty(); CalculationResults calculationResults = task.execute(marketData, REF_DATA); //JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET: //ORIGINAL LINE: com.opengamma.strata.collect.result.Result<?> result0 = calculationResults.getCells().get(0).getResult(); Result <object> result0 = calculationResults.Cells.get(0).Result; assertThat(result0).Success.hasValue(ImmutableSet.of(TestingMeasures.PRESENT_VALUE)); // ParRate not requested //JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET: //ORIGINAL LINE: com.opengamma.strata.collect.result.Result<?> result1 = calculationResults.getCells().get(1).getResult(); Result <object> result1 = calculationResults.Cells.get(1).Result; assertThat(result1).isFailure(FailureReason.UNSUPPORTED).hasFailureMessageMatching("Measure 'ParRate' is not supported by function 'MeasureCheckFunction'"); }
/// <summary> /// Test executing a bad function that fails to return expected measure. /// </summary> public virtual void executeMissingMeasure() { // function claims it supports 'PresentValueMultiCurrency' but fails to return it when asked MeasureCheckFunction fn = new MeasureCheckFunction(ImmutableSet.of(TestingMeasures.PRESENT_VALUE), ("123")); CalculationTaskCell cell0 = CalculationTaskCell.of(0, 0, TestingMeasures.PRESENT_VALUE, REPORTING_CURRENCY_USD); CalculationTaskCell cell1 = CalculationTaskCell.of(0, 1, TestingMeasures.PRESENT_VALUE_MULTI_CCY, REPORTING_CURRENCY_USD); CalculationTask task = CalculationTask.of(TARGET, fn, cell0, cell1); ScenarioMarketData marketData = ScenarioMarketData.empty(); CalculationResults calculationResults = task.execute(marketData, REF_DATA); //JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET: //ORIGINAL LINE: com.opengamma.strata.collect.result.Result<?> result0 = calculationResults.getCells().get(0).getResult(); Result <object> result0 = calculationResults.Cells.get(0).Result; assertThat(result0).Success.hasValue(ImmutableSet.of(TestingMeasures.PRESENT_VALUE, TestingMeasures.PRESENT_VALUE_MULTI_CCY)); //JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET: //ORIGINAL LINE: com.opengamma.strata.collect.result.Result<?> result1 = calculationResults.getCells().get(1).getResult(); Result <object> result1 = calculationResults.Cells.get(1).Result; assertThat(result1).isFailure(FailureReason.CALCULATION_FAILED).hasFailureMessageMatching("Function 'MeasureCheckFunction' did not return requested measure 'PresentValueMultiCurrency' for ID '123'"); }
/// <summary> /// Test two derived function composed together /// </summary> public virtual void calculateMeasuresNestedDerivedClasses() { TestTarget target = new TestTarget(10); //JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET: //ORIGINAL LINE: java.util.Map<com.opengamma.strata.calc.Measure, com.opengamma.strata.collect.result.Result<?>> delegateResults = com.google.common.collect.ImmutableMap.of(CASH_FLOWS, com.opengamma.strata.collect.result.Result.success(3), PAR_RATE, com.opengamma.strata.collect.result.Result.success(5), PRESENT_VALUE, com.opengamma.strata.collect.result.Result.success(7)); IDictionary <Measure, Result <object> > delegateResults = ImmutableMap.of(CASH_FLOWS, Result.success(3), PAR_RATE, Result.success(5), PRESENT_VALUE, Result.success(7)); DerivedFn derivedFn1 = new DerivedFn(BUCKETED_PV01); DerivedFn derivedFn2 = new DerivedFn(PRESENT_VALUE_MULTI_CCY); DerivedCalculationFunctionWrapper <TestTarget, int> wrapper = new DerivedCalculationFunctionWrapper <TestTarget, int>(derivedFn1, new DelegateFn(delegateResults)); wrapper = new DerivedCalculationFunctionWrapper <>(derivedFn2, wrapper); ISet <Measure> measures = ImmutableSet.of(BUCKETED_PV01, PRESENT_VALUE_MULTI_CCY, CASH_FLOWS, PAR_RATE, PRESENT_VALUE); //JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET: //ORIGINAL LINE: java.util.Map<com.opengamma.strata.calc.Measure, com.opengamma.strata.collect.result.Result<?>> results = wrapper.calculate(target, measures, CalculationParameters.empty(), com.opengamma.strata.data.scenario.ScenarioMarketData.empty(), com.opengamma.strata.basics.ReferenceData.standard()); IDictionary <Measure, Result <object> > results = wrapper.calculate(target, measures, CalculationParameters.empty(), ScenarioMarketData.empty(), ReferenceData.standard()); assertThat(wrapper.supportedMeasures()).isEqualTo(measures); assertThat(wrapper.targetType()).isEqualTo(typeof(TestTarget)); assertThat(results.Keys).isEqualTo(measures); assertThat(results[BUCKETED_PV01]).hasValue(35); assertThat(results[PRESENT_VALUE_MULTI_CCY]).hasValue(35); assertThat(results[CASH_FLOWS]).hasValue(3); assertThat(results[PAR_RATE]).hasValue(5); assertThat(results[PRESENT_VALUE]).hasValue(7); }
/// <summary> /// Test the behaviour when the delegate function returns no value for a measure it claims to support. /// This is a bug in the function, it should always return a result for all measures that are supported and /// were requested. /// </summary> public virtual void supportedMeasureNotReturned() { TestTarget target = new TestTarget(10); //JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET: //ORIGINAL LINE: java.util.Map<com.opengamma.strata.calc.Measure, com.opengamma.strata.collect.result.Result<?>> delegateResults = com.google.common.collect.ImmutableMap.of(CASH_FLOWS, com.opengamma.strata.collect.result.Result.success(3), PAR_RATE, com.opengamma.strata.collect.result.Result.success(5), PRESENT_VALUE, com.opengamma.strata.collect.result.Result.success(7)); IDictionary <Measure, Result <object> > delegateResults = ImmutableMap.of(CASH_FLOWS, Result.success(3), PAR_RATE, Result.success(5), PRESENT_VALUE, Result.success(7)); DelegateFn delegateFn = new DelegateFnAnonymousInnerClass(this, delegateResults, target); DerivedCalculationFunctionWrapper <TestTarget, int> wrapper = new DerivedCalculationFunctionWrapper <TestTarget, int>(new DerivedFn(), delegateFn); ISet <Measure> measures = ImmutableSet.of(BUCKETED_PV01); //JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET: //ORIGINAL LINE: java.util.Map<com.opengamma.strata.calc.Measure, com.opengamma.strata.collect.result.Result<?>> results = wrapper.calculate(target, measures, CalculationParameters.empty(), com.opengamma.strata.data.scenario.ScenarioMarketData.empty(), com.opengamma.strata.basics.ReferenceData.standard()); IDictionary <Measure, Result <object> > results = wrapper.calculate(target, measures, CalculationParameters.empty(), ScenarioMarketData.empty(), ReferenceData.standard()); assertThat(results.Keys).isEqualTo(measures); assertThat(results[BUCKETED_PV01]).hasFailureMessageMatching(".*did not return the expected measures.*"); }
/// <summary> /// Test the behaviour when the underlying function doesn't support the measures required by the derived function. /// </summary> public virtual void requiredMeasuresNotSupported() { TestTarget target = new TestTarget(10); //JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET: //ORIGINAL LINE: java.util.Map<com.opengamma.strata.calc.Measure, com.opengamma.strata.collect.result.Result<?>> delegateResults = com.google.common.collect.ImmutableMap.of(PAR_RATE, com.opengamma.strata.collect.result.Result.success(5), PRESENT_VALUE, com.opengamma.strata.collect.result.Result.success(7)); IDictionary <Measure, Result <object> > delegateResults = ImmutableMap.of(PAR_RATE, Result.success(5), PRESENT_VALUE, Result.success(7)); DerivedCalculationFunctionWrapper <TestTarget, int> wrapper = new DerivedCalculationFunctionWrapper <TestTarget, int>(new DerivedFn(), new DelegateFn(delegateResults)); ISet <Measure> measures = ImmutableSet.of(BUCKETED_PV01, PAR_RATE); //JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET: //ORIGINAL LINE: java.util.Map<com.opengamma.strata.calc.Measure, com.opengamma.strata.collect.result.Result<?>> results = wrapper.calculate(target, measures, CalculationParameters.empty(), com.opengamma.strata.data.scenario.ScenarioMarketData.empty(), com.opengamma.strata.basics.ReferenceData.standard()); IDictionary <Measure, Result <object> > results = wrapper.calculate(target, measures, CalculationParameters.empty(), ScenarioMarketData.empty(), ReferenceData.standard()); // The derived measure isn't supported because its required measure isn't available assertThat(wrapper.supportedMeasures()).isEqualTo(ImmutableSet.of(PAR_RATE, PRESENT_VALUE)); assertThat(results.Keys).isEqualTo(measures); assertThat(results[BUCKETED_PV01]).hasFailureMessageMatching(".*cannot calculate the required measures.*"); assertThat(results[PAR_RATE]).hasValue(5); }
/// <summary> /// Test that the derived measure isn't calculated unless it is requested. /// </summary> public virtual void derivedMeasureNotRequested() { TestTarget target = new TestTarget(10); //JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET: //ORIGINAL LINE: java.util.Map<com.opengamma.strata.calc.Measure, com.opengamma.strata.collect.result.Result<?>> delegateResults = com.google.common.collect.ImmutableMap.of(CASH_FLOWS, com.opengamma.strata.collect.result.Result.success(3), PRESENT_VALUE, com.opengamma.strata.collect.result.Result.success(7)); IDictionary <Measure, Result <object> > delegateResults = ImmutableMap.of(CASH_FLOWS, Result.success(3), PRESENT_VALUE, Result.success(7)); DerivedCalculationFunctionWrapper <TestTarget, int> wrapper = new DerivedCalculationFunctionWrapper <TestTarget, int>(new DerivedFn(), new DelegateFn(delegateResults)); ISet <Measure> measures = ImmutableSet.of(CASH_FLOWS, PRESENT_VALUE); //JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET: //ORIGINAL LINE: java.util.Map<com.opengamma.strata.calc.Measure, com.opengamma.strata.collect.result.Result<?>> results = wrapper.calculate(target, measures, CalculationParameters.empty(), com.opengamma.strata.data.scenario.ScenarioMarketData.empty(), com.opengamma.strata.basics.ReferenceData.standard()); IDictionary <Measure, Result <object> > results = wrapper.calculate(target, measures, CalculationParameters.empty(), ScenarioMarketData.empty(), ReferenceData.standard()); assertThat(results.Keys).isEqualTo(measures); assertThat(results[CASH_FLOWS]).hasValue(3); assertThat(results[PRESENT_VALUE]).hasValue(7); }
public virtual void buildNoConfigForPair() { FxRateMarketDataFunction function = new FxRateMarketDataFunction(); string regex = "No FX rate configuration available for GBP/USD"; CurrencyPair gbpUsd = CurrencyPair.of(Currency.GBP, Currency.USD); assertThrowsIllegalArg(() => function.build(FxRateId.of(gbpUsd), config(), ScenarioMarketData.empty(), REF_DATA), regex); }
public virtual void buildMissingConfig() { FxRateMarketDataFunction function = new FxRateMarketDataFunction(); string regex = "No configuration found .*FxRateConfig"; assertThrowsIllegalArg(() => function.build(RATE_ID, MarketDataConfig.empty(), ScenarioMarketData.empty(), REF_DATA), regex); }