public virtual void test_without_typeNotFound() { CalculationParameters test = CalculationParameters.empty(); CalculationParameters filtered1 = test.without(typeof(TestParameter)); assertEquals(filtered1.Parameters.size(), 0); }
//------------------------------------------------------------------------- public virtual void coverage() { CalculationParameters test = CalculationParameters.of(PARAM); coverImmutableBean(test); CalculationParameters test2 = CalculationParameters.empty(); coverBeanEquals(test, test2); assertNotNull(CalculationParameters.meta()); }
//------------------------------------------------------------------------- /// <summary> /// Obtains an instance that will calculate the specified cells. /// <para> /// The cells must all be for the same row index and none of the column indices must overlap. /// The result will contain no calculation parameters. /// /// </para> /// </summary> /// <param name="target"> the target for which the value will be calculated </param> /// <param name="function"> the function that performs the calculation </param> /// <param name="cells"> the cells to be calculated by this task </param> /// <returns> the task </returns> public static CalculationTask of <T1>(CalculationTarget target, CalculationFunction <T1> function, params CalculationTaskCell[] cells) where T1 : com.opengamma.strata.basics.CalculationTarget { return(of(target, function, CalculationParameters.empty(), ImmutableList.copyOf(cells))); }
/// <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); }