private static MarketDataConfig config()
{
IDictionary <CurrencyPair, QuoteId> ratesMap = ImmutableMap.of(CURRENCY_PAIR, QUOTE_ID);
FxRateConfig fxRateConfig = FxRateConfig.builder().observableRates(ratesMap).build();
return(MarketDataConfig.builder().add(ObservableSource.NONE, fxRateConfig).build());
}
//-------------------------------------------------------------------------
public virtual void test_of_2arg()
{
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: java.util.Map<MarketDataId<?>, Object> dataMap = com.google.common.collect.ImmutableMap.of(ID1, VAL1, ID2, VAL2);
IDictionary <MarketDataId <object>, object> dataMap = ImmutableMap.of(ID1, VAL1, ID2, VAL2);
MarketData test = MarketData.of(VAL_DATE, dataMap);
assertEquals(test.containsValue(ID1), true);
assertEquals(test.getValue(ID1), VAL1);
assertEquals(test.findValue(ID1), VAL1);
assertEquals(test.containsValue(ID2), true);
assertEquals(test.getValue(ID2), VAL2);
assertEquals(test.findValue(ID2), VAL2);
assertEquals(test.containsValue(ID3), false);
assertThrows(() => test.getValue(ID3), typeof(MarketDataNotFoundException));
assertEquals(test.findValue(ID3), null);
assertEquals(test.Ids, ImmutableSet.of(ID1, ID2));
assertEquals(test.findIds(ID1.MarketDataName), ImmutableSet.of(ID1));
assertEquals(test.findIds(new TestingName("Foo")), ImmutableSet.of());
assertEquals(test.getTimeSeries(ID4), LocalDateDoubleTimeSeries.empty());
assertEquals(test.getTimeSeries(ID5), LocalDateDoubleTimeSeries.empty());
}
/// <summary>
/// Loads the priority order of currencies, used to determine the base currency of the market convention pair
/// for pairs that aren't explicitly configured.
/// </summary>
/// <returns> a map of currency to order </returns>
internal static ImmutableMap <Currency, int> loadOrdering()
{
try
{
IniFile ini = ResourceConfig.combinedIniFile(ResourceConfig.orderedResources(CURRENCY_DATA_INI));
PropertySet section = ini.section("marketConventionPriority");
string list = section.value("ordering");
// The currency ordering is defined as a comma-separated list
//JAVA TO C# CONVERTER TODO TASK: Most Java stream collectors are not converted by Java to C# Converter:
IList <Currency> currencies = java.util.list.Split(",", true).Select(string.Trim).Select(Currency.of).collect(toImmutableList());
ImmutableMap.Builder <Currency, int> orderBuilder = ImmutableMap.builder();
for (int i = 0; i < currencies.Count; i++)
{
orderBuilder.put(currencies[i], i + 1);
}
return(orderBuilder.build());
}
catch (Exception ex)
{
// logging used because this is loaded in a static variable
log.severe(Throwables.getStackTraceAsString(ex));
// return an empty instance to avoid ExceptionInInitializerError
return(ImmutableMap.of());
}
}
//-------------------------------------------------------------------------
internal static ScenarioMarketData marketData()
{
LocalDateDoubleTimeSeries ts = LocalDateDoubleTimeSeries.of(date(2015, 10, 19), 0.013);
TestMarketDataMap md = new TestMarketDataMap(VAL_DATE, ImmutableMap.of(DISCOUNT_CURVE_ID, SwaptionSabrRateVolatilityDataSet.CURVE_DSC_EUR, FORWARD_CURVE_ID, SwaptionSabrRateVolatilityDataSet.CURVE_FWD_EUR, SWAPTION_ID, VOLS), ImmutableMap.of(IndexQuoteId.of(SWAP_INDEX), ts));
return(md);
}
//-------------------------------------------------------------------------
internal static ScenarioMarketData marketData()
{
Curve curve = ConstantCurve.of(Curves.discountFactors("Test", ACT_360), 0.99);
TestMarketDataMap md = new TestMarketDataMap(VAL_DATE, ImmutableMap.of(DISCOUNT_CURVE_ID, curve), ImmutableMap.of());
return(md);
}
//-------------------------------------------------------------------------
public virtual void test_of()
{
CalculationFunctions functions = CalculationFunctions.of(ImmutableMap.of(typeof(TestTarget), new TestFunction()));
IList <TestTarget> targets = ImmutableList.of(TARGET1, TARGET2);
IList <Column> columns = ImmutableList.of(Column.of(TestingMeasures.PRESENT_VALUE), Column.of(TestingMeasures.PAR_RATE));
CalculationRules calculationRules = CalculationRules.of(functions, USD);
CalculationTasks test = CalculationTasks.of(calculationRules, targets, columns);
assertThat(test.Targets).hasSize(2);
assertThat(test.Targets).containsExactly(TARGET1, TARGET2);
assertThat(test.Columns).hasSize(2);
assertThat(test.Columns).containsExactly(Column.of(TestingMeasures.PRESENT_VALUE), Column.of(TestingMeasures.PAR_RATE));
assertThat(test.Tasks).hasSize(2);
assertThat(test.Tasks[0].Target).isEqualTo(TARGET1);
assertThat(test.Tasks[0].Cells.size()).isEqualTo(2);
assertThat(test.Tasks[0].Cells.get(0).RowIndex).isEqualTo(0);
assertThat(test.Tasks[0].Cells.get(0).ColumnIndex).isEqualTo(0);
assertThat(test.Tasks[0].Cells.get(0).Measure).isEqualTo(TestingMeasures.PRESENT_VALUE);
assertThat(test.Tasks[0].Cells.get(1).RowIndex).isEqualTo(0);
assertThat(test.Tasks[0].Cells.get(1).ColumnIndex).isEqualTo(1);
assertThat(test.Tasks[0].Cells.get(1).Measure).isEqualTo(TestingMeasures.PAR_RATE);
assertThat(test.Tasks[1].Target).isEqualTo(TARGET2);
assertThat(test.Tasks[1].Cells.size()).isEqualTo(2);
assertThat(test.Tasks[1].Cells.get(0).RowIndex).isEqualTo(1);
assertThat(test.Tasks[1].Cells.get(0).ColumnIndex).isEqualTo(0);
assertThat(test.Tasks[1].Cells.get(0).Measure).isEqualTo(TestingMeasures.PRESENT_VALUE);
assertThat(test.Tasks[1].Cells.get(1).RowIndex).isEqualTo(1);
assertThat(test.Tasks[1].Cells.get(1).ColumnIndex).isEqualTo(1);
assertThat(test.Tasks[1].Cells.get(1).Measure).isEqualTo(TestingMeasures.PAR_RATE);
coverImmutableBean(test);
assertNotNull(CalculationTasks.meta());
}
//-------------------------------------------------------------------------
internal static ScenarioMarketData marketData()
{
Curve curve = ConstantCurve.of(Curves.discountFactors("Test", ACT_360), 0.99);
TestMarketDataMap md = new TestMarketDataMap(VAL_DATE, ImmutableMap.of(DISCOUNT_CURVE_ID, curve, FORWARD_CURVE_ID, curve, VOL_ID, NORMAL_VOL_SWAPTION_PROVIDER_USD), ImmutableMap.of());
return(md);
}
public virtual void test_toCombinedFutureMap()
{
CompletableFuture <string> future1 = new CompletableFuture <string>();
future1.complete("A");
System.Threading.CountdownEvent latch = new System.Threading.CountdownEvent(1);
CompletableFuture <string> future2 = CompletableFuture.supplyAsync(() =>
{
try
{
latch.await();
}
catch (InterruptedException)
{
}
return("B");
});
IDictionary <string, CompletableFuture <string> > input = ImmutableMap.of("a", future1, "b", future2);
//JAVA TO C# CONVERTER TODO TASK: Most Java stream collectors are not converted by Java to C# Converter:
CompletableFuture <IDictionary <string, string> > test = input.SetOfKeyValuePairs().collect(Guavate.toCombinedFutureMap());
assertEquals(test.Done, false);
latch.Signal();
IDictionary <string, string> combined = test.join();
assertEquals(test.Done, true);
assertEquals(combined.Count, 2);
assertEquals(combined["a"], "A");
assertEquals(combined["b"], "B");
}
public virtual void endedTest()
{
LocalDate valuationDate = PRODUCT.ProtectionEndDate.plusDays(1);
CreditRatesProvider provider = createCreditRatesProviderSingle(valuationDate, false);
double price = PRICER.price(PRODUCT, provider, SETTLEMENT_STD, CLEAN, REF_DATA);
assertEquals(price, 0d);
CurrencyAmount pv = PRICER.presentValue(PRODUCT, provider, SETTLEMENT_STD, CLEAN, REF_DATA);
assertEquals(pv, CurrencyAmount.zero(USD));
assertThrowsIllegalArg(() => PRICER.parSpread(PRODUCT, provider, SETTLEMENT_STD, REF_DATA));
CurrencyAmount rpv01 = PRICER.rpv01(PRODUCT, provider, SETTLEMENT_STD, CLEAN, REF_DATA);
assertEquals(rpv01, CurrencyAmount.zero(USD));
CurrencyAmount recovery01 = PRICER.recovery01(PRODUCT, provider, SETTLEMENT_STD, REF_DATA);
assertEquals(recovery01, CurrencyAmount.zero(USD));
PointSensitivityBuilder sensi = PRICER.presentValueSensitivity(PRODUCT, provider, SETTLEMENT_STD, REF_DATA);
assertEquals(sensi, PointSensitivityBuilder.none());
PointSensitivityBuilder sensiPrice = PRICER.priceSensitivity(PRODUCT, provider, SETTLEMENT_STD, REF_DATA);
assertEquals(sensiPrice, PointSensitivityBuilder.none());
assertThrowsIllegalArg(() => PRICER.parSpreadSensitivity(PRODUCT, provider, SETTLEMENT_STD, REF_DATA));
JumpToDefault jumpToDefault = PRICER.jumpToDefault(PRODUCT, provider, SETTLEMENT_STD, REF_DATA);
assertEquals(jumpToDefault, JumpToDefault.of(USD, ImmutableMap.of(INDEX_ID, 0d)));
CurrencyAmount expectedLoss = PRICER.expectedLoss(PRODUCT, provider);
assertEquals(expectedLoss, CurrencyAmount.zero(USD));
}
//-------------------------------------------------------------------------
public virtual void test_combineFuturesAsMap()
{
CompletableFuture <string> future1 = new CompletableFuture <string>();
future1.complete("A");
System.Threading.CountdownEvent latch = new System.Threading.CountdownEvent(1);
CompletableFuture <string> future2 = CompletableFuture.supplyAsync(() =>
{
try
{
latch.await();
}
catch (InterruptedException)
{
}
return("B");
});
IDictionary <string, CompletableFuture <string> > input = ImmutableMap.of("a", future1, "b", future2);
CompletableFuture <IDictionary <string, string> > test = Guavate.combineFuturesAsMap(input);
assertEquals(test.Done, false);
latch.Signal();
IDictionary <string, string> combined = test.join();
assertEquals(test.Done, true);
assertEquals(combined.Count, 2);
assertEquals(combined["a"], "A");
assertEquals(combined["b"], "B");
}
public virtual void test_combineFuturesAsMap_exception()
{
CompletableFuture <string> future1 = new CompletableFuture <string>();
future1.complete("A");
System.Threading.CountdownEvent latch = new System.Threading.CountdownEvent(1);
CompletableFuture <string> future2 = CompletableFuture.supplyAsync(() =>
{
try
{
latch.await();
}
catch (InterruptedException)
{
}
throw new System.InvalidOperationException("Oops");
});
IDictionary <string, CompletableFuture <string> > input = ImmutableMap.of("a", future1, "b", future2);
CompletableFuture <IDictionary <string, string> > test = Guavate.combineFuturesAsMap(input);
assertEquals(test.Done, false);
latch.Signal();
assertThrows(typeof(CompletionException), () => test.join());
assertEquals(test.Done, true);
assertEquals(test.CompletedExceptionally, true);
}
public virtual void test_minusDifferentSize()
{
MultiCurrencyAmountArray array1 = MultiCurrencyAmountArray.of(ImmutableMap.of(Currency.USD, DoubleArray.of(30, 32), Currency.EUR, DoubleArray.of(40, 43), Currency.CHF, DoubleArray.of(50, 54)));
MultiCurrencyAmountArray array2 = MultiCurrencyAmountArray.of(ImmutableMap.of(Currency.GBP, DoubleArray.of(20, 21, 22), Currency.EUR, DoubleArray.of(140, 143, 144), Currency.CHF, DoubleArray.of(250, 254, 256)));
assertThrowsIllegalArg(() => array1.minus(array2));
}
//-------------------------------------------------------------------------
public virtual void test_empty()
{
CurveSensitivities test = CurveSensitivities.empty();
assertEquals(test.Info, PortfolioItemInfo.empty());
assertEquals(test.TypedSensitivities, ImmutableMap.of());
}
// obtains the data and calculates the grid of results
private static void calculate(CalculationRunner runner)
{
// the trades that will have measures calculated
IList <Trade> trades = ImmutableList.of(createFutureTrade1(), createFutureTrade2(), createOptionTrade1(), createOptionTrade2());
// the columns, specifying the measures to be calculated
IList <Column> columns = ImmutableList.of(Column.of(Measures.PRESENT_VALUE));
// use the built-in example market data
LocalDate valuationDate = LocalDate.of(2014, 1, 22);
ExampleMarketDataBuilder marketDataBuilder = ExampleMarketData.builder();
MarketData marketData = marketDataBuilder.buildSnapshot(valuationDate);
// the complete set of rules for calculating measures
CalculationFunctions functions = StandardComponents.calculationFunctions();
CalculationRules rules = CalculationRules.of(functions);
// the reference data, such as holidays and securities
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: com.opengamma.strata.basics.ReferenceData refData = com.opengamma.strata.basics.ImmutableReferenceData.of(com.google.common.collect.ImmutableMap.of<com.opengamma.strata.basics.ReferenceDataId<?>, Object>(FGBL_MAR14_ID, FGBL_MAR14, OGBL_MAR14_C150_ID, OGBL_MAR14_C150, ED_MAR14_ID, ED_MAR14));
ReferenceData refData = ImmutableReferenceData.of(ImmutableMap.of <ReferenceDataId <object>, object>(FGBL_MAR14_ID, FGBL_MAR14, OGBL_MAR14_C150_ID, OGBL_MAR14_C150, ED_MAR14_ID, ED_MAR14));
// calculate the results
Results results = runner.calculate(rules, trades, columns, marketData, refData);
// use the report runner to transform the engine results into a trade report
ReportCalculationResults calculationResults = ReportCalculationResults.of(valuationDate, trades, columns, results, functions, refData);
TradeReportTemplate reportTemplate = ExampleData.loadTradeReportTemplate("security-report-template");
TradeReport tradeReport = TradeReport.of(calculationResults, reportTemplate);
tradeReport.writeAsciiTable(System.out);
}
//-------------------------------------------------------------------------
private static MarketDataFxRateProvider provider()
{
IDictionary <FxRateId, FxRate> marketDataMap = ImmutableMap.of(FxRateId.of(EUR, USD, OBS_SOURCE), FxRate.of(EUR, USD, EUR_USD));
MarketData marketData = ImmutableMarketData.of(VAL_DATE, marketDataMap);
return(MarketDataFxRateProvider.of(marketData, OBS_SOURCE, GBP));
}
public virtual void mapValuesToValues()
{
IDictionary <string, int> expected = ImmutableMap.of("one", 2, "two", 4, "three", 6, "four", 8);
IDictionary <string, int> result = MapStream.of(map_Renamed).mapValues(v => v * 2).toMap();
assertThat(result).isEqualTo(expected);
}
private static MarketDataFxRateProvider provider2()
{
IDictionary <FxRateId, FxRate> marketDataMap = ImmutableMap.of(FxRateId.of(EUR, USD), FxRate.of(EUR, USD, EUR_USD), FxRateId.of(EUR, BEF), FxRate.of(EUR, BEF, EUR_BEF), FxRateId.of(GBP, USD), FxRate.of(GBP, USD, GBP_USD));
MarketData marketData = ImmutableMarketData.of(VAL_DATE, marketDataMap);
return(MarketDataFxRateProvider.of(marketData, ObservableSource.NONE, GBP));
}
public virtual void mapKeysAndValuesToValues()
{
IDictionary <string, string> expected = ImmutableMap.of("one", "one1", "two", "two2", "three", "three3", "four", "four4");
IDictionary <string, string> result = MapStream.of(map_Renamed).mapValues((k, v) => k + v).toMap();
assertThat(result).isEqualTo(expected);
}
//-------------------------------------------------------------------------
public virtual void test_requirements()
{
CalculationFunctions functions = CalculationFunctions.of(ImmutableMap.of(typeof(TestTarget), new TestFunction()));
CalculationRules calculationRules = CalculationRules.of(functions, USD);
IList <TestTarget> targets = ImmutableList.of(TARGET1);
IList <Column> columns = ImmutableList.of(Column.of(TestingMeasures.PRESENT_VALUE));
CalculationTasks test = CalculationTasks.of(calculationRules, targets, columns);
MarketDataRequirements requirements = test.requirements(REF_DATA);
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: java.util.Set<? extends com.opengamma.strata.data.MarketDataId<?>> nonObservables = requirements.getNonObservables();
ISet <MarketDataId <object> > nonObservables = requirements.NonObservables;
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: com.google.common.collect.ImmutableSet<? extends com.opengamma.strata.data.ObservableId> observables = requirements.getObservables();
ImmutableSet <ObservableId> observables = requirements.Observables;
ImmutableSet <ObservableId> timeSeries = requirements.TimeSeries;
assertThat(nonObservables).hasSize(1);
assertThat(nonObservables.GetEnumerator().next()).isEqualTo(TestId.of("1"));
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: com.opengamma.strata.data.MarketDataId<?> observableId = com.opengamma.strata.calc.marketdata.TestObservableId.of("2", CalculationTaskTest.OBS_SOURCE);
MarketDataId <object> observableId = TestObservableId.of("2", CalculationTaskTest.OBS_SOURCE);
assertThat(observables).hasSize(1);
assertThat(observables.GetEnumerator().next()).isEqualTo(observableId);
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: com.opengamma.strata.data.MarketDataId<?> timeSeriesId = com.opengamma.strata.calc.marketdata.TestObservableId.of("3", CalculationTaskTest.OBS_SOURCE);
MarketDataId <object> timeSeriesId = TestObservableId.of("3", CalculationTaskTest.OBS_SOURCE);
assertThat(timeSeries).hasSize(1);
assertThat(timeSeries.GetEnumerator().next()).isEqualTo(timeSeriesId);
}
//-------------------------------------------------------------------------
public virtual void filter()
{
IDictionary <string, int> expected = ImmutableMap.of("one", 1, "two", 2);
IDictionary <string, int> result = MapStream.of(map_Renamed).filter((k, v) => k.Equals("one") || v == 2).toMap();
assertThat(result).isEqualTo(expected);
}
/// <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);
}
public virtual void filterValues()
{
IDictionary <string, int> expected = ImmutableMap.of("one", 1, "two", 2);
IDictionary <string, int> result = MapStream.of(map_Renamed).filterValues(v => v < 3).toMap();
assertThat(result).isEqualTo(expected);
}
//-------------------------------------------------------------------------
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @VisibleForTesting static com.google.common.collect.ImmutableMap<String, HolidayCalendar> loadFromIni(String filename)
internal static ImmutableMap <string, HolidayCalendar> loadFromIni(string filename)
{
IList <ResourceLocator> resources = ResourceConfig.orderedResources(filename);
IDictionary <string, HolidayCalendar> map = new Dictionary <string, HolidayCalendar>();
foreach (ResourceLocator resource in resources)
{
try
{
IniFile ini = IniFile.of(resource.CharSource);
foreach (string sectionName in ini.sections())
{
PropertySet section = ini.section(sectionName);
HolidayCalendar parsed = parseHolidayCalendar(sectionName, section);
map[parsed.Name] = parsed;
if (!map.ContainsKey(parsed.Name.ToUpper(Locale.ENGLISH)))
{
map.Add(parsed.Name.ToUpper(Locale.ENGLISH), parsed);
}
}
}
catch (Exception ex)
{
log.log(Level.SEVERE, "Error processing resource as Holiday Calendar INI file: " + resource, ex);
return(ImmutableMap.of());
}
}
return(ImmutableMap.copyOf(map));
}
public virtual void filterValues_byClass()
{
IDictionary <Number, Number> map = ImmutableMap.of(1, 11, 2d, 22, 3, 33d);
IDictionary <Number, int> result = MapStream.of(map).filterValues(typeof(Integer)).toMap();
assertThat(result).isEqualTo(ImmutableMap.of(1, 11, 2d, 22));
}
// calculates the result
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: private java.util.Map<com.opengamma.strata.calc.Measure, com.opengamma.strata.collect.result.Result<?>> calculate(com.opengamma.strata.data.scenario.ScenarioMarketData marketData, com.opengamma.strata.basics.ReferenceData refData)
private IDictionary <Measure, Result <object> > calculate(ScenarioMarketData marketData, ReferenceData refData)
{
try
{
ISet <Measure> requestedMeasures = Measures;
ISet <Measure> supportedMeasures = function.supportedMeasures();
ISet <Measure> measures = Sets.intersection(requestedMeasures, supportedMeasures);
//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<?>> map = com.google.common.collect.ImmutableMap.of();
IDictionary <Measure, Result <object> > map = ImmutableMap.of();
if (measures.Count > 0)
{
map = function.calculate(target, measures, parameters, marketData, refData);
}
// check if result does not contain all requested measures
//JAVA TO C# CONVERTER TODO TASK: There is no .NET equivalent to the java.util.Collection 'containsAll' method:
if (!map.Keys.containsAll(requestedMeasures))
{
return(handleMissing(requestedMeasures, supportedMeasures, map));
}
return(map);
}
catch (Exception ex)
{
return(handleFailure(ex));
}
}
public virtual void mapKeysToKeys()
{
IDictionary <string, int> expected = ImmutableMap.of("ONE", 1, "TWO", 2, "THREE", 3, "FOUR", 4);
IDictionary <string, int> result = MapStream.of(map_Renamed).mapKeys(k => k.ToUpper(Locale.ENGLISH)).toMap();
assertThat(result).isEqualTo(expected);
}
private static ImmutableMap <string, OvernightIndex> loadFromCsv()
{
IList <ResourceLocator> resources = ResourceConfig.orderedResources("OvernightIndexData.csv");
IDictionary <string, OvernightIndex> map = new Dictionary <string, OvernightIndex>();
foreach (ResourceLocator resource in resources)
{
try
{
CsvFile csv = CsvFile.of(resource.CharSource, true);
foreach (CsvRow row in csv.rows())
{
OvernightIndex parsed = parseOvernightIndex(row);
map[parsed.Name] = parsed;
if (!map.ContainsKey(parsed.Name.ToUpper(Locale.ENGLISH)))
{
map.Add(parsed.Name.ToUpper(Locale.ENGLISH), parsed);
}
}
}
catch (Exception ex)
{
log.log(Level.SEVERE, "Error processing resource as Overnight Index CSV file: " + resource, ex);
return(ImmutableMap.of());
}
}
return(ImmutableMap.copyOf(map));
}
public virtual void test_ofChained_chainToNowhere()
{
IniFile test = ResourceConfig.combinedIniFile("TestChain3.ini");
Multimap <string, string> keyValues1 = ImmutableListMultimap.of("a", "x", "b", "y");
assertEquals(test.asMap(), ImmutableMap.of("one", PropertySet.of(keyValues1)));
}
private IList <ExplainMap> flatten(ExplainMap explainMap)
{
IList <ExplainMap> flattenedMap = new List <ExplainMap>();
flatten(explainMap, false, ImmutableMap.of(), Maps.newHashMap(), 0, flattenedMap);
return(flattenedMap);
}
/// <summary>
/// Tests building a tree of requirements using market data functions.
/// </summary>
public virtual void buildDependencyTree()
{
MarketDataNode expected = rootNode(observableNode(new TestIdA(this, "1")), valueNode(new TestIdB(this, "2"), valueNode(new TestIdB(this, "4"), observableNode(new TestIdA(this, "5"))), timeSeriesNode(new TestIdA(this, "3"))), timeSeriesNode(new TestIdA(this, "6")));
// The requirements for the data directly used by the calculations
MarketDataRequirements requirements = MarketDataRequirements.builder().addValues(new TestIdA(this, "1"), new TestIdB(this, "2")).addTimeSeries(new TestIdA(this, "6")).build();
// Requirements for each item in the tree - used to initialize the functions
MarketDataRequirements id2Reqs = MarketDataRequirements.builder().addTimeSeries(new TestIdA(this, "3")).addValues(new TestIdB(this, "4")).build();
MarketDataRequirements id4Reqs = MarketDataRequirements.builder().addValues(new TestIdA(this, "5")).build();
ImmutableMap <TestIdB, MarketDataRequirements> reqsMap = ImmutableMap.of(new TestIdB(this, "2"), id2Reqs, new TestIdB(this, "4"), id4Reqs);
TestMarketDataFunctionA builderA = new TestMarketDataFunctionA();
TestMarketDataFunctionB builderB = new TestMarketDataFunctionB(reqsMap);
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: com.google.common.collect.ImmutableMap<Class, MarketDataFunction<?, ?>> functions = com.google.common.collect.ImmutableMap.of(TestIdA.class, builderA, TestIdB.class, builderB);
ImmutableMap <Type, MarketDataFunction <object, ?> > functions = ImmutableMap.of(typeof(TestIdA), builderA, typeof(TestIdB), builderB);
MarketDataNode root = MarketDataNode.buildDependencyTree(requirements, BuiltScenarioMarketData.empty(), MarketDataConfig.empty(), functions);
assertThat(root).isEqualTo(expected);
}
