/// <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);
}
