/// <summary>
/// Test that ScenarioArrays containing a single value are unwrapped when calling calculateAsync().
/// </summary>
public virtual void unwrapScenarioResultsAsync()
{
ScenarioArray <string> scenarioResult = ScenarioArray.of("foo");
ScenarioResultFunction fn = new ScenarioResultFunction(TestingMeasures.PRESENT_VALUE, scenarioResult);
CalculationTaskCell cell = CalculationTaskCell.of(0, 0, TestingMeasures.PRESENT_VALUE, NATURAL);
CalculationTask task = CalculationTask.of(TARGET, fn, cell);
Column column = Column.of(TestingMeasures.PRESENT_VALUE);
CalculationTasks tasks = CalculationTasks.of(ImmutableList.of(task), ImmutableList.of(column));
// using the direct executor means there is no need to close/shutdown the runner
CalculationTaskRunner test = CalculationTaskRunner.of(MoreExecutors.newDirectExecutorService());
Listener listener = new Listener();
MarketData marketData = MarketData.empty(VAL_DATE);
test.calculateAsync(tasks, marketData, REF_DATA, listener);
CalculationResult calculationResult1 = listener.result;
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: com.opengamma.strata.collect.result.Result<?> result1 = calculationResult1.getResult();
Result <object> result1 = calculationResult1.Result;
// Check the result contains the string directly, not the result wrapping the string
assertThat(result1).hasValue("foo");
test.calculateMultiScenarioAsync(tasks, ScenarioMarketData.of(1, marketData), REF_DATA, listener);
CalculationResult calculationResult2 = listener.result;
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: com.opengamma.strata.collect.result.Result<?> result2 = calculationResult2.getResult();
Result <object> result2 = calculationResult2.Result;
// Check the result contains the scenario result wrapping the string
assertThat(result2).hasValue(scenarioResult);
}
public virtual void test_of_repeated()
{
ScenarioMarketData test = ScenarioMarketData.of(1, MarketData.of(VAL_DATE, ImmutableMap.of(ID1, VAL1)));
assertThat(test.ValuationDate).isEqualTo(MarketDataBox.ofSingleValue(VAL_DATE));
assertThat(test.getValue(ID1)).isEqualTo(MarketDataBox.ofSingleValue(VAL1));
}
public void calculateAsync(CalculationTasks tasks, MarketData marketData, ReferenceData refData, CalculationListener listener)
{
// the listener is decorated to unwrap ScenarioArrays containing a single result
ScenarioMarketData md = ScenarioMarketData.of(1, marketData);
UnwrappingListener unwrappingListener = new UnwrappingListener(listener);
calculateMultiScenarioAsync(tasks, md, refData, unwrappingListener);
}
public virtual void of_badScenarios()
{
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: java.util.Map<com.opengamma.strata.data.MarketDataId<?>, MarketDataBox<?>> dataMap = com.google.common.collect.ImmutableMap.of(ID1, MarketDataBox.ofScenarioValues(VAL1));
IDictionary <MarketDataId <object>, MarketDataBox <object> > dataMap = ImmutableMap.of(ID1, MarketDataBox.ofScenarioValues(VAL1));
IDictionary <ObservableId, LocalDateDoubleTimeSeries> tsMap = ImmutableMap.of(ID1, TIME_SERIES);
assertThrows(() => ScenarioMarketData.of(2, VAL_DATE, dataMap, tsMap), typeof(System.ArgumentException));
}
//-------------------------------------------------------------------------
public Results calculate(CalculationTasks tasks, MarketData marketData, ReferenceData refData)
{
// perform the calculations
ScenarioMarketData md = ScenarioMarketData.of(1, marketData);
Results results = calculateMultiScenario(tasks, md, refData);
// unwrap the results
// since there is only one scenario it is not desirable to return scenario result containers
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: java.util.List<com.opengamma.strata.collect.result.Result<?>> mappedResults = results.getCells().stream().map(r -> unwrapScenarioResult(r)).collect(toImmutableList());
//JAVA TO C# CONVERTER TODO TASK: Most Java stream collectors are not converted by Java to C# Converter:
IList <Result <object> > mappedResults = results.Cells.Select(r => unwrapScenarioResult(r)).collect(toImmutableList());
return(Results.of(results.Columns, mappedResults));
}
public virtual void test_of_noScenarios()
{
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: java.util.Map<com.opengamma.strata.data.MarketDataId<?>, MarketDataBox<?>> dataMap = com.google.common.collect.ImmutableMap.of(ID1, MarketDataBox.empty());
IDictionary <MarketDataId <object>, MarketDataBox <object> > dataMap = ImmutableMap.of(ID1, MarketDataBox.empty());
ScenarioMarketData test = ScenarioMarketData.of(0, VAL_DATE, dataMap, ImmutableMap.of());
assertThat(test.ValuationDate).isEqualTo(MarketDataBox.ofSingleValue(VAL_DATE));
assertThat(test.containsValue(ID1)).True;
assertThat(test.containsValue(ID2)).False;
assertThat(test.getValue(ID1)).isEqualTo(MarketDataBox.empty());
assertThrows(() => test.getValue(ID2), typeof(MarketDataNotFoundException));
assertThat(test.findValue(ID1)).hasValue(MarketDataBox.empty());
assertThat(test.findValue(ID2)).Empty;
assertThat(test.Ids).isEqualTo(ImmutableSet.of(ID1));
assertThat(test.getTimeSeries(ID1)).isEqualTo(LocalDateDoubleTimeSeries.empty());
assertThat(test.getTimeSeries(ID2)).isEqualTo(LocalDateDoubleTimeSeries.empty());
}
//-------------------------------------------------------------------------
public virtual void test_scenarios()
{
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: java.util.Map<com.opengamma.strata.data.MarketDataId<?>, MarketDataBox<?>> dataMap = com.google.common.collect.ImmutableMap.of(ID1, BOX1);
IDictionary <MarketDataId <object>, MarketDataBox <object> > dataMap = ImmutableMap.of(ID1, BOX1);
IDictionary <ObservableId, LocalDateDoubleTimeSeries> tsMap = ImmutableMap.of(ID1, TIME_SERIES);
ScenarioMarketData test = ScenarioMarketData.of(2, VAL_DATE, dataMap, tsMap);
MarketData scenario0 = test.scenario(0);
MarketData scenario1 = test.scenario(1);
assertThat(scenario0.getValue(ID1)).isEqualTo(BOX1.getValue(0));
assertThat(scenario1.getValue(ID1)).isEqualTo(BOX1.getValue(1));
IList <double> list = test.scenarios().map(s => s.getValue(ID1)).collect(toImmutableList());
assertThat(list[0]).isEqualTo(BOX1.getValue(0));
assertThat(list[1]).isEqualTo(BOX1.getValue(1));
}
//-------------------------------------------------------------------------
// Test that ScenarioArrays containing a single value are unwrapped.
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public void unwrapScenarioResults() throws Exception
public virtual void unwrapScenarioResults()
{
ScenarioArray <string> scenarioResult = ScenarioArray.of("foo");
ScenarioResultFunction fn = new ScenarioResultFunction(TestingMeasures.PRESENT_VALUE, scenarioResult);
CalculationTaskCell cell = CalculationTaskCell.of(0, 0, TestingMeasures.PRESENT_VALUE, NATURAL);
CalculationTask task = CalculationTask.of(TARGET, fn, cell);
Column column = Column.of(TestingMeasures.PRESENT_VALUE);
CalculationTasks tasks = CalculationTasks.of(ImmutableList.of(task), ImmutableList.of(column));
// using the direct executor means there is no need to close/shutdown the runner
CalculationTaskRunner test = CalculationTaskRunner.of(MoreExecutors.newDirectExecutorService());
MarketData marketData = MarketData.empty(VAL_DATE);
Results results1 = test.calculate(tasks, 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<?> result1 = results1.get(0, 0);
Result <object> result1 = results1.get(0, 0);
// Check the result contains the string directly, not the result wrapping the string
assertThat(result1).hasValue("foo");
Results results2 = test.calculateMultiScenario(tasks, ScenarioMarketData.of(1, 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<?> result2 = results2.get(0, 0);
Result <object> result2 = results2.get(0, 0);
// Check the result contains the scenario result wrapping the string
assertThat(result2).hasValue(scenarioResult);
ResultsListener resultsListener = new ResultsListener();
test.calculateAsync(tasks, marketData, REF_DATA, resultsListener);
CompletableFuture <Results> future = resultsListener.Future;
// The future is guaranteed to be done because everything is running on a single thread
assertThat(future.Done).True;
Results results3 = future.get();
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: com.opengamma.strata.collect.result.Result<?> result3 = results3.get(0, 0);
Result <object> result3 = results3.get(0, 0);
// Check the result contains the string directly, not the result wrapping the string
assertThat(result3).hasValue("foo");
}
/// <summary>
/// Test that a failure is returned if the observable data isn't available.
/// </summary>
public virtual void buildMissingMarketData()
{
FraCurveNode node1x4 = fraNode(1, "a");
FraCurveNode node2x5 = fraNode(2, "b");
FraCurveNode node3x6 = fraNode(3, "c");
InterpolatedNodalCurveDefinition curve = InterpolatedNodalCurveDefinition.builder().name(CurveName.of("curve")).interpolator(CurveInterpolators.DOUBLE_QUADRATIC).extrapolatorLeft(CurveExtrapolators.FLAT).extrapolatorRight(CurveExtrapolators.FLAT).nodes(node1x4, node2x5, node3x6).build();
RatesCurveGroupDefinition groupDefn = RatesCurveGroupDefinition.builder().name(CurveGroupName.of("curve group")).addDiscountCurve(curve, Currency.USD).build();
MarketDataConfig marketDataConfig = MarketDataConfig.builder().add(groupDefn.Name, groupDefn).build();
ScenarioMarketData emptyData = ScenarioMarketData.of(1, date(2016, 6, 30), ImmutableMap.of(), ImmutableMap.of());
RatesCurveInputsMarketDataFunction marketDataFunction = new RatesCurveInputsMarketDataFunction();
RatesCurveInputsId curveInputsId = RatesCurveInputsId.of(groupDefn.Name, curve.Name, ObservableSource.NONE);
assertThrows(() => marketDataFunction.build(curveInputsId, marketDataConfig, emptyData, REF_DATA), typeof(MarketDataNotFoundException));
}
