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));
}
//-------------------------------------------------------------------------
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 coverage()
{
ExtendedMarketData <string> test = ExtendedMarketData.of(ID1, VAL1, BASE_DATA);
coverImmutableBean(test);
ExtendedMarketData <string> test2 = ExtendedMarketData.of(ID2, VAL2, ImmutableMarketData.of(VAL_DATE, ImmutableMap.of()));
coverBeanEquals(test, test2);
}
private static ImmutableMarketData baseData()
{
//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);
IDictionary <ObservableId, LocalDateDoubleTimeSeries> timeSeriesMap = ImmutableMap.of(ID4, TIME_SERIES);
return(ImmutableMarketData.builder(VAL_DATE).values(dataMap).timeSeries(timeSeriesMap).build());
}
public virtual void cross_counter()
{
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));
MarketData marketData = ImmutableMarketData.of(VAL_DATE, marketDataMap);
FxRateProvider fx = MarketDataFxRateProvider.of(marketData);
assertEquals(fx.fxRate(USD, BEF), EUR_BEF / EUR_USD, 1.0E-10);
assertEquals(fx.fxRate(BEF, USD), EUR_USD / EUR_BEF, 1.0E-10);
}
public virtual void cross_base()
{
IDictionary <FxRateId, FxRate> marketDataMap = ImmutableMap.of(FxRateId.of(EUR, USD), FxRate.of(EUR, USD, EUR_USD), FxRateId.of(GBP, USD), FxRate.of(GBP, USD, GBP_USD));
MarketData marketData = ImmutableMarketData.of(VAL_DATE, marketDataMap);
FxRateProvider fx = MarketDataFxRateProvider.of(marketData);
assertEquals(fx.fxRate(GBP, EUR), GBP_USD / EUR_USD, 1.0E-10);
assertEquals(fx.fxRate(EUR, GBP), EUR_USD / GBP_USD, 1.0E-10);
}
//-------------------------------------------------------------------------
public virtual void test_builder()
{
ImmutableMarketData test = ImmutableMarketData.builder(VAL_DATE.plusDays(1)).valuationDate(VAL_DATE).addValue(ID1, "123").addValueUnsafe(ID2, "124").addValueMap(ImmutableMap.of(ID3, "201")).addTimeSeries(ID4, TIME_SERIES).build();
assertEquals(test.ValuationDate, VAL_DATE);
assertEquals(test.Values.get(ID1), "123");
assertEquals(test.Values.get(ID2), "124");
assertEquals(test.Ids, ImmutableSet.of(ID1, ID2, ID3));
assertEquals(test.TimeSeries.get(ID4), TIME_SERIES);
}
public virtual void cross_specified()
{
IDictionary <FxRateId, FxRate> marketDataMap = ImmutableMap.of(FxRateId.of(EUR, CHF), FxRate.of(EUR, CHF, EUR_CHF), FxRateId.of(GBP, CHF), FxRate.of(GBP, CHF, GBP_CHF));
MarketData marketData = ImmutableMarketData.of(VAL_DATE, marketDataMap);
FxRateProvider fx = MarketDataFxRateProvider.of(marketData, ObservableSource.NONE, CHF);
assertEquals(fx.fxRate(GBP, EUR), GBP_CHF / EUR_CHF, 1.0E-10);
assertEquals(fx.fxRate(EUR, GBP), EUR_CHF / GBP_CHF, 1.0E-10);
assertThrows(() => fx.fxRate(EUR, USD), typeof(MarketDataNotFoundException));
}
//-------------------------------------------------------------------------
public virtual void coverage()
{
//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);
IDictionary <MarketDataId <object>, object> dataMap = ImmutableMap.of(ID1, VAL1);
ImmutableMarketData test = ImmutableMarketData.of(VAL_DATE, dataMap);
coverImmutableBean(test);
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: java.util.Map<MarketDataId<?>, Object> dataMap2 = com.google.common.collect.ImmutableMap.of(ID2, VAL2);
IDictionary <MarketDataId <object>, object> dataMap2 = ImmutableMap.of(ID2, VAL2);
ImmutableMarketData test2 = ImmutableMarketData.of(VAL_DATE.minusDays(1), dataMap2);
coverBeanEquals(test, test2);
}
/// <summary>
/// Combines this set of market data with another.
/// <para>
/// The result combines both sets of market data.
/// Values are taken from this set of market data if available, otherwise they are taken
/// from the other set.
/// </para>
/// <para>
/// The valuation dates of the sets of market data must be the same.
///
/// </para>
/// </summary>
/// <param name="other"> the other market data </param>
/// <returns> the combined market data </returns>
public ImmutableMarketData combinedWith(ImmutableMarketData other)
{
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: java.util.Map<MarketDataId<?>, Object> combinedValues = new java.util.HashMap<>(other.values);
IDictionary <MarketDataId <object>, object> combinedValues = new Dictionary <MarketDataId <object>, object>(other.values);
//JAVA TO C# CONVERTER TODO TASK: There is no .NET Dictionary equivalent to the Java 'putAll' method:
combinedValues.putAll(values);
Dictionary <ObservableId, LocalDateDoubleTimeSeries> combinedTimeSeries = new Dictionary <ObservableId, LocalDateDoubleTimeSeries>(other.timeSeries);
//JAVA TO C# CONVERTER TODO TASK: There is no .NET Dictionary equivalent to the Java 'putAll' method:
combinedTimeSeries.putAll(timeSeries);
if (!valuationDate.Equals(other.valuationDate))
{
throw new System.ArgumentException("Unable to combine market data instances with different valuation dates");
}
return(new ImmutableMarketData(valuationDate, combinedValues, combinedTimeSeries));
}
public virtual void test_builder_badType()
{
assertThrows(() => ImmutableMarketData.builder(VAL_DATE).addValueUnsafe(ID1, 123d), typeof(System.InvalidCastException));
}
