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