public virtual void test_ofDayOfWeek_next_oneMonth()
{
foreach (DayOfWeek dow in DayOfWeek.values())
{
RollConvention test = RollConvention.ofDayOfWeek(dow);
assertEquals(test.next(date(2014, AUGUST, 14), P1W), date(2014, AUGUST, 21).with(TemporalAdjusters.nextOrSame(dow)));
}
}
public virtual void test_ofDayOfWeek_previous_oneDay()
{
foreach (DayOfWeek dow in DayOfWeek.values())
{
RollConvention test = RollConvention.ofDayOfWeek(dow);
assertEquals(test.previous(date(2014, AUGUST, 14), P1D), date(2014, AUGUST, 13).with(TemporalAdjusters.previousOrSame(dow)));
}
}
// resolve the values
private DoubleArray resolveValues(IList <SchedulePeriod> periods, RollConvention rollConv)
{
// handle simple case where there are no steps
if (steps.Count == 0 && stepSequence == null)
{
return(DoubleArray.filled(periods.Count, initialValue));
}
return(resolveSteps(periods, rollConv));
}
private Schedule(IList <SchedulePeriod> periods, Frequency frequency, RollConvention rollConvention)
{
JodaBeanUtils.notEmpty(periods, "periods");
JodaBeanUtils.notNull(frequency, "frequency");
JodaBeanUtils.notNull(rollConvention, "rollConvention");
this.periods = ImmutableList.copyOf(periods);
this.frequency = frequency;
this.rollConvention = rollConvention;
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test(dataProvider = "types") public void test_null(RollConvention type)
public virtual void test_null(RollConvention type)
{
assertThrowsIllegalArg(() => type.adjust(null));
assertThrowsIllegalArg(() => type.matches(null));
assertThrowsIllegalArg(() => type.next(date(2014, JULY, 1), null));
assertThrowsIllegalArg(() => type.next(null, P3M));
assertThrowsIllegalArg(() => type.previous(date(2014, JULY, 1), null));
assertThrowsIllegalArg(() => type.previous(null, P3M));
}
//-------------------------------------------------------------------------
public virtual void test_ofDayOfWeek()
{
foreach (DayOfWeek dow in DayOfWeek.values())
{
RollConvention test = RollConvention.ofDayOfWeek(dow);
assertEquals(test.Name, "Day" + CaseFormat.UPPER_UNDERSCORE.converterTo(CaseFormat.UPPER_CAMEL).convert(dow.ToString()).substring(0, 3));
assertEquals(test.ToString(), "Day" + CaseFormat.UPPER_UNDERSCORE.converterTo(CaseFormat.UPPER_CAMEL).convert(dow.ToString()).substring(0, 3));
assertSame(RollConvention.of(test.Name), test);
assertSame(RollConvention.of("DAY" + dow.ToString().Substring(0, 3)), test);
}
}
//-------------------------------------------------------------------------
public virtual void test_ofDayOfMonth()
{
for (int i = 1; i < 30; i++)
{
RollConvention test = RollConvention.ofDayOfMonth(i);
assertEquals(test.adjust(date(2014, JULY, 1)), date(2014, JULY, i));
assertEquals(test.Name, "Day" + i);
assertEquals(test.ToString(), "Day" + i);
assertSame(RollConvention.of(test.Name), test);
assertSame(RollConvention.of("DAY" + i), test);
}
}
public virtual void test_ofDayOfMonth_previous_oneMonth()
{
for (int start = 1; start <= 5; start++)
{
for (int i = 1; i <= 30; i++)
{
RollConvention test = RollConvention.ofDayOfMonth(i);
LocalDate expected = date(2014, JUNE, i);
assertEquals(test.previous(date(2014, JULY, start), P1M), expected);
}
}
}
public virtual void test_ofDayOfMonth_matches_Day30()
{
assertEquals(RollConvention.ofDayOfMonth(30).matches(date(2016, JANUARY, 29)), false);
assertEquals(RollConvention.ofDayOfMonth(30).matches(date(2016, JANUARY, 30)), true);
assertEquals(RollConvention.ofDayOfMonth(30).matches(date(2016, JANUARY, 31)), false);
assertEquals(RollConvention.ofDayOfMonth(30).matches(date(2016, FEBRUARY, 28)), false);
assertEquals(RollConvention.ofDayOfMonth(30).matches(date(2016, FEBRUARY, 29)), true);
assertEquals(RollConvention.ofDayOfMonth(30).matches(date(2015, FEBRUARY, 27)), false);
assertEquals(RollConvention.ofDayOfMonth(30).matches(date(2015, FEBRUARY, 28)), true);
}
private void Generate(BusinessDate startDate, BusinessDate endDate,
int duration, Frequency freq, RollConvention roll, Stub stub)
{
StartDate = startDate;
EndDate = endDate;
Duration = duration;
Frequency = freq;
Roll = roll;
Stub = stub;
Dates = new List <BusinessDate>();
Periods = new List <Period>();
Create();
}
// resolve the steps, broken into a separate method to aid inlining
private DoubleArray resolveSteps(IList <SchedulePeriod> periods, RollConvention rollConv)
{
int size = periods.Count;
double[] result = new double[size];
IList <ValueStep> resolvedSteps = StepSequence.map(seq => seq.resolve(steps, rollConv)).orElse(steps);
// expand ValueStep to array of adjustments matching the periods
// the steps are not sorted, so use fixed size array to absorb incoming data
ValueAdjustment[] expandedSteps = new ValueAdjustment[size];
IList <ValueStep> invalidSteps = new List <ValueStep>();
foreach (ValueStep step in resolvedSteps)
{
int index = step.findIndex(periods);
if (index < 0)
{
invalidSteps.Add(step);
continue;
}
if (expandedSteps[index] != null && !expandedSteps[index].Equals(step.Value))
{
throw new System.ArgumentException(Messages.format("Invalid ValueSchedule, two steps resolved to the same schedule period starting on {}, schedule defined as {}", periods[index].UnadjustedStartDate, this));
}
expandedSteps[index] = step.Value;
}
// apply each adjustment
double value = initialValue;
for (int i = 0; i < size; i++)
{
if (expandedSteps[i] != null)
{
value = expandedSteps[i].adjust(value);
}
result[i] = value;
}
// ensure that invalid steps cause no changes
foreach (ValueStep step in invalidSteps)
{
double baseValue = result[step.findPreviousIndex(periods)];
double adjusted = step.Value.adjust(baseValue);
if (adjusted != baseValue)
{
throw new System.ArgumentException("ValueStep date does not match a period boundary: " + step.Date.get());
}
}
// return result
return(DoubleArray.ofUnsafe(result));
}
public void Create(BusinessDate startDate, BusinessDate endDate,
int duration, Frequency freq,
RollConvention roll = RollConvention.NONE, Stub stub = Stub.NONE)
{
StartDate = startDate;
EndDate = endDate;
Duration = duration;
Frequency = freq;
Roll = roll;
Stub = stub;
Dates = new List <BusinessDate>();
Periods = new List <Period>();
Create();
}
public virtual void test_ofDayOfMonth_previous_oneDay()
{
for (int start = 1; start <= 5; start++)
{
for (int i = 1; i <= 30; i++)
{
RollConvention test = RollConvention.ofDayOfMonth(i);
LocalDate expected = date(2014, JULY, i);
if (i >= start)
{
expected = expected.minusMonths(1);
}
assertEquals(test.previous(date(2014, JULY, start), P1D), expected);
}
}
}
//-------------------------------------------------------------------------
/// <summary>
/// Resolves the sequence to a list of steps.
/// </summary>
/// <param name="existingSteps"> the existing list of steps </param>
/// <param name="rollConv"> the roll convention </param>
/// <returns> the steps </returns>
internal IList <ValueStep> resolve(IList <ValueStep> existingSteps, RollConvention rollConv)
{
ImmutableList.Builder <ValueStep> steps = ImmutableList.builder();
steps.addAll(existingSteps);
LocalDate prev = firstStepDate;
LocalDate date = firstStepDate;
while (!date.isAfter(lastStepDate))
{
steps.add(ValueStep.of(date, adjustment));
prev = date;
date = rollConv.next(date, frequency);
}
if (!prev.Equals(lastStepDate))
{
throw new System.ArgumentException(Messages.format("ValueStepSequence lastStepDate did not match frequency '{}' using roll convention '{}', {} != {}", frequency, rollConv, lastStepDate, prev));
}
return(steps.build());
}
//-------------------------------------------------------------------------
public virtual void test_equals()
{
RollConvention a = RollConventions.EOM;
RollConvention b = RollConventions.DAY_1;
RollConvention c = RollConventions.DAY_WED;
assertEquals(a.Equals(a), true);
assertEquals(a.Equals(b), false);
assertEquals(a.Equals(c), false);
assertEquals(b.Equals(a), false);
assertEquals(b.Equals(b), true);
assertEquals(b.Equals(c), false);
assertEquals(c.Equals(a), false);
assertEquals(c.Equals(b), false);
assertEquals(c.Equals(c), true);
assertEquals(a.GetHashCode(), a.GetHashCode());
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @SuppressWarnings("unchecked") @Override public Builder set(String propertyName, Object newValue)
public override Builder set(string propertyName, object newValue)
{
switch (propertyName.GetHashCode())
{
case -678739246: // periods
this.periods_Renamed = (IList <SchedulePeriod>)newValue;
break;
case -70023844: // frequency
this.frequency_Renamed = (Frequency)newValue;
break;
case -10223666: // rollConvention
this.rollConvention_Renamed = (RollConvention)newValue;
break;
default:
throw new NoSuchElementException("Unknown property: " + propertyName);
}
return(this);
}
public virtual void test_ofDayOfMonth_adjust_Day30()
{
assertEquals(RollConvention.ofDayOfMonth(30).adjust(date(2014, FEBRUARY, 2)), date(2014, FEBRUARY, 28));
assertEquals(RollConvention.ofDayOfMonth(30).adjust(date(2016, FEBRUARY, 2)), date(2016, FEBRUARY, 29));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test(dataProvider = "lenient") public void test_lenientLookup_specialNames(String name, RollConvention convention)
public virtual void test_lenientLookup_specialNames(string name, RollConvention convention)
{
assertEquals(RollConvention.extendedEnum().findLenient(name.ToLower(Locale.ENGLISH)), convention);
}
public virtual void test_of_lookup_null()
{
assertThrowsIllegalArg(() => RollConvention.of(null));
}
public virtual void test_of_lookup_notFound()
{
assertThrowsIllegalArg(() => RollConvention.of("Rubbish"));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test(dataProvider = "name") public void test_extendedEnum(RollConvention convention, String name)
public virtual void test_extendedEnum(RollConvention convention, string name)
{
ImmutableMap <string, RollConvention> map = RollConvention.extendedEnum().lookupAll();
assertEquals(map.get(name), convention);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test(dataProvider = "name") public void test_lenientLookup_standardNames(RollConvention convention, String name)
public virtual void test_lenientLookup_standardNames(RollConvention convention, string name)
{
assertEquals(RollConvention.extendedEnum().findLenient(name.ToLower(Locale.ENGLISH)).get(), convention);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test(dataProvider = "name") public void test_of_lookup(RollConvention convention, String name)
public virtual void test_of_lookup(RollConvention convention, string name)
{
assertEquals(RollConvention.of(name), convention);
}
public Schedule(BusinessDate startDate, BusinessDate endDate,
Frequency freq, RollConvention roll = RollConvention.NONE, Stub stub = Stub.NONE)
{
Create(startDate, endDate, 1, freq, roll, stub);
}
int ISchedule.Create(BusinessDate startDate, BusinessDate endDate,
int duration, Frequency unit, RollConvention roll, Stub stub)
{
Generate(startDate, endDate, duration, unit, roll, stub);
return(Dates.Count);
}
public virtual void test_ofDayOfWeek_matches()
{
assertEquals(RollConvention.ofDayOfWeek(TUESDAY).matches(date(2014, SEPTEMBER, 1)), false);
assertEquals(RollConvention.ofDayOfWeek(TUESDAY).matches(date(2014, SEPTEMBER, 2)), true);
assertEquals(RollConvention.ofDayOfWeek(TUESDAY).matches(date(2014, SEPTEMBER, 3)), false);
}
int ISchedule.Create(BusinessDate startDate, BusinessDate endDate,
Frequency freq, RollConvention roll, Stub stub)
{
Generate(startDate, endDate, 1, freq, roll, stub);
return(Dates.Count);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test(dataProvider = "name") public void test_name(RollConvention convention, String name)
public virtual void test_name(RollConvention convention, string name)
{
assertEquals(convention.Name, name);
}
//-------------------------------------------------------------------------
public override void start(Stage primaryStage)
{
LocalDate today = LocalDate.now(ZoneId.systemDefault());
// setup GUI elements
Label startLbl = new Label("Start date:");
DatePicker startInp = new DatePicker(today);
startLbl.LabelFor = startInp;
startInp.ShowWeekNumbers = false;
Label endLbl = new Label("End date:");
DatePicker endInp = new DatePicker(today.plusYears(1));
endLbl.LabelFor = endInp;
endInp.ShowWeekNumbers = false;
Label freqLbl = new Label("Frequency:");
ChoiceBox <Frequency> freqInp = new ChoiceBox <Frequency>(FXCollections.observableArrayList(Frequency.P1M, Frequency.P2M, Frequency.P3M, Frequency.P4M, Frequency.P6M, Frequency.P12M));
freqLbl.LabelFor = freqInp;
freqInp.Value = Frequency.P3M;
Label stubLbl = new Label("Stub:");
ObservableList <StubConvention> stubOptions = FXCollections.observableArrayList(StubConvention.values());
stubOptions.add(0, null);
ChoiceBox <StubConvention> stubInp = new ChoiceBox <StubConvention>(stubOptions);
stubLbl.LabelFor = stubInp;
stubInp.Value = StubConvention.SMART_INITIAL;
Label rollLbl = new Label("Roll:");
ChoiceBox <RollConvention> rollInp = new ChoiceBox <RollConvention>(FXCollections.observableArrayList(null, RollConventions.NONE, RollConventions.EOM, RollConventions.IMM, RollConventions.IMMAUD, RollConventions.IMMNZD, RollConventions.SFE));
rollLbl.LabelFor = rollInp;
rollInp.Value = RollConventions.NONE;
Label bdcLbl = new Label("Adjust:");
ChoiceBox <BusinessDayConvention> bdcInp = new ChoiceBox <BusinessDayConvention>(FXCollections.observableArrayList(BusinessDayConventions.NO_ADJUST, BusinessDayConventions.FOLLOWING, BusinessDayConventions.MODIFIED_FOLLOWING, BusinessDayConventions.PRECEDING, BusinessDayConventions.MODIFIED_PRECEDING, BusinessDayConventions.MODIFIED_FOLLOWING_BI_MONTHLY, BusinessDayConventions.NEAREST));
bdcLbl.LabelFor = bdcInp;
bdcInp.Value = BusinessDayConventions.MODIFIED_FOLLOWING;
Label holidayLbl = new Label("Holidays:");
ChoiceBox <HolidayCalendarId> holidayInp = new ChoiceBox <HolidayCalendarId>(FXCollections.observableArrayList(HolidayCalendarIds.CHZU, HolidayCalendarIds.GBLO, HolidayCalendarIds.EUTA, HolidayCalendarIds.FRPA, HolidayCalendarIds.JPTO, HolidayCalendarIds.NYFD, HolidayCalendarIds.NYSE, HolidayCalendarIds.USNY, HolidayCalendarIds.USGS, HolidayCalendarIds.NO_HOLIDAYS, HolidayCalendarIds.SAT_SUN));
holidayLbl.LabelFor = holidayInp;
holidayInp.Value = HolidayCalendarIds.GBLO;
TableView <SchedulePeriod> resultGrid = new TableView <SchedulePeriod>();
TableColumn <SchedulePeriod, LocalDate> unadjustedCol = new TableColumn <SchedulePeriod, LocalDate>("Unadjusted dates");
TableColumn <SchedulePeriod, LocalDate> adjustedCol = new TableColumn <SchedulePeriod, LocalDate>("Adjusted dates");
TableColumn <SchedulePeriod, LocalDate> resultUnadjStartCol = new TableColumn <SchedulePeriod, LocalDate>("Start");
resultUnadjStartCol.CellValueFactory = new TableCallback <>(SchedulePeriod.meta().unadjustedStartDate());
TableColumn <SchedulePeriod, LocalDate> resultUnadjEndCol = new TableColumn <SchedulePeriod, LocalDate>("End");
resultUnadjEndCol.CellValueFactory = new TableCallback <>(SchedulePeriod.meta().unadjustedEndDate());
TableColumn <SchedulePeriod, Period> resultUnadjLenCol = new TableColumn <SchedulePeriod, Period>("Length");
resultUnadjLenCol.CellValueFactory = ReadOnlyCallback.of(sch => Period.between(sch.UnadjustedStartDate, sch.UnadjustedEndDate));
TableColumn <SchedulePeriod, LocalDate> resultStartCol = new TableColumn <SchedulePeriod, LocalDate>("Start");
resultStartCol.CellValueFactory = new TableCallback <>(SchedulePeriod.meta().startDate());
TableColumn <SchedulePeriod, LocalDate> resultEndCol = new TableColumn <SchedulePeriod, LocalDate>("End");
resultEndCol.CellValueFactory = new TableCallback <>(SchedulePeriod.meta().endDate());
TableColumn <SchedulePeriod, Period> resultLenCol = new TableColumn <SchedulePeriod, Period>("Length");
resultLenCol.CellValueFactory = ReadOnlyCallback.of(sch => sch.length());
unadjustedCol.Columns.add(resultUnadjStartCol);
unadjustedCol.Columns.add(resultUnadjEndCol);
unadjustedCol.Columns.add(resultUnadjLenCol);
adjustedCol.Columns.add(resultStartCol);
adjustedCol.Columns.add(resultEndCol);
adjustedCol.Columns.add(resultLenCol);
resultGrid.Columns.add(unadjustedCol);
resultGrid.Columns.add(adjustedCol);
resultGrid.Placeholder = new Label("Schedule not yet generated");
unadjustedCol.prefWidthProperty().bind(resultGrid.widthProperty().divide(2));
adjustedCol.prefWidthProperty().bind(resultGrid.widthProperty().divide(2));
resultUnadjStartCol.prefWidthProperty().bind(unadjustedCol.widthProperty().divide(3));
resultUnadjEndCol.prefWidthProperty().bind(unadjustedCol.widthProperty().divide(3));
resultUnadjLenCol.prefWidthProperty().bind(unadjustedCol.widthProperty().divide(3));
resultStartCol.prefWidthProperty().bind(adjustedCol.widthProperty().divide(3));
resultEndCol.prefWidthProperty().bind(adjustedCol.widthProperty().divide(3));
resultLenCol.prefWidthProperty().bind(adjustedCol.widthProperty().divide(3));
// setup generation button
// this uses the GUI thread which is not the best idea
Button btn = new Button();
btn.Text = "Generate";
btn.OnAction = @event =>
{
LocalDate start = startInp.Value;
LocalDate end = endInp.Value;
Frequency freq = freqInp.Value;
StubConvention stub = stubInp.Value;
RollConvention roll = rollInp.Value;
HolidayCalendarId holCal = holidayInp.Value;
BusinessDayConvention bdc = bdcInp.Value;
BusinessDayAdjustment bda = BusinessDayAdjustment.of(bdc, holCal);
PeriodicSchedule defn = PeriodicSchedule.builder().startDate(start).endDate(end).frequency(freq).businessDayAdjustment(bda).stubConvention(stub).rollConvention(roll).build();
try
{
Schedule schedule = defn.createSchedule(REF_DATA);
Console.WriteLine(schedule);
resultGrid.Items = FXCollections.observableArrayList(schedule.Periods);
}
catch (ScheduleException ex)
{
resultGrid.Items = FXCollections.emptyObservableList();
resultGrid.Placeholder = new Label(ex.Message);
Console.WriteLine(ex.Message);
}
};
// layout the components
GridPane gp = new GridPane();
gp.Hgap = 10;
gp.Vgap = 10;
gp.Padding = new Insets(0, 10, 0, 10);
gp.add(startLbl, 1, 1);
gp.add(startInp, 2, 1);
gp.add(endLbl, 1, 2);
gp.add(endInp, 2, 2);
gp.add(freqLbl, 1, 3);
gp.add(freqInp, 2, 3);
gp.add(bdcLbl, 3, 1);
gp.add(bdcInp, 4, 1);
gp.add(holidayLbl, 3, 2);
gp.add(holidayInp, 4, 2);
gp.add(stubLbl, 3, 3);
gp.add(stubInp, 4, 3);
gp.add(rollLbl, 3, 4);
gp.add(rollInp, 4, 4);
gp.add(btn, 3, 5, 2, 1);
gp.add(resultGrid, 1, 7, 4, 1);
BorderPane bp = new BorderPane(gp);
Scene scene = new Scene(bp, 600, 600);
// launch
primaryStage.Title = "Periodic schedule generator";
primaryStage.Scene = scene;
primaryStage.show();
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test(dataProvider = "name") public void test_toString(RollConvention convention, String name)
public virtual void test_toString(RollConvention convention, string name)
{
assertEquals(convention.ToString(), name);
}
