public virtual void test_combinedWith_other_other_noClashSame()
{
ReferenceData test = REF_DATA1.combinedWith(REF_DATA12);
assertEquals(test.getValue(ID1), VAL1);
assertEquals(test.getValue(ID2), VAL2);
}
//-------------------------------------------------------------------------
public virtual void test_combinedWith_IRD_other_noClash()
{
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: java.util.Map<ReferenceDataId<?>, Object> dataMap1 = com.google.common.collect.ImmutableMap.of(ID1, VAL1);
IDictionary <ReferenceDataId <object>, object> dataMap1 = ImmutableMap.of(ID1, VAL1);
ImmutableReferenceData test1 = ImmutableReferenceData.of(dataMap1);
ReferenceData test = test1.combinedWith(REF_DATA2);
assertEquals(test.getValue(ID1), VAL1);
assertEquals(test.getValue(ID2), VAL2);
}
//-------------------------------------------------------------------------
public virtual void test_defaulting()
{
ReferenceData @base = ImmutableReferenceData.of(ImmutableMap.of(HolidayCalendarIds.FRI_SAT, HolidayCalendars.FRI_SAT));
ReferenceData test = HolidayCalendars.defaultingReferenceData(@base);
assertEquals(test.getValue(HolidayCalendarIds.FRI_SAT), HolidayCalendars.FRI_SAT);
assertEquals(test.getValue(HolidayCalendarIds.GBLO), DEFAULTED_GBLO);
assertEquals(test.containsValue(HolidayCalendarIds.FRI_SAT), true);
assertEquals(test.containsValue(HolidayCalendarIds.GBLO), true);
assertEquals(test.containsValue(new TestingReferenceDataId("1")), false);
}
//-------------------------------------------------------------------------
public virtual FunctionRequirements requirements(SecurityTrade trade, ISet <Measure> measures, CalculationParameters parameters, ReferenceData refData)
{
Security security = refData.getValue(trade.SecurityId);
QuoteId id = QuoteId.of(trade.SecurityId.StandardId);
return(FunctionRequirements.builder().valueRequirements(ImmutableSet.of(id)).outputCurrencies(security.Currency).build());
}
//-------------------------------------------------------------------------
public virtual void test_defaultMethods()
{
assertEquals(REF_DATA1.containsValue(ID1), true);
assertEquals(REF_DATA1.containsValue(ID2), false);
assertEquals(REF_DATA1.getValue(ID1), VAL1);
assertThrows(() => REF_DATA1.getValue(ID2), typeof(ReferenceDataNotFoundException));
assertEquals(REF_DATA1.findValue(ID1), VAL1);
assertEquals(REF_DATA1.findValue(ID2), null);
assertEquals(REF_DATA1.queryValueOrNull(ID1), VAL1);
assertEquals(REF_DATA1.queryValueOrNull(ID2), null);
assertEquals(ID1.queryValueOrNull(REF_DATA1), VAL1);
assertEquals(ID2.queryValueOrNull(REF_DATA1), null);
}
public virtual void test_empty()
{
ReferenceData test = ReferenceData.empty();
assertEquals(test.containsValue(ID1), false);
assertThrows(() => test.getValue(ID1), typeof(ReferenceDataNotFoundException));
assertEquals(test.findValue(ID1), null);
}
public virtual void test_of_single()
{
ReferenceData test = ImmutableReferenceData.of(ID1, VAL1);
assertEquals(test.containsValue(HolidayCalendarIds.NO_HOLIDAYS), false);
assertEquals(test.containsValue(HolidayCalendarIds.SAT_SUN), false);
assertEquals(test.containsValue(HolidayCalendarIds.FRI_SAT), false);
assertEquals(test.containsValue(HolidayCalendarIds.THU_FRI), false);
assertEquals(test.containsValue(ID1), true);
assertEquals(test.getValue(ID1), VAL1);
assertEquals(test.findValue(ID1), VAL1);
assertEquals(test.containsValue(ID2), false);
assertThrows(() => test.getValue(ID2), typeof(ReferenceDataNotFoundException));
assertEquals(test.findValue(ID2), null);
}
//-------------------------------------------------------------------------
public virtual void test_resolve_single()
{
HolidayCalendarId gb = HolidayCalendarId.of("GB");
HolidayCalendarId eu = HolidayCalendarId.of("EU");
HolidayCalendar gbCal = HolidayCalendars.SAT_SUN;
ReferenceData refData = ImmutableReferenceData.of(gb, gbCal);
assertEquals(gb.resolve(refData), gbCal);
assertThrows(() => eu.resolve(refData), typeof(ReferenceDataNotFoundException));
assertEquals(refData.getValue(gb), gbCal);
}
//-------------------------------------------------------------------------
public IborFutureOption createProduct(ReferenceData refData)
{
Security security = refData.getValue(underlyingFutureId);
if (!(security is IborFutureSecurity))
{
throw new System.InvalidCastException(Messages.format("{} underlying future '{}' resolved to '{}' when '{}' was expected", typeof(IborFutureOptionSecurity).Name, underlyingFutureId, security.GetType().Name, typeof(IborFutureSecurity).Name));
}
IborFutureSecurity futureSec = (IborFutureSecurity)security;
IborFuture underlying = futureSec.createProduct(refData);
return(new IborFutureOption(SecurityId, putCall, strikePrice, expiryDate, expiryTime, expiryZone, premiumStyle, rounding, underlying));
}
public virtual void test_resolve_combined_direct()
{
HolidayCalendarId gb = HolidayCalendarId.of("GB");
HolidayCalendar gbCal = HolidayCalendars.SAT_SUN;
HolidayCalendarId eu = HolidayCalendarId.of("EU");
HolidayCalendar euCal = HolidayCalendars.FRI_SAT;
HolidayCalendarId combined = gb.combinedWith(eu);
HolidayCalendar combinedCal = euCal.combinedWith(gbCal);
ReferenceData refData = ImmutableReferenceData.of(ImmutableMap.of(combined, combinedCal));
assertEquals(combined.resolve(refData), combinedCal);
assertEquals(refData.getValue(combined), combinedCal);
}
public virtual void test_defaulting_combinedWith()
{
ReferenceData base1 = ImmutableReferenceData.of(ImmutableMap.of(HolidayCalendarIds.THU_FRI, HolidayCalendars.THU_FRI));
ReferenceData base2 = ImmutableReferenceData.of(ImmutableMap.of(HolidayCalendarIds.THU_FRI, HolidayCalendars.FRI_SAT, HolidayCalendarIds.FRI_SAT, HolidayCalendars.FRI_SAT));
ReferenceData testDefaulted = HolidayCalendars.defaultingReferenceData(base1);
assertEquals(testDefaulted.getValue(HolidayCalendarIds.THU_FRI), HolidayCalendars.THU_FRI);
assertEquals(testDefaulted.getValue(HolidayCalendarIds.FRI_SAT), DEFAULTED_FRI_SAT);
assertEquals(testDefaulted.getValue(HolidayCalendarIds.GBLO), DEFAULTED_GBLO);
ReferenceData testCombined = testDefaulted.combinedWith(base2);
assertEquals(testCombined.getValue(HolidayCalendarIds.THU_FRI), HolidayCalendars.THU_FRI); // test1 takes precedence
assertEquals(testCombined.getValue(HolidayCalendarIds.FRI_SAT), HolidayCalendars.FRI_SAT); // from test2
assertEquals(testCombined.getValue(HolidayCalendarIds.GBLO), DEFAULTED_GBLO); // from default
ReferenceData testCombinedRevered = base2.combinedWith(testDefaulted);
assertEquals(testCombinedRevered.getValue(HolidayCalendarIds.THU_FRI), HolidayCalendars.FRI_SAT); // test2 takes precedence
assertEquals(testCombinedRevered.getValue(HolidayCalendarIds.FRI_SAT), HolidayCalendars.FRI_SAT); // from test2
assertEquals(testCombinedRevered.getValue(HolidayCalendarIds.GBLO), DEFAULTED_GBLO); // from default
}
//-------------------------------------------------------------------------
public virtual void test_of_RD()
{
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: java.util.Map<ReferenceDataId<?>, Object> dataMap = com.google.common.collect.ImmutableMap.of(ID1, VAL1, ID2, VAL2);
IDictionary <ReferenceDataId <object>, object> dataMap = ImmutableMap.of(ID1, VAL1, ID2, VAL2);
ReferenceData test = ReferenceData.of(dataMap);
assertEquals(test.containsValue(HolidayCalendarIds.NO_HOLIDAYS), true);
assertEquals(test.containsValue(HolidayCalendarIds.SAT_SUN), true);
assertEquals(test.containsValue(HolidayCalendarIds.FRI_SAT), true);
assertEquals(test.containsValue(HolidayCalendarIds.THU_FRI), true);
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(ReferenceDataNotFoundException));
assertEquals(test.findValue(ID3), null);
}
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: @Override public com.opengamma.strata.product.SecuritizedProductPosition<?> resolveTarget(com.opengamma.strata.basics.ReferenceData refData)
public SecuritizedProductPosition <object> resolveTarget(ReferenceData refData)
{
SecurityId securityId = SecurityId;
Security security = refData.getValue(securityId);
Position position = security.createPosition(Info, LongQuantity, ShortQuantity, refData);
if (position is SecuritizedProductPosition)
{
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: return (com.opengamma.strata.product.SecuritizedProductPosition<?>) position;
return((SecuritizedProductPosition <object>)position);
}
//JAVA TO C# CONVERTER WARNING: The .NET Type.FullName property will not always yield results identical to the Java Class.getName method:
throw new System.InvalidCastException(Messages.format("Reference data for security '{}' did not implement SecuritizedProductPosition: ", securityId, position.GetType().FullName));
}
//-------------------------------------------------------------------------
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: @Override public java.util.Map<com.opengamma.strata.calc.Measure, com.opengamma.strata.collect.result.Result<?>> calculate(com.opengamma.strata.product.SecurityTrade trade, java.util.Set<com.opengamma.strata.calc.Measure> measures, com.opengamma.strata.calc.runner.CalculationParameters parameters, com.opengamma.strata.data.scenario.ScenarioMarketData scenarioMarketData, com.opengamma.strata.basics.ReferenceData refData)
public virtual IDictionary <Measure, Result <object> > calculate(SecurityTrade trade, ISet <Measure> measures, CalculationParameters parameters, ScenarioMarketData scenarioMarketData, ReferenceData refData)
{
// resolve security
Security security = refData.getValue(trade.SecurityId);
// loop around measures, calculating all scenarios for one measure
//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 = new java.util.HashMap<>();
IDictionary <Measure, Result <object> > results = new Dictionary <Measure, Result <object> >();
foreach (Measure measure in measures)
{
results[measure] = calculate(measure, trade, security, scenarioMarketData);
}
return(results);
}
//-------------------------------------------------------------------------
/// <summary>
/// Resolves this identifier to a holiday calendar using the specified reference data.
/// <para>
/// This returns an instance of <seealso cref="HolidayCalendar"/> that can perform calculations.
/// </para>
/// <para>
/// Resolved objects may be bound to data that changes over time, such as holiday calendars.
/// If the data changes, such as the addition of a new holiday, the resolved form will not be updated.
/// Care must be taken when placing the resolved form in a cache or persistence layer.
///
/// </para>
/// </summary>
/// <param name="refData"> the reference data, used to resolve the reference </param>
/// <returns> the resolved holiday calendar </returns>
/// <exception cref="ReferenceDataNotFoundException"> if the identifier is not found </exception>
public HolidayCalendar resolve(ReferenceData refData)
{
return(refData.getValue(this));
}
public virtual Currency naturalCurrency(SecurityTrade trade, ReferenceData refData)
{
Security security = refData.getValue(trade.SecurityId);
return(security.Currency);
}
public virtual Currency naturalCurrency(SecurityPosition position, ReferenceData refData)
{
Security security = refData.getValue(position.SecurityId);
return(security.Currency);
}
public virtual void test_combinedWith_other_other_clash()
{
ReferenceData combined = REF_DATA1.combinedWith(REF_DATA3);
assertEquals(combined.getValue(ID1), VAL1);
}