//------------------------------------------------------------------------- public virtual void of() { CalculationResults test = CalculationResults.of(TARGET, ImmutableList.of(CALC_RESULT)); assertEquals(test.Target, TARGET); assertEquals(test.Cells, ImmutableList.of(CALC_RESULT)); }
// Tests that a listener is only invoked by a single thread at any time even if multiple threads are // invoking the wrapper concurrently. //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: public void concurrentExecution() throws InterruptedException public virtual void concurrentExecution() { int nThreads = Runtime.Runtime.availableProcessors(); int resultsPerThread = 10; ConcurrentLinkedQueue <string> errors = new ConcurrentLinkedQueue <string>(); System.Threading.CountdownEvent latch = new System.Threading.CountdownEvent(1); int expectedResultCount = nThreads * resultsPerThread; Listener listener = new Listener(errors, latch); System.Action <CalculationResults> wrapper = new ListenerWrapper(listener, expectedResultCount, ImmutableList.of(), ImmutableList.of()); ExecutorService executor = Executors.newFixedThreadPool(nThreads); CalculationResult result = CalculationResult.of(0, 0, Result.failure(FailureReason.ERROR, "foo")); CalculationTarget target = new CalculationTargetAnonymousInnerClass(this); CalculationResults results = CalculationResults.of(target, ImmutableList.of(result)); IntStream.range(0, expectedResultCount).forEach(i => executor.submit(() => wrapper(results))); latch.await(); executor.shutdown(); if (!errors.Empty) { //JAVA TO C# CONVERTER TODO TASK: Most Java stream collectors are not converted by Java to C# Converter: string allErrors = errors.collect(joining("\n")); fail(allErrors); } }
//------------------------------------------------------------------------- public virtual void coverage() { CalculationResults test = CalculationResults.of(TARGET, ImmutableList.of(CALC_RESULT)); coverImmutableBean(test); CalculationResults test2 = CalculationResults.of(TARGET2, ImmutableList.of(CALC_RESULT2)); coverBeanEquals(test, test2); assertNotNull(CalculationResults.meta()); }
//----------------------------------------------------------------------- public override bool Equals(object obj) { if (obj == this) { return(true); } if (obj != null && obj.GetType() == this.GetType()) { CalculationResults other = (CalculationResults)obj; return(JodaBeanUtils.equal(target, other.target) && JodaBeanUtils.equal(cells, other.cells)); } return(false); }
/// <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"); }
/// <summary> /// Tests that executing a function that returns a success result returns the underlying result without wrapping it. /// </summary> public virtual void executeSuccessResultValue() { SupplierFunction <Result <ScenarioArray <string> > > fn = SupplierFunction.of(() => Result.success(ScenarioArray.of("foo"))); CalculationTaskCell cell = CalculationTaskCell.of(0, 0, TestingMeasures.PRESENT_VALUE, REPORTING_CURRENCY_USD); CalculationTask task = CalculationTask.of(TARGET, fn, cell); ScenarioMarketData marketData = ImmutableScenarioMarketData.builder(date(2011, 3, 8)).build(); 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).hasValue(ScenarioArray.of("foo")); }
/// <summary> /// Test a non-convertible result is returned even if there is no reporting currency. /// </summary> public virtual void nonConvertibleResultReturnedWhenNoReportingCurrency() { TestFunction fn = new TestFunction(); CalculationTaskCell cell = CalculationTaskCell.of(0, 0, TestingMeasures.PRESENT_VALUE, NATURAL); CalculationTask task = CalculationTask.of(TARGET, fn, cell); ScenarioMarketData marketData = ImmutableScenarioMarketData.builder(date(2011, 3, 8)).build(); 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).hasValue(ScenarioArray.of("bar")); }
/// <summary> /// Test the result is returned unchanged if using ReportingCurrency.NONE. /// </summary> public virtual void convertResultCurrencyNoConversionRequested() { SupplierFunction <CurrencyAmount> fn = SupplierFunction.of(() => CurrencyAmount.of(EUR, 1d)); CalculationTaskCell cell = CalculationTaskCell.of(0, 0, TestingMeasures.PRESENT_VALUE, ReportingCurrency.NONE); CalculationTask task = CalculationTask.of(TARGET, fn, cell); ScenarioMarketData marketData = ImmutableScenarioMarketData.builder(date(2011, 3, 8)).build(); 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).hasValue(ScenarioArray.of(CurrencyAmount.of(EUR, 1d))); }
/// <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> /// Test that the result is not converted if the isCurrencyConvertible flag on the measure is false. /// </summary> public virtual void currencyConversionHonoursConvertibleFlagOnMeasure() { DoubleArray values = DoubleArray.of(1, 2, 3); //JAVA TO C# CONVERTER TODO TASK: Most Java stream collectors are not converted by Java to C# Converter: IList <FxRate> rates = ImmutableList.of(1.61, 1.62, 1.63).Select(rate => FxRate.of(GBP, USD, rate)).collect(toImmutableList()); CurrencyScenarioArray list = CurrencyScenarioArray.of(GBP, values); ScenarioMarketData marketData = ImmutableScenarioMarketData.builder(date(2011, 3, 8)).addScenarioValue(FxRateId.of(GBP, USD), rates).build(); ConvertibleFunction fn = ConvertibleFunction.of(() => list, GBP); CalculationTaskCell cell = CalculationTaskCell.of(0, 0, TestingMeasures.PRESENT_VALUE_MULTI_CCY, REPORTING_CURRENCY_USD); CalculationTask task = CalculationTask.of(TARGET, fn, cell); CurrencyScenarioArray expectedArray = CurrencyScenarioArray.of(GBP, values); 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).hasValue(expectedArray); }
//------------------------------------------------------------------------- /// <summary> /// Executes the task, performing calculations for the target using multiple sets of market data. /// <para> /// This invokes the function with the correct set of market data. /// /// </para> /// </summary> /// <param name="marketData"> the market data used in the calculation </param> /// <param name="refData"> the reference data </param> /// <returns> results of the calculation, one for every scenario in the market data </returns> //JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @SuppressWarnings("unchecked") public CalculationResults execute(com.opengamma.strata.data.scenario.ScenarioMarketData marketData, com.opengamma.strata.basics.ReferenceData refData) public CalculationResults execute(ScenarioMarketData marketData, ReferenceData refData) { // calculate the results //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 = calculate(marketData, refData); IDictionary <Measure, Result <object> > results = calculate(marketData, refData); // get a suitable FX provider ScenarioFxRateProvider fxProvider = parameters.findParameter(typeof(FxRateLookup)).map(lookup => LookupScenarioFxRateProvider.of(marketData, lookup)).orElse(ScenarioFxRateProvider.of(marketData)); // convert the results, using a normal loop for better stack traces ImmutableList.Builder <CalculationResult> resultBuilder = ImmutableList.builder(); foreach (CalculationTaskCell cell in cells) { resultBuilder.add(cell.createResult(this, target, results, fxProvider, refData)); } // return the result return(CalculationResults.of(target, resultBuilder.build())); }
/// <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'"); }