public void StubValuesForInterface()
{
var value = StubValue.ForType(typeof(IMyInterface));
Assert.That(value, Is.InstanceOf <IProxy>());
Assert.That(((IProxy)value).BaseObject, Is.TypeOf <Mock>());
}
public void StubValuesForDelegate()
{
var value = StubValue.ForType(typeof(Action));
Assert.That(value, Is.InstanceOf <Delegate>());
Assert.That(((Delegate)value).Target, Is.InstanceOf <IProxy>());
Assert.That(((IProxy)((Delegate)value).Target).BaseObject, Is.TypeOf <Mock>());
}
public static bool StubValueHasFloatingRateArray(StubValue stubValue)
{
return(stubValue.Items[0] is FloatingRate);
}
public static FloatingRate[] GetStubValueFloatingRateArray(StubValue stubValue)
{
return(stubValue.Items.Cast <FloatingRate>().ToArray());
}
public static bool StubValueHasStubAmountArray(StubValue stubValue)
{
return(stubValue.Items[0] is Money);
}
public static Money[] GetStubValueStubAmountArray(StubValue stubValue)
{
return(stubValue.Items.Cast <Money>().ToArray());
}
public static bool StubValueHasStubRateArray(StubValue stubValue)
{
return(stubValue.Items[0] is decimal);
}
public static decimal[] GetStubValueStubRateArray(StubValue stubValue)
{
return(stubValue.Items.Select(item => (decimal)item).ToArray());
}
public static void UpdateStubCalculationPeriod(InterestRateStream interestRateStream, CalculationPeriod stubCalculationPeriod, StubValue stubValue)
{
if (XsdClassesFieldResolver.StubValueHasStubRateArray(stubValue))
{
Decimal fixedRate = XsdClassesFieldResolver.GetStubValueStubRateArray(stubValue)[0];
// Fixed rate
//
XsdClassesFieldResolver.SetCalculationPeriodFixedRate(stubCalculationPeriod, fixedRate);
}
//else if (XsdClassesFieldResolver.StubValue_HasFloatingRateArray(stubValue))
//{
// //Calculation calculation = XsdClassesFieldResolver.CalculationPeriodAmount_GetCalculation(interestRateStream.calculationPeriodAmount);
// //FloatingRate floatingRate = XsdClassesFieldResolver.GetStubValue_FloatingRateArray(stubValue)[0];
// //FloatingRateDefinition floatingRateDefinition = ForecastRateHelper.UpdateFloatingRateDefinition(floatingRate,
// // calculation.dayCountFraction,
// // stubCalculationPeriod);
// // no observed, no calculated rate, spread == 0.0
// //
// FloatingRateDefinition floatingRateDefinition = ForecastRateHelper.CreateFloatingRateDefinition(stubCalculationPeriod);
// XsdClassesFieldResolver.CalculationPeriod_SetFloatingRateDefinition(stubCalculationPeriod, floatingRateDefinition);
// //// Floating rate is set on UpdateCashflows phase.
// ////
// //XsdClassesFieldResolver.CalculationPeriod_SetFloatingRateDefinition(stubCalculationPeriod, floatingRateDefinition);
// //throw new NotImplementedException("");
//}
else if (XsdClassesFieldResolver.StubValueHasStubAmountArray(stubValue))
{
throw new NotImplementedException("stubCalculationPeriodAmount with stubAmount is not implemented.");
}
}
public void StubValuesForStrings()
{
Assert.That(StubValue.ForType(typeof(string)), Is.EqualTo(string.Empty));
}
public void StubValuesForArrays()
{
Assert.That(StubValue.ForType(typeof(int[])), Is.Empty);
Assert.That(StubValue.ForType(typeof(double[, ])), Is.Empty);
Assert.That(StubValue.ForType(typeof(string[, , ])), Is.Empty);
}
public void StubValuesForReferenceTypesWithoutDefaultConstructors()
{
Assert.That(StubValue.ForType(typeof(Uri)), Is.Null);
}
public void StubValuesForReferenceTypesWithDefaultConstructors()
{
Assert.That(StubValue.ForType(typeof(List <int>)), Is.Not.Null.And.TypeOf <List <int> >());
}
public void StubValuesForValueTypes()
{
Assert.AreEqual(0, StubValue.ForType(typeof(int)));
Assert.AreEqual(0.0, StubValue.ForType(typeof(double)));
Assert.AreEqual(0m, StubValue.ForType(typeof(decimal)));
}
private static void UpdateStubCalculationPeriodData(InterestRateStream interestRateStream, CalculationPeriod stubCalculationPeriod, StubValue stubValue, Notional notinalSchedule)
{
StubCalculationPeriodAmountHelper.UpdateStubCalculationPeriod(interestRateStream, stubCalculationPeriod, stubValue);
decimal notional = NotionalHelper.GetNotionalValue(notinalSchedule, stubCalculationPeriod.adjustedStartDate);
// Notinal amount
//
XsdClassesFieldResolver.CalculationPeriodSetNotionalAmount(stubCalculationPeriod, notional);
}
/// <summary>
/// Update calculation periods with rates/notional.
/// </summary>
/// <param name="interestRateStream"></param>
/// <param name="calculationPeriodsPrincipalExchangesAndStubs"></param>
public static void UpdateCalculationPeriodsData(InterestRateStream interestRateStream, CalculationPeriodsPrincipalExchangesAndStubs calculationPeriodsPrincipalExchangesAndStubs)
{
Calculation calculation = XsdClassesFieldResolver.CalculationPeriodAmountGetCalculation(interestRateStream.calculationPeriodAmount);
Notional notionalSchedule = XsdClassesFieldResolver.CalculationGetNotionalSchedule(calculation);
#region Generate FUTURE amounts for principle exchanges
// Initial PE
//
if (null != calculationPeriodsPrincipalExchangesAndStubs.InitialPrincipalExchange)
{
// initial OUTflow
//
decimal initialNotionalValue = ScheduleHelper.GetValue(notionalSchedule.notionalStepSchedule, calculationPeriodsPrincipalExchangesAndStubs.InitialPrincipalExchange.adjustedPrincipalExchangeDate);
calculationPeriodsPrincipalExchangesAndStubs.InitialPrincipalExchange.principalExchangeAmount = -initialNotionalValue;
calculationPeriodsPrincipalExchangesAndStubs.InitialPrincipalExchange.principalExchangeAmountSpecified = true;
}
// intermediatory PE
//
foreach (PrincipalExchange intermediatoryExchange in calculationPeriodsPrincipalExchangesAndStubs.IntermediatePrincipalExchanges)
{
DateTime principleExchangeDate = intermediatoryExchange.adjustedPrincipalExchangeDate;
//value at the day before principle exchange day
//
decimal prevNotionalValue = ScheduleHelper.GetValue(notionalSchedule.notionalStepSchedule, principleExchangeDate.AddDays(-1));
//value at principle exchange day ..
//
decimal newNotionalValue = ScheduleHelper.GetValue(notionalSchedule.notionalStepSchedule, principleExchangeDate);
decimal principalExchangeAmount = prevNotionalValue - newNotionalValue;
intermediatoryExchange.principalExchangeAmount = principalExchangeAmount;
intermediatoryExchange.principalExchangeAmountSpecified = true;
}
// Final PE
//
if (null != calculationPeriodsPrincipalExchangesAndStubs.FinalPrincipalExchange)
{
// pay the rest ot the notional back
//
decimal newNotionalValue = ScheduleHelper.GetValue(notionalSchedule.notionalStepSchedule,
calculationPeriodsPrincipalExchangesAndStubs.FinalPrincipalExchange.adjustedPrincipalExchangeDate);
calculationPeriodsPrincipalExchangesAndStubs.FinalPrincipalExchange.principalExchangeAmount = newNotionalValue;
calculationPeriodsPrincipalExchangesAndStubs.FinalPrincipalExchange.principalExchangeAmountSpecified = true;
}
#endregion
// Process standard calculation periods
//
foreach (CalculationPeriod calculationPeriod in calculationPeriodsPrincipalExchangesAndStubs.CalculationPeriods)
{
UpdateCalculationPeriodData(calculation, calculationPeriod, notionalSchedule);
}
// Process stub calculation periods
//
if (null != interestRateStream.stubCalculationPeriodAmount)
{
if ((null == interestRateStream.stubCalculationPeriodAmount.initialStub) &&
(null == interestRateStream.stubCalculationPeriodAmount.finalStub))
{
throw new System.Exception(
"interestRateStream.stubCalculationPeriodAmount.initialStub && interestRateStream.stubCalculationPeriodAmount.finalStub are null");
}
StubValue initialStub = interestRateStream.stubCalculationPeriodAmount.initialStub;
StubValue finalStub = interestRateStream.stubCalculationPeriodAmount.finalStub;
if (null != calculationPeriodsPrincipalExchangesAndStubs.InitialStubCalculationPeriod && null != initialStub)
{
UpdateStubCalculationPeriodData(interestRateStream, calculationPeriodsPrincipalExchangesAndStubs.InitialStubCalculationPeriod, initialStub, notionalSchedule);
}
if (null != calculationPeriodsPrincipalExchangesAndStubs.FinalStubCalculationPeriod && null != finalStub)
{
UpdateStubCalculationPeriodData(interestRateStream, calculationPeriodsPrincipalExchangesAndStubs.FinalStubCalculationPeriod, finalStub, notionalSchedule);
}
}
else
{
foreach (CalculationPeriod calculationPeriod in new[] { calculationPeriodsPrincipalExchangesAndStubs.InitialStubCalculationPeriod, calculationPeriodsPrincipalExchangesAndStubs.FinalStubCalculationPeriod })
{
if (null != calculationPeriod)
{
UpdateCalculationPeriodData(calculation, calculationPeriod, notionalSchedule);
}
}
}
}
