6.6.3 - Alpha2 - 本地化 Material Date Time Picker (版本 4.2.3)
This commit is contained in:
SuperMonster003
@@ -0,0 +1,79 @@
|
||||
package com.wdullaer.materialdatetimepicker.date;
|
||||
|
||||
import org.junit.Assert;
|
||||
import org.junit.Test;
|
||||
|
||||
import java.util.Calendar;
|
||||
import java.util.TimeZone;
|
||||
|
||||
public class DatePickerDialogTest {
|
||||
// isHighlighted
|
||||
@Test
|
||||
public void isHighlightedShouldReturnFalseIfNoHighlightedDaysAreSet() {
|
||||
DatePickerDialog dpd = DatePickerDialog.newInstance((view, year, monthOfYear, dayOfMonth) -> {
|
||||
|
||||
});
|
||||
Assert.assertFalse(dpd.isHighlighted(1990, 1, 1));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isHighlightedShouldReturnFalseIfHighlightedDoesNotContainSelection() {
|
||||
DatePickerDialog dpd = DatePickerDialog.newInstance((view, year, monthOfYear, dayOfMonth) -> {
|
||||
|
||||
});
|
||||
Calendar highlighted = Calendar.getInstance();
|
||||
highlighted.set(Calendar.YEAR, 1990);
|
||||
highlighted.set(Calendar.MONTH, 1);
|
||||
highlighted.set(Calendar.DAY_OF_MONTH, 1);
|
||||
|
||||
Calendar[] highlightedDays = {highlighted};
|
||||
|
||||
dpd.setHighlightedDays(highlightedDays);
|
||||
|
||||
Assert.assertFalse(dpd.isHighlighted(1990, 2, 1));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isHighlightedShouldReturnTrueIfHighlightedDoesContainSelection() {
|
||||
DatePickerDialog dpd = DatePickerDialog.newInstance((view, year, monthOfYear, dayOfMonth) -> {
|
||||
|
||||
});
|
||||
int year = 1990;
|
||||
int month = 1;
|
||||
int day = 1;
|
||||
|
||||
Calendar highlighted = Calendar.getInstance();
|
||||
highlighted.set(Calendar.YEAR, year);
|
||||
highlighted.set(Calendar.MONTH, month);
|
||||
highlighted.set(Calendar.DAY_OF_MONTH, day);
|
||||
|
||||
Calendar[] highlightedDays = {highlighted};
|
||||
|
||||
dpd.setHighlightedDays(highlightedDays);
|
||||
|
||||
Assert.assertTrue(dpd.isHighlighted(year, month, day));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isHighlightedShouldBehaveCorrectlyInCustomTimezones() {
|
||||
String timeZoneString = "Americas/Los_Angeles";
|
||||
Calendar initial = Calendar.getInstance(TimeZone.getTimeZone(timeZoneString));
|
||||
DatePickerDialog dpd = DatePickerDialog.newInstance((view, year, monthOfYear, dayOfMonth) -> {
|
||||
|
||||
}, initial);
|
||||
int year = 1990;
|
||||
int month = 1;
|
||||
int day = 1;
|
||||
|
||||
Calendar highlighted = Calendar.getInstance(TimeZone.getTimeZone(timeZoneString));
|
||||
highlighted.set(Calendar.YEAR, year);
|
||||
highlighted.set(Calendar.MONTH, month);
|
||||
highlighted.set(Calendar.DAY_OF_MONTH, day);
|
||||
|
||||
Calendar[] highlightedDays = {highlighted};
|
||||
|
||||
dpd.setHighlightedDays(highlightedDays);
|
||||
|
||||
Assert.assertTrue(dpd.isHighlighted(year, month, day));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,206 @@
|
||||
package com.wdullaer.materialdatetimepicker.date;
|
||||
|
||||
import com.pholser.junit.quickcheck.Property;
|
||||
import com.pholser.junit.quickcheck.generator.InRange;
|
||||
import com.pholser.junit.quickcheck.runner.JUnitQuickcheck;
|
||||
import com.wdullaer.materialdatetimepicker.Utils;
|
||||
|
||||
import org.junit.Assert;
|
||||
import org.junit.runner.RunWith;
|
||||
|
||||
import java.util.Arrays;
|
||||
import java.util.Calendar;
|
||||
import java.util.Date;
|
||||
import java.util.Locale;
|
||||
import java.util.TimeZone;
|
||||
|
||||
/**
|
||||
* Property based tests for DefaultDateRangeLimiter (quickcheck FTW!)
|
||||
* Created by wdullaer on 26/04/17.
|
||||
*/
|
||||
|
||||
@RunWith(JUnitQuickcheck.class)
|
||||
public class DefaultDateRangeLimiterPropertyTest {
|
||||
final private DatePickerController controller = new DatePickerController() {
|
||||
@Override
|
||||
public void onYearSelected(int year) {}
|
||||
|
||||
@Override
|
||||
public void onDayOfMonthSelected(int year, int month, int day) {}
|
||||
|
||||
@Override
|
||||
public void registerOnDateChangedListener(DatePickerDialog.OnDateChangedListener listener) {}
|
||||
|
||||
@Override
|
||||
public void unregisterOnDateChangedListener(DatePickerDialog.OnDateChangedListener listener) {}
|
||||
|
||||
@Override
|
||||
public MonthAdapter.CalendarDay getSelectedDay() {
|
||||
return new MonthAdapter.CalendarDay(Calendar.getInstance(), TimeZone.getDefault());
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isThemeDark() {
|
||||
return false;
|
||||
}
|
||||
|
||||
@Override
|
||||
public int getAccentColor() {
|
||||
return 0;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isHighlighted(int year, int month, int day) {
|
||||
return false;
|
||||
}
|
||||
|
||||
@Override
|
||||
public int getFirstDayOfWeek() {
|
||||
return 0;
|
||||
}
|
||||
|
||||
@Override
|
||||
public int getMinYear() {
|
||||
return 0;
|
||||
}
|
||||
|
||||
@Override
|
||||
public int getMaxYear() {
|
||||
return 0;
|
||||
}
|
||||
|
||||
@Override
|
||||
public Calendar getStartDate() {
|
||||
return Calendar.getInstance();
|
||||
}
|
||||
|
||||
@Override
|
||||
public Calendar getEndDate() {
|
||||
return Calendar.getInstance();
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isOutOfRange(int year, int month, int day) {
|
||||
return false;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void tryVibrate() {}
|
||||
|
||||
@Override
|
||||
public TimeZone getTimeZone() {
|
||||
return TimeZone.getDefault();
|
||||
}
|
||||
|
||||
@Override
|
||||
public Locale getLocale() {
|
||||
return Locale.getDefault();
|
||||
}
|
||||
|
||||
@Override
|
||||
public DatePickerDialog.Version getVersion() {
|
||||
return DatePickerDialog.Version.VERSION_2;
|
||||
}
|
||||
|
||||
@Override
|
||||
public DatePickerDialog.ScrollOrientation getScrollOrientation() {
|
||||
return DatePickerDialog.ScrollOrientation.HORIZONTAL;
|
||||
}
|
||||
};
|
||||
|
||||
private static Calendar[] datesToCalendars(Date[] dates) {
|
||||
Calendar[] output = new Calendar[dates.length];
|
||||
Calendar day = Calendar.getInstance();
|
||||
for (int i = 0; i < dates.length; i++) {
|
||||
Calendar cal = (Calendar) day.clone();
|
||||
cal.setTime(dates[i]);
|
||||
output[i] = cal;
|
||||
}
|
||||
return output;
|
||||
}
|
||||
|
||||
@Property
|
||||
public void setToNearestShouldBeInSelectableDays(
|
||||
@InRange(min = "01/01/1900", max = "12/31/2099", format = "MM/dd/yyyy") Date date,
|
||||
@InRange(min = "01/01/1900", max = "12/31/2099", format = "MM/dd/yyyy") Date[] dates
|
||||
) {
|
||||
DefaultDateRangeLimiter limiter = new DefaultDateRangeLimiter();
|
||||
|
||||
Calendar day = Calendar.getInstance();
|
||||
day.setTime(date);
|
||||
|
||||
Calendar[] selectables = datesToCalendars(dates);
|
||||
|
||||
limiter.setSelectableDays(selectables);
|
||||
|
||||
// selectableDays are manipulated a bit by the limiter
|
||||
selectables = limiter.getSelectableDays();
|
||||
|
||||
// selectables == null when the input is empty
|
||||
if (selectables == null) Assert.assertEquals(
|
||||
day.getTimeInMillis(),
|
||||
limiter.setToNearestDate(day).getTimeInMillis()
|
||||
);
|
||||
else Assert.assertTrue(Arrays.asList(selectables).contains(limiter.setToNearestDate(day)));
|
||||
}
|
||||
|
||||
@Property
|
||||
public void setToNearestShouldNeverBeInDisabledDays(
|
||||
@InRange(min = "01/01/1900", max = "12/31/2099", format = "MM/dd/yyyy") Date date,
|
||||
@InRange(min = "01/01/1900", max = "12/31/2099", format = "MM/dd/yyyy") Date[] dates
|
||||
) {
|
||||
DefaultDateRangeLimiter limiter = new DefaultDateRangeLimiter();
|
||||
|
||||
Calendar day = Calendar.getInstance();
|
||||
day.setTime(date);
|
||||
|
||||
Calendar[] disableds = datesToCalendars(dates);
|
||||
|
||||
limiter.setDisabledDays(disableds);
|
||||
Assert.assertFalse(Arrays.asList(disableds).contains(limiter.setToNearestDate(day)));
|
||||
}
|
||||
|
||||
@Property
|
||||
public void setToNearestShouldNeverBeBelowMinDate(
|
||||
@InRange(min = "01/01/1900", max = "12/31/2099", format = "MM/dd/yyyy") Date date,
|
||||
@InRange(min = "01/01/1900", max = "12/31/2099", format = "MM/dd/yyyy") Date minDate
|
||||
) {
|
||||
DefaultDateRangeLimiter limiter = new DefaultDateRangeLimiter();
|
||||
|
||||
Calendar day = Calendar.getInstance();
|
||||
day.setTime(date);
|
||||
|
||||
Calendar minDay = Calendar.getInstance();
|
||||
minDay.setTime(minDate);
|
||||
|
||||
limiter.setMinDate(minDay);
|
||||
Assert.assertTrue(Utils.trimToMidnight(minDay).getTimeInMillis() <= limiter.setToNearestDate(day).getTimeInMillis());
|
||||
}
|
||||
|
||||
@Property
|
||||
public void setToNearestShouldNeverBeAboveMaxDate(
|
||||
@InRange(min = "01/01/1800", max = "12/31/2099", format = "MM/dd/yyyy") Date date,
|
||||
@InRange(min = "01/01/1800", max = "12/31/2099", format = "MM/dd/yyyy") Date maxDate
|
||||
) {
|
||||
DefaultDateRangeLimiter limiter = new DefaultDateRangeLimiter();
|
||||
|
||||
Calendar day = Calendar.getInstance();
|
||||
day.setTime(date);
|
||||
|
||||
Calendar minDay = Calendar.getInstance();
|
||||
minDay.set(Calendar.YEAR, 1800);
|
||||
minDay.set(Calendar.MONTH, Calendar.JANUARY);
|
||||
minDay.set(Calendar.DAY_OF_MONTH, 1);
|
||||
Utils.trimToMidnight(minDay);
|
||||
|
||||
Calendar maxDay = Calendar.getInstance();
|
||||
maxDay.setTime(maxDate);
|
||||
|
||||
limiter.setMinDate(minDay);
|
||||
limiter.setMaxDate(maxDay);
|
||||
Assert.assertTrue(Utils.trimToMidnight(maxDay).getTimeInMillis() >= limiter.setToNearestDate(day).getTimeInMillis());
|
||||
}
|
||||
|
||||
// TODO write property based tests that enable all options as one
|
||||
// TODO ensure generators cover more of the known edge cases in the inputs
|
||||
}
|
||||
@@ -0,0 +1,700 @@
|
||||
package com.wdullaer.materialdatetimepicker.date;
|
||||
|
||||
import com.wdullaer.materialdatetimepicker.Utils;
|
||||
|
||||
import org.junit.Test;
|
||||
import org.junit.Assert;
|
||||
|
||||
import java.util.Arrays;
|
||||
import java.util.Calendar;
|
||||
import java.util.Locale;
|
||||
import java.util.TimeZone;
|
||||
|
||||
/**
|
||||
* Unit tests for the default DateRangeLimiter implementation
|
||||
* Primarily used to assert that the rounding logic functions properly
|
||||
*
|
||||
* Created by wdullaer on 14/04/17.
|
||||
*/
|
||||
public class DefaultDateRangeLimiterTest {
|
||||
final private DatePickerController controller = new DatePickerController() {
|
||||
@Override
|
||||
public void onYearSelected(int year) {}
|
||||
|
||||
@Override
|
||||
public void onDayOfMonthSelected(int year, int month, int day) {}
|
||||
|
||||
@Override
|
||||
public void registerOnDateChangedListener(DatePickerDialog.OnDateChangedListener listener) {}
|
||||
|
||||
@Override
|
||||
public void unregisterOnDateChangedListener(DatePickerDialog.OnDateChangedListener listener) {}
|
||||
|
||||
@Override
|
||||
public MonthAdapter.CalendarDay getSelectedDay() {
|
||||
return new MonthAdapter.CalendarDay(Calendar.getInstance(), TimeZone.getDefault());
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isThemeDark() {
|
||||
return false;
|
||||
}
|
||||
|
||||
@Override
|
||||
public int getAccentColor() {
|
||||
return 0;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isHighlighted(int year, int month, int day) {
|
||||
return false;
|
||||
}
|
||||
|
||||
@Override
|
||||
public int getFirstDayOfWeek() {
|
||||
return 0;
|
||||
}
|
||||
|
||||
@Override
|
||||
public int getMinYear() {
|
||||
return 0;
|
||||
}
|
||||
|
||||
@Override
|
||||
public int getMaxYear() {
|
||||
return 0;
|
||||
}
|
||||
|
||||
@Override
|
||||
public Calendar getStartDate() {
|
||||
return Calendar.getInstance();
|
||||
}
|
||||
|
||||
@Override
|
||||
public Calendar getEndDate() {
|
||||
return Calendar.getInstance();
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isOutOfRange(int year, int month, int day) {
|
||||
return false;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void tryVibrate() {}
|
||||
|
||||
@Override
|
||||
public TimeZone getTimeZone() {
|
||||
return TimeZone.getDefault();
|
||||
}
|
||||
|
||||
@Override
|
||||
public Locale getLocale() {
|
||||
return Locale.getDefault();
|
||||
}
|
||||
|
||||
@Override
|
||||
public DatePickerDialog.Version getVersion() {
|
||||
return DatePickerDialog.Version.VERSION_2;
|
||||
}
|
||||
|
||||
@Override
|
||||
public DatePickerDialog.ScrollOrientation getScrollOrientation() {
|
||||
return DatePickerDialog.ScrollOrientation.HORIZONTAL;
|
||||
}
|
||||
};
|
||||
|
||||
// getters
|
||||
@Test
|
||||
public void getSelectableDaysShouldHaveDatesTrimmedToMidnight() {
|
||||
DefaultDateRangeLimiter limiter = new DefaultDateRangeLimiter();
|
||||
Calendar[] days = new Calendar[3];
|
||||
for (int i = 0;i < days.length; i++) {
|
||||
Calendar day = Calendar.getInstance();
|
||||
day.set(Calendar.YEAR, 1999 + i);
|
||||
day.set(Calendar.HOUR_OF_DAY, 2);
|
||||
day.set(Calendar.MINUTE, 10);
|
||||
day.set(Calendar.SECOND, 30);
|
||||
day.set(Calendar.MILLISECOND, 25);
|
||||
days[i] = day;
|
||||
}
|
||||
|
||||
limiter.setSelectableDays(days);
|
||||
Calendar[] selectableDays = limiter.getSelectableDays();
|
||||
|
||||
Assert.assertNotNull(selectableDays);
|
||||
Assert.assertEquals(days.length, selectableDays.length);
|
||||
for (Calendar selectableDay : selectableDays) {
|
||||
Assert.assertEquals(selectableDay.get(Calendar.HOUR_OF_DAY), 0);
|
||||
Assert.assertEquals(selectableDay.get(Calendar.MINUTE), 0);
|
||||
Assert.assertEquals(selectableDay.get(Calendar.SECOND), 0);
|
||||
Assert.assertEquals(selectableDay.get(Calendar.MILLISECOND), 0);
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void getDisabledDaysShouldHaveDatesTrimmedToMidnight() {
|
||||
DefaultDateRangeLimiter limiter = new DefaultDateRangeLimiter();
|
||||
Calendar[] days = new Calendar[3];
|
||||
for (int i = 0;i < days.length; i++) {
|
||||
Calendar day = Calendar.getInstance();
|
||||
day.set(Calendar.YEAR, 1999 + i);
|
||||
day.set(Calendar.HOUR_OF_DAY, 2);
|
||||
day.set(Calendar.MINUTE, 10);
|
||||
day.set(Calendar.SECOND, 30);
|
||||
day.set(Calendar.MILLISECOND, 25);
|
||||
days[i] = day;
|
||||
}
|
||||
|
||||
limiter.setDisabledDays(days);
|
||||
Calendar[] disabledDays = limiter.getDisabledDays();
|
||||
|
||||
Assert.assertNotNull(disabledDays);
|
||||
Assert.assertEquals(days.length, disabledDays.length);
|
||||
for (Calendar selectableDay : disabledDays) {
|
||||
Assert.assertEquals(selectableDay.get(Calendar.HOUR_OF_DAY), 0);
|
||||
Assert.assertEquals(selectableDay.get(Calendar.MINUTE), 0);
|
||||
Assert.assertEquals(selectableDay.get(Calendar.SECOND), 0);
|
||||
Assert.assertEquals(selectableDay.get(Calendar.MILLISECOND), 0);
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void getMinDateShouldHaveDateTrimmedToMidnight() {
|
||||
DefaultDateRangeLimiter limiter = new DefaultDateRangeLimiter();
|
||||
Calendar day = Calendar.getInstance();
|
||||
day.set(Calendar.YEAR, 1999);
|
||||
day.set(Calendar.HOUR_OF_DAY, 2);
|
||||
day.set(Calendar.MINUTE, 10);
|
||||
day.set(Calendar.SECOND, 30);
|
||||
day.set(Calendar.MILLISECOND, 25);
|
||||
|
||||
limiter.setMinDate(day);
|
||||
Calendar minDate = limiter.getMinDate();
|
||||
|
||||
Assert.assertNotNull(minDate);
|
||||
Assert.assertEquals(minDate.get(Calendar.HOUR_OF_DAY), 0);
|
||||
Assert.assertEquals(minDate.get(Calendar.MINUTE), 0);
|
||||
Assert.assertEquals(minDate.get(Calendar.SECOND), 0);
|
||||
Assert.assertEquals(minDate.get(Calendar.MILLISECOND), 0);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void getMaxDateShouldHaveDateTrimmedToMidnight() {
|
||||
DefaultDateRangeLimiter limiter = new DefaultDateRangeLimiter();
|
||||
Calendar day = Calendar.getInstance();
|
||||
day.set(Calendar.YEAR, 1999);
|
||||
day.set(Calendar.HOUR_OF_DAY, 2);
|
||||
day.set(Calendar.MINUTE, 10);
|
||||
day.set(Calendar.SECOND, 30);
|
||||
day.set(Calendar.MILLISECOND, 25);
|
||||
|
||||
limiter.setMaxDate(day);
|
||||
Calendar maxDate = limiter.getMaxDate();
|
||||
|
||||
Assert.assertNotNull(maxDate);
|
||||
Assert.assertEquals(maxDate.get(Calendar.HOUR_OF_DAY), 0);
|
||||
Assert.assertEquals(maxDate.get(Calendar.MINUTE), 0);
|
||||
Assert.assertEquals(maxDate.get(Calendar.SECOND), 0);
|
||||
Assert.assertEquals(maxDate.get(Calendar.MILLISECOND), 0);
|
||||
}
|
||||
|
||||
// getStartDate()
|
||||
@Test
|
||||
public void getStartDateShouldReturnFirstSelectableDay() {
|
||||
DefaultDateRangeLimiter limiter = new DefaultDateRangeLimiter();
|
||||
Calendar[] days = new Calendar[3];
|
||||
for (int i = 0; i < days.length; i++) {
|
||||
days[i] = Calendar.getInstance();
|
||||
days[i].set(Calendar.YEAR, 1999 + i);
|
||||
}
|
||||
|
||||
limiter.setSelectableDays(days);
|
||||
|
||||
// selectableDays are manipulated a bit by the limiter
|
||||
days = limiter.getSelectableDays();
|
||||
|
||||
Assert.assertNotNull(days);
|
||||
Assert.assertEquals(limiter.getStartDate().getTimeInMillis(), days[0].getTimeInMillis());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void getStartDateShouldReturnMinDate() {
|
||||
DefaultDateRangeLimiter limiter = new DefaultDateRangeLimiter();
|
||||
Calendar minDate = Calendar.getInstance();
|
||||
|
||||
limiter.setMinDate(minDate);
|
||||
minDate = Utils.trimToMidnight(minDate);
|
||||
|
||||
Assert.assertEquals(limiter.getStartDate().getTimeInMillis(), minDate.getTimeInMillis());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void getStartDateShouldReturnMinDateWhenAControllerIsSet() {
|
||||
DefaultDateRangeLimiter limiter = new DefaultDateRangeLimiter();
|
||||
limiter.setController(controller);
|
||||
Calendar minDate = Calendar.getInstance();
|
||||
|
||||
limiter.setMinDate(minDate);
|
||||
minDate = Utils.trimToMidnight(minDate);
|
||||
|
||||
Assert.assertEquals(limiter.getStartDate().getTimeInMillis(), minDate.getTimeInMillis());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void getStartDateShouldPreferSelectableOverMinDate() {
|
||||
DefaultDateRangeLimiter limiter = new DefaultDateRangeLimiter();
|
||||
Calendar[] days = new Calendar[3];
|
||||
for (int i = 0; i < days.length; i++) {
|
||||
days[i] = Calendar.getInstance();
|
||||
days[i].set(Calendar.YEAR, 1999 + i);
|
||||
}
|
||||
Calendar minDate = Calendar.getInstance();
|
||||
|
||||
limiter.setSelectableDays(days);
|
||||
limiter.setMinDate(minDate);
|
||||
|
||||
// selectableDays are manipulated a bit by the limiter
|
||||
days = limiter.getSelectableDays();
|
||||
|
||||
Assert.assertNotNull(days);
|
||||
Assert.assertEquals(limiter.getStartDate().getTimeInMillis(), days[0].getTimeInMillis());
|
||||
}
|
||||
|
||||
// getEndDate()
|
||||
@Test
|
||||
public void getEndDateShouldReturnLastSelectableDay() {
|
||||
DefaultDateRangeLimiter limiter = new DefaultDateRangeLimiter();
|
||||
Calendar[] days = new Calendar[3];
|
||||
for (int i = 0; i < days.length; i++) {
|
||||
days[i] = Calendar.getInstance();
|
||||
days[i].set(Calendar.YEAR, 1999 + i);
|
||||
}
|
||||
|
||||
limiter.setSelectableDays(days);
|
||||
|
||||
// selectableDays are manipulated a bit by the limiter
|
||||
days = limiter.getSelectableDays();
|
||||
|
||||
Assert.assertNotNull(days);
|
||||
Assert.assertEquals(limiter.getEndDate().getTimeInMillis(), days[days.length - 1].getTimeInMillis());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void getEndDateShouldReturnMaxDate() {
|
||||
DefaultDateRangeLimiter limiter = new DefaultDateRangeLimiter();
|
||||
Calendar maxDate = Calendar.getInstance();
|
||||
|
||||
limiter.setMaxDate(maxDate);
|
||||
maxDate = Utils.trimToMidnight(maxDate);
|
||||
|
||||
Assert.assertEquals(limiter.getEndDate().getTimeInMillis(), maxDate.getTimeInMillis());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void getEndDateShouldReturnMaxDateWhenAControllerIsSet() {
|
||||
DefaultDateRangeLimiter limiter = new DefaultDateRangeLimiter();
|
||||
limiter.setController(controller);
|
||||
Calendar maxDate = Calendar.getInstance();
|
||||
|
||||
limiter.setMaxDate(maxDate);
|
||||
maxDate = Utils.trimToMidnight(maxDate);
|
||||
|
||||
Assert.assertEquals(limiter.getEndDate().getTimeInMillis(), maxDate.getTimeInMillis());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void getEndDateShouldPreferSelectableOverMaxDate() {
|
||||
DefaultDateRangeLimiter limiter = new DefaultDateRangeLimiter();
|
||||
Calendar[] days = new Calendar[3];
|
||||
for (int i = 0; i < days.length; i++) {
|
||||
days[i] = Calendar.getInstance();
|
||||
days[i].set(Calendar.YEAR, 1999 + i);
|
||||
}
|
||||
Calendar maxDate = Calendar.getInstance();
|
||||
|
||||
limiter.setSelectableDays(days);
|
||||
limiter.setMinDate(maxDate);
|
||||
|
||||
// selectableDays are manipulated a bit by the limiter
|
||||
days = limiter.getSelectableDays();
|
||||
|
||||
Assert.assertNotNull(days);
|
||||
Assert.assertEquals(limiter.getEndDate().getTimeInMillis(), days[days.length - 1].getTimeInMillis());
|
||||
}
|
||||
|
||||
// isOutOfRange()
|
||||
@Test
|
||||
public void isOutOfRangeShouldReturnTrueForDisabledDates() {
|
||||
DefaultDateRangeLimiter limiter = new DefaultDateRangeLimiter();
|
||||
Calendar[] days = new Calendar[1];
|
||||
Calendar day = Calendar.getInstance();
|
||||
day.set(Calendar.YEAR, 1999);
|
||||
days[0] = day;
|
||||
|
||||
limiter.setDisabledDays(days);
|
||||
int year = day.get(Calendar.YEAR);
|
||||
int month = day.get(Calendar.MONTH);
|
||||
int dayNumber = day.get(Calendar.DAY_OF_MONTH);
|
||||
|
||||
Assert.assertTrue(limiter.isOutOfRange(year, month, dayNumber));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isOutOfRangeShouldReturnFalseForEnabledDates() {
|
||||
DefaultDateRangeLimiter limiter = new DefaultDateRangeLimiter();
|
||||
Calendar[] days = new Calendar[1];
|
||||
Calendar day = Calendar.getInstance();
|
||||
day.set(Calendar.YEAR, 1999);
|
||||
days[0] = day;
|
||||
|
||||
limiter.setSelectableDays(days);
|
||||
int year = day.get(Calendar.YEAR);
|
||||
int month = day.get(Calendar.MONTH);
|
||||
int dayNumber = day.get(Calendar.DAY_OF_MONTH);
|
||||
|
||||
Assert.assertFalse(limiter.isOutOfRange(year, month, dayNumber));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isOutOfRangeShouldReturnTrueIfDateIsBeforeMin() {
|
||||
DefaultDateRangeLimiter limiter = new DefaultDateRangeLimiter();
|
||||
Calendar day = Calendar.getInstance();
|
||||
day.set(Calendar.YEAR, 1999);
|
||||
|
||||
limiter.setMinDate(day);
|
||||
day.add(Calendar.DAY_OF_MONTH, -1);
|
||||
int year = day.get(Calendar.YEAR);
|
||||
int month = day.get(Calendar.MONTH);
|
||||
int dayNumber = day.get(Calendar.DAY_OF_MONTH);
|
||||
|
||||
Assert.assertTrue(limiter.isOutOfRange(year, month, dayNumber));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isOutOfRangeShouldReturnTrueIfDateIsBeforeMinYear() {
|
||||
DefaultDateRangeLimiter limiter = new DefaultDateRangeLimiter();
|
||||
int minYear = 1999;
|
||||
|
||||
limiter.setYearRange(minYear, minYear + 1);
|
||||
|
||||
Calendar day = Calendar.getInstance();
|
||||
day.set(Calendar.YEAR, minYear - 1);
|
||||
int year = day.get(Calendar.YEAR);
|
||||
int month = day.get(Calendar.MONTH);
|
||||
int dayNumber = day.get(Calendar.DAY_OF_MONTH);
|
||||
|
||||
Assert.assertTrue(limiter.isOutOfRange(year, month, dayNumber));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isOutOfRangeShouldReturnTrueIfDateIsAfterMax() {
|
||||
DefaultDateRangeLimiter limiter = new DefaultDateRangeLimiter();
|
||||
Calendar day = Calendar.getInstance();
|
||||
day.set(Calendar.YEAR, 1999);
|
||||
|
||||
limiter.setMaxDate(day);
|
||||
day.add(Calendar.DAY_OF_MONTH, 1);
|
||||
int year = day.get(Calendar.YEAR);
|
||||
int month = day.get(Calendar.MONTH);
|
||||
int dayNumber = day.get(Calendar.DAY_OF_MONTH);
|
||||
|
||||
Assert.assertTrue(limiter.isOutOfRange(year, month, dayNumber));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isOutOfRangeShouldReturnTrueIfDateIsAfterMaxYear() {
|
||||
DefaultDateRangeLimiter limiter = new DefaultDateRangeLimiter();
|
||||
int maxYear = 1999;
|
||||
|
||||
limiter.setYearRange(maxYear - 1, maxYear);
|
||||
|
||||
Calendar day = Calendar.getInstance();
|
||||
day.set(Calendar.YEAR, maxYear + 1);
|
||||
int year = day.get(Calendar.YEAR);
|
||||
int month = day.get(Calendar.MONTH);
|
||||
int dayNumber = day.get(Calendar.DAY_OF_MONTH);
|
||||
|
||||
Assert.assertTrue(limiter.isOutOfRange(year, month, dayNumber));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isOutOfRangeShouldPreferDisabledOverEnabled() {
|
||||
DefaultDateRangeLimiter limiter = new DefaultDateRangeLimiter();
|
||||
Calendar[] days = new Calendar[1];
|
||||
Calendar day = Calendar.getInstance();
|
||||
day.set(Calendar.YEAR, 1999);
|
||||
days[0] = day;
|
||||
|
||||
limiter.setSelectableDays(days);
|
||||
limiter.setDisabledDays(days);
|
||||
int year = day.get(Calendar.YEAR);
|
||||
int month = day.get(Calendar.MONTH);
|
||||
int dayNumber = day.get(Calendar.DAY_OF_MONTH);
|
||||
|
||||
Assert.assertTrue(limiter.isOutOfRange(year, month, dayNumber));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isOutOfRangeShouldWorkWithCustomTimeZones() {
|
||||
final String timeZoneString = "America/Los_Angeles";
|
||||
TimeZone timeZone = TimeZone.getTimeZone(timeZoneString);
|
||||
DefaultDateRangeLimiter limiter = new DefaultDateRangeLimiter();
|
||||
|
||||
int year = 1985;
|
||||
int month = 1;
|
||||
int day = 1;
|
||||
Calendar disabledDay = Calendar.getInstance(timeZone);
|
||||
disabledDay.set(Calendar.YEAR, year);
|
||||
disabledDay.set(Calendar.MONTH, month);
|
||||
disabledDay.set(Calendar.DAY_OF_MONTH, day);
|
||||
Calendar[] days = new Calendar[1];
|
||||
days[0] = disabledDay;
|
||||
DatePickerController controller = new DatePickerController() {
|
||||
@Override
|
||||
public void onYearSelected(int year) {}
|
||||
|
||||
@Override
|
||||
public void onDayOfMonthSelected(int year, int month, int day) {}
|
||||
|
||||
@Override
|
||||
public void registerOnDateChangedListener(DatePickerDialog.OnDateChangedListener listener) {}
|
||||
|
||||
@Override
|
||||
public void unregisterOnDateChangedListener(DatePickerDialog.OnDateChangedListener listener) {}
|
||||
|
||||
@Override
|
||||
public MonthAdapter.CalendarDay getSelectedDay() {
|
||||
return null;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isThemeDark() {
|
||||
return false;
|
||||
}
|
||||
|
||||
@Override
|
||||
public int getAccentColor() {
|
||||
return 0;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isHighlighted(int year, int month, int day) {
|
||||
return false;
|
||||
}
|
||||
|
||||
@Override
|
||||
public int getFirstDayOfWeek() {
|
||||
return 0;
|
||||
}
|
||||
|
||||
@Override
|
||||
public int getMinYear() {
|
||||
return 0;
|
||||
}
|
||||
|
||||
@Override
|
||||
public int getMaxYear() {
|
||||
return 0;
|
||||
}
|
||||
|
||||
@Override
|
||||
public Calendar getStartDate() {
|
||||
return null;
|
||||
}
|
||||
|
||||
@Override
|
||||
public Calendar getEndDate() {
|
||||
return null;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isOutOfRange(int year, int month, int day) {
|
||||
return false;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void tryVibrate() {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public TimeZone getTimeZone() {
|
||||
return TimeZone.getTimeZone(timeZoneString);
|
||||
}
|
||||
|
||||
@Override
|
||||
public Locale getLocale() {
|
||||
return Locale.getDefault();
|
||||
}
|
||||
|
||||
@Override
|
||||
public DatePickerDialog.Version getVersion() {
|
||||
return null;
|
||||
}
|
||||
|
||||
@Override
|
||||
public DatePickerDialog.ScrollOrientation getScrollOrientation() {
|
||||
return null;
|
||||
}
|
||||
};
|
||||
|
||||
limiter.setDisabledDays(days);
|
||||
limiter.setController(controller);
|
||||
|
||||
Assert.assertTrue(limiter.isOutOfRange(year, month, day));
|
||||
}
|
||||
|
||||
// setToNearestDate()
|
||||
@Test
|
||||
public void setToNearestShouldReturnTheInputWhenValid() {
|
||||
DefaultDateRangeLimiter limiter = new DefaultDateRangeLimiter();
|
||||
Calendar day = Calendar.getInstance();
|
||||
Calendar expected = (Calendar) day.clone();
|
||||
|
||||
Assert.assertEquals(limiter.setToNearestDate(day).getTimeInMillis(), expected.getTimeInMillis());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void setToNearestShouldRoundDisabledDates() {
|
||||
DefaultDateRangeLimiter limiter = new DefaultDateRangeLimiter();
|
||||
Calendar[] days = new Calendar[3];
|
||||
for (int i = 0;i < days.length; i++) {
|
||||
Calendar day = Calendar.getInstance();
|
||||
day.set(Calendar.YEAR, 1999 + i);
|
||||
day.set(Calendar.HOUR_OF_DAY, 2);
|
||||
day.set(Calendar.MINUTE, 10);
|
||||
day.set(Calendar.SECOND, 30);
|
||||
day.set(Calendar.MILLISECOND, 25);
|
||||
days[i] = day;
|
||||
}
|
||||
|
||||
limiter.setDisabledDays(days);
|
||||
Calendar day = (Calendar) days[0].clone();
|
||||
|
||||
Assert.assertNotSame(limiter.setToNearestDate(day).getTimeInMillis(), days[0].getTimeInMillis());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void setToNearestShouldRoundToMinDate() {
|
||||
DefaultDateRangeLimiter limiter = new DefaultDateRangeLimiter();
|
||||
Calendar minDate = Calendar.getInstance();
|
||||
minDate.set(Calendar.YEAR, 1999);
|
||||
|
||||
limiter.setMinDate(minDate);
|
||||
|
||||
Calendar day = Calendar.getInstance();
|
||||
day.set(Calendar.YEAR, 1998);
|
||||
|
||||
Assert.assertEquals(
|
||||
limiter.setToNearestDate(day).getTimeInMillis(),
|
||||
Utils.trimToMidnight(minDate).getTimeInMillis()
|
||||
);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void setToNearestShouldRoundToMaxDate() {
|
||||
DefaultDateRangeLimiter limiter = new DefaultDateRangeLimiter();
|
||||
Calendar maxDate = Calendar.getInstance();
|
||||
maxDate.set(Calendar.YEAR, 1999);
|
||||
|
||||
limiter.setMaxDate(maxDate);
|
||||
|
||||
Calendar day = Calendar.getInstance();
|
||||
day.set(Calendar.YEAR, 2000);
|
||||
|
||||
Assert.assertEquals(
|
||||
limiter.setToNearestDate(day).getTimeInMillis(),
|
||||
Utils.trimToMidnight(maxDate).getTimeInMillis()
|
||||
);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void setToNearestShouldRoundToASelectableDay() {
|
||||
DefaultDateRangeLimiter limiter = new DefaultDateRangeLimiter();
|
||||
Calendar[] days = new Calendar[3];
|
||||
for (int i = 0;i < days.length; i++) {
|
||||
Calendar day = Calendar.getInstance();
|
||||
day.set(Calendar.YEAR, 1999 + i);
|
||||
day.set(Calendar.HOUR_OF_DAY, 2);
|
||||
day.set(Calendar.MINUTE, 10);
|
||||
day.set(Calendar.SECOND, 30);
|
||||
day.set(Calendar.MILLISECOND, 25);
|
||||
days[i] = day;
|
||||
}
|
||||
|
||||
limiter.setSelectableDays(days);
|
||||
Calendar day = Calendar.getInstance();
|
||||
|
||||
// selectableDays are manipulated a bit by the limiter
|
||||
days = limiter.getSelectableDays();
|
||||
|
||||
Assert.assertNotNull(days);
|
||||
Assert.assertTrue(Arrays.asList(days).contains(limiter.setToNearestDate(day)));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void setToNearestShouldRoundToASelectableDayWhenAControllerIsSet() {
|
||||
DefaultDateRangeLimiter limiter = new DefaultDateRangeLimiter();
|
||||
limiter.setController(controller);
|
||||
Calendar[] days = new Calendar[3];
|
||||
for (int i = 0;i < days.length; i++) {
|
||||
Calendar day = Calendar.getInstance();
|
||||
day.set(Calendar.YEAR, 1999 + i);
|
||||
day.set(Calendar.HOUR_OF_DAY, 2);
|
||||
day.set(Calendar.MINUTE, 10);
|
||||
day.set(Calendar.SECOND, 30);
|
||||
day.set(Calendar.MILLISECOND, 25);
|
||||
days[i] = day;
|
||||
}
|
||||
|
||||
limiter.setSelectableDays(days);
|
||||
Calendar day = Calendar.getInstance();
|
||||
|
||||
// selectableDays are manipulated a bit by the limiter
|
||||
days = limiter.getSelectableDays();
|
||||
|
||||
Assert.assertNotNull(days);
|
||||
Assert.assertTrue(Arrays.asList(days).contains(limiter.setToNearestDate(day)));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void setToNearestShouldRoundToFirstJanOfMinYearWhenBeforeMin() {
|
||||
// Case with just year range and no other restrictions
|
||||
DefaultDateRangeLimiter limiter = new DefaultDateRangeLimiter();
|
||||
|
||||
limiter.setYearRange(1980, 2100);
|
||||
Calendar day = Calendar.getInstance();
|
||||
day.set(Calendar.YEAR, 1970);
|
||||
|
||||
Calendar expectedDay = Calendar.getInstance();
|
||||
expectedDay.set(Calendar.YEAR, 1980);
|
||||
expectedDay.set(Calendar.MONTH, Calendar.JANUARY);
|
||||
expectedDay.set(Calendar.DAY_OF_MONTH, 1);
|
||||
|
||||
Assert.assertEquals(
|
||||
Utils.trimToMidnight(expectedDay).getTimeInMillis(),
|
||||
limiter.setToNearestDate(day).getTimeInMillis()
|
||||
);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void setToNearestShouldReturn31stDecOfMaxYearWhenAfterMax() {
|
||||
// Case with just year range and no other restrictions
|
||||
DefaultDateRangeLimiter limiter = new DefaultDateRangeLimiter();
|
||||
|
||||
limiter.setYearRange(1900, 1950);
|
||||
Calendar day = Calendar.getInstance();
|
||||
day.set(Calendar.YEAR, 1970);
|
||||
|
||||
Calendar expectedDay = Calendar.getInstance();
|
||||
expectedDay.set(Calendar.YEAR, 1950);
|
||||
expectedDay.set(Calendar.MONTH, Calendar.DECEMBER);
|
||||
expectedDay.set(Calendar.DAY_OF_MONTH, 31);
|
||||
|
||||
Assert.assertEquals(
|
||||
Utils.trimToMidnight(expectedDay).getTimeInMillis(),
|
||||
limiter.setToNearestDate(day).getTimeInMillis()
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,853 @@
|
||||
package com.wdullaer.materialdatetimepicker.time;
|
||||
|
||||
import static com.wdullaer.materialdatetimepicker.time.TimePickerDialog.HOUR_INDEX;
|
||||
import static com.wdullaer.materialdatetimepicker.time.TimePickerDialog.MINUTE_INDEX;
|
||||
|
||||
import org.junit.Test;
|
||||
import org.junit.Assert;
|
||||
|
||||
/**
|
||||
* Unit tests for the default implementation of TimepointLimiter
|
||||
* Mostly used to assert that the rounding logic works
|
||||
*
|
||||
* Created by wdullaer on 22/06/17.
|
||||
*/
|
||||
public class DefaultTimepointLimiterTest {
|
||||
@Test
|
||||
public void isAmDisabledShouldReturnTrueWhenMinTimeIsInTheAfternoon() {
|
||||
Timepoint minTime = new Timepoint(13);
|
||||
DefaultTimepointLimiter limiter = new DefaultTimepointLimiter();
|
||||
|
||||
limiter.setMinTime(minTime);
|
||||
|
||||
Assert.assertTrue(limiter.isAmDisabled());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isAmDisabledShouldReturnFalseWhenMinTimeIsInTheMorning() {
|
||||
Timepoint minTime = new Timepoint(8);
|
||||
DefaultTimepointLimiter limiter = new DefaultTimepointLimiter();
|
||||
|
||||
limiter.setMinTime(minTime);
|
||||
|
||||
Assert.assertFalse(limiter.isAmDisabled());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isAmDisabledShouldReturnTrueWhenMinTimeIsMidday() {
|
||||
Timepoint minTime = new Timepoint(12);
|
||||
DefaultTimepointLimiter limiter = new DefaultTimepointLimiter();
|
||||
|
||||
limiter.setMinTime(minTime);
|
||||
|
||||
Assert.assertTrue(limiter.isAmDisabled());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isAmDisabledShouldReturnFalseWhenMaxTimeIsInTheMorning() {
|
||||
Timepoint maxTime = new Timepoint(8);
|
||||
DefaultTimepointLimiter limiter = new DefaultTimepointLimiter();
|
||||
|
||||
limiter.setMaxTime(maxTime);
|
||||
|
||||
Assert.assertFalse(limiter.isAmDisabled());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isAmDisabledShouldReturnFalseWhenMaxTimeIsMidday() {
|
||||
Timepoint maxTime = new Timepoint(12);
|
||||
DefaultTimepointLimiter limiter = new DefaultTimepointLimiter();
|
||||
|
||||
limiter.setMaxTime(maxTime);
|
||||
|
||||
Assert.assertFalse(limiter.isAmDisabled());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isPmDisabledShouldReturnTrueWhenMaxTimeIsInTheMorning() {
|
||||
Timepoint maxTime = new Timepoint(9);
|
||||
DefaultTimepointLimiter limiter = new DefaultTimepointLimiter();
|
||||
|
||||
limiter.setMaxTime(maxTime);
|
||||
|
||||
Assert.assertTrue(limiter.isPmDisabled());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isPmDisabledShouldReturnFalseWhenMinTimeIsInTheAfternoon() {
|
||||
Timepoint minTime = new Timepoint(13);
|
||||
DefaultTimepointLimiter limiter = new DefaultTimepointLimiter();
|
||||
|
||||
limiter.setMinTime(minTime);
|
||||
|
||||
Assert.assertFalse(limiter.isPmDisabled());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isPmDisabledShouldReturnFalseWhenMaxTimeIsMidday() {
|
||||
Timepoint maxTime = new Timepoint(12);
|
||||
DefaultTimepointLimiter limiter = new DefaultTimepointLimiter();
|
||||
|
||||
limiter.setMaxTime(maxTime);
|
||||
|
||||
Assert.assertFalse(limiter.isPmDisabled());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isAmDisabledShouldReturnTrueIfSelectableDaysAreInTheAfternoon() {
|
||||
Timepoint[] selectableDays = {
|
||||
new Timepoint(13),
|
||||
new Timepoint(22)
|
||||
};
|
||||
DefaultTimepointLimiter limiter = new DefaultTimepointLimiter();
|
||||
|
||||
limiter.setSelectableTimes(selectableDays);
|
||||
|
||||
Assert.assertTrue(limiter.isAmDisabled());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isAmDisabledShouldReturnFalseIfSelectableDaysHasOneTimeInTheMorning() {
|
||||
Timepoint[] selectableDays = {
|
||||
new Timepoint(4),
|
||||
new Timepoint(13),
|
||||
new Timepoint(22)
|
||||
};
|
||||
DefaultTimepointLimiter limiter = new DefaultTimepointLimiter();
|
||||
|
||||
limiter.setSelectableTimes(selectableDays);
|
||||
|
||||
Assert.assertFalse(limiter.isAmDisabled());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isPmDisabledShouldReturnTrueIfSelectableDaysAreInTheMorning() {
|
||||
Timepoint[] selectableDays = {
|
||||
new Timepoint(4),
|
||||
new Timepoint(9),
|
||||
new Timepoint(11)
|
||||
};
|
||||
DefaultTimepointLimiter limiter = new DefaultTimepointLimiter();
|
||||
|
||||
limiter.setSelectableTimes(selectableDays);
|
||||
|
||||
Assert.assertTrue(limiter.isPmDisabled());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isPmDisabledShouldReturnFalseIfSelectableDaysHasOneTimeInTheAfternoon() {
|
||||
Timepoint[] selectableDays = {
|
||||
new Timepoint(4),
|
||||
new Timepoint(22)
|
||||
};
|
||||
DefaultTimepointLimiter limiter = new DefaultTimepointLimiter();
|
||||
|
||||
limiter.setSelectableTimes(selectableDays);
|
||||
|
||||
Assert.assertFalse(limiter.isPmDisabled());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isPmDisabledShouldReturnFalseIfSelectableDaysContainsMidday() {
|
||||
Timepoint[] selectableDays = {
|
||||
new Timepoint(4),
|
||||
new Timepoint(9),
|
||||
new Timepoint(12)
|
||||
};
|
||||
DefaultTimepointLimiter limiter = new DefaultTimepointLimiter();
|
||||
|
||||
limiter.setSelectableTimes(selectableDays);
|
||||
|
||||
Assert.assertFalse(limiter.isPmDisabled());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isPmDisabledShouldReturnFalseWithoutConstraints() {
|
||||
DefaultTimepointLimiter limiter = new DefaultTimepointLimiter();
|
||||
|
||||
Assert.assertFalse(limiter.isPmDisabled());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isAmDisabledShouldReturnFalseWithoutConstraints() {
|
||||
DefaultTimepointLimiter limiter = new DefaultTimepointLimiter();
|
||||
|
||||
Assert.assertFalse(limiter.isAmDisabled());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void setMinTimeShouldThrowExceptionWhenBiggerThanMaxTime() {
|
||||
Timepoint maxTime = new Timepoint(2);
|
||||
Timepoint minTime = new Timepoint(3);
|
||||
DefaultTimepointLimiter limiter = new DefaultTimepointLimiter();
|
||||
|
||||
limiter.setMaxTime(maxTime);
|
||||
|
||||
try {
|
||||
limiter.setMinTime(minTime);
|
||||
Assert.fail("setMinTime() should throw IllegalArgumentException");
|
||||
} catch (IllegalArgumentException e) {
|
||||
Assert.assertNotNull(e);
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void setMaxTimeShouldThrowExceptionWhenSmallerThanMinTime() {
|
||||
Timepoint maxTime = new Timepoint(2);
|
||||
Timepoint minTime = new Timepoint(3);
|
||||
DefaultTimepointLimiter limiter = new DefaultTimepointLimiter();
|
||||
|
||||
limiter.setMinTime(minTime);
|
||||
|
||||
try {
|
||||
limiter.setMaxTime(maxTime);
|
||||
Assert.fail("setMaxTime() should throw IllegalArgumentException");
|
||||
} catch (IllegalArgumentException e) {
|
||||
Assert.assertNotNull(e);
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isOutOfRangeShouldReturnTrueIfInputSmallerThanMinTime() {
|
||||
Timepoint minTime = new Timepoint(10);
|
||||
Timepoint input = new Timepoint(2);
|
||||
DefaultTimepointLimiter limiter = new DefaultTimepointLimiter();
|
||||
|
||||
limiter.setMinTime(minTime);
|
||||
|
||||
Assert.assertTrue(limiter.isOutOfRange(input));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isOutOfRangeShouldReturnTrueIfInputLargerThanMaxTime() {
|
||||
Timepoint maxTime = new Timepoint(2);
|
||||
Timepoint input = new Timepoint(12);
|
||||
DefaultTimepointLimiter limiter = new DefaultTimepointLimiter();
|
||||
|
||||
limiter.setMaxTime(maxTime);
|
||||
|
||||
Assert.assertTrue(limiter.isOutOfRange(input));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isOutOfRangeShouldReturnFalseIfInputIsBetweenMinAndMaxTime() {
|
||||
Timepoint minTime = new Timepoint(1);
|
||||
Timepoint maxTime = new Timepoint(13);
|
||||
Timepoint input = new Timepoint(4);
|
||||
DefaultTimepointLimiter limiter = new DefaultTimepointLimiter();
|
||||
|
||||
limiter.setMinTime(minTime);
|
||||
limiter.setMaxTime(maxTime);
|
||||
|
||||
Assert.assertFalse(limiter.isOutOfRange(input));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isOutOfRangeShouldReturnFalseWithoutRestraints() {
|
||||
Timepoint input = new Timepoint(14);
|
||||
DefaultTimepointLimiter limiter = new DefaultTimepointLimiter();
|
||||
|
||||
Assert.assertFalse(limiter.isOutOfRange(input));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isOutOfRangeShouldReturnTrueIfInputNotSelectable() {
|
||||
Timepoint input = new Timepoint(1);
|
||||
Timepoint[] selectableDays = {
|
||||
new Timepoint(13),
|
||||
new Timepoint(14)
|
||||
};
|
||||
DefaultTimepointLimiter limiter = new DefaultTimepointLimiter();
|
||||
|
||||
limiter.setSelectableTimes(selectableDays);
|
||||
|
||||
Assert.assertTrue(limiter.isOutOfRange(input));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isOutOfRangeShouldReturnFalseIfInputSelectable() {
|
||||
Timepoint input = new Timepoint(15);
|
||||
Timepoint[] selectableDays = {
|
||||
new Timepoint(4),
|
||||
new Timepoint(10),
|
||||
new Timepoint(15)
|
||||
};
|
||||
DefaultTimepointLimiter limiter = new DefaultTimepointLimiter();
|
||||
|
||||
limiter.setSelectableTimes(selectableDays);
|
||||
|
||||
Assert.assertFalse(limiter.isOutOfRange(input));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isOutOfRangeWithIndexShouldHandleNull() {
|
||||
DefaultTimepointLimiter limiter = new DefaultTimepointLimiter();
|
||||
|
||||
Assert.assertFalse(limiter.isOutOfRange(null, HOUR_INDEX, Timepoint.TYPE.SECOND));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isOutOfRangeMinuteShouldReturnFalseWhenMinTimeEqualsToTheMinute() {
|
||||
Timepoint minTime = new Timepoint(12, 13, 14);
|
||||
Timepoint input = new Timepoint(12, 13);
|
||||
DefaultTimepointLimiter limiter = new DefaultTimepointLimiter();
|
||||
|
||||
limiter.setMinTime(minTime);
|
||||
|
||||
Assert.assertFalse(limiter.isOutOfRange(input, MINUTE_INDEX, Timepoint.TYPE.SECOND));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isOutOfRangeMinuteShouldReturnFalseWhenMaxTimeEqualsToTheMinute() {
|
||||
Timepoint maxTime = new Timepoint(12, 13, 14);
|
||||
Timepoint input = new Timepoint(12, 13);
|
||||
DefaultTimepointLimiter limiter = new DefaultTimepointLimiter();
|
||||
|
||||
limiter.setMaxTime(maxTime);
|
||||
|
||||
Assert.assertFalse(limiter.isOutOfRange(input, MINUTE_INDEX, Timepoint.TYPE.SECOND));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isOutOfRangeMinuteShouldReturnFalseWhenTimeEqualsSelectableTimeToTheMinute() {
|
||||
Timepoint[] selectableTimes = {
|
||||
new Timepoint(11, 12, 13),
|
||||
new Timepoint(12, 13, 14),
|
||||
new Timepoint(13, 14, 15)
|
||||
};
|
||||
Timepoint input = new Timepoint(12, 13);
|
||||
DefaultTimepointLimiter limiter = new DefaultTimepointLimiter();
|
||||
|
||||
limiter.setSelectableTimes(selectableTimes);
|
||||
|
||||
Assert.assertFalse(limiter.isOutOfRange(input, MINUTE_INDEX, Timepoint.TYPE.SECOND));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isOutOfRangeMinuteShouldReturnFalseWhenTimeEqualsSelectableTimeToTheMinute2() {
|
||||
Timepoint[] selectableTimes = {
|
||||
new Timepoint(11, 12, 13),
|
||||
new Timepoint(12, 13, 14),
|
||||
new Timepoint(13, 14, 15)
|
||||
};
|
||||
Timepoint input = new Timepoint(13, 14, 59);
|
||||
DefaultTimepointLimiter limiter = new DefaultTimepointLimiter();
|
||||
|
||||
limiter.setSelectableTimes(selectableTimes);
|
||||
|
||||
Assert.assertFalse(limiter.isOutOfRange(input, MINUTE_INDEX, Timepoint.TYPE.SECOND));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isOutOfRangeMinuteShouldReturnFalseWhenTimeEqualsSelectableTimeToTheMinute3() {
|
||||
Timepoint[] selectableTimes = {
|
||||
new Timepoint(11, 12, 13),
|
||||
new Timepoint(12, 13, 14),
|
||||
new Timepoint(13, 14, 15)
|
||||
};
|
||||
Timepoint input = new Timepoint(11, 12, 0);
|
||||
DefaultTimepointLimiter limiter = new DefaultTimepointLimiter();
|
||||
|
||||
limiter.setSelectableTimes(selectableTimes);
|
||||
|
||||
Assert.assertFalse(limiter.isOutOfRange(input, MINUTE_INDEX, Timepoint.TYPE.SECOND));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isOutOfRangeMinuteShouldReturnTrueWhenTimeDoesNotEqualSelectableTimeToTheMinute() {
|
||||
Timepoint[] selectableTimes = {
|
||||
new Timepoint(11, 12, 13),
|
||||
new Timepoint(12, 13, 14),
|
||||
new Timepoint(13, 14, 15)
|
||||
};
|
||||
Timepoint input = new Timepoint(11, 11, 0);
|
||||
DefaultTimepointLimiter limiter = new DefaultTimepointLimiter();
|
||||
|
||||
limiter.setSelectableTimes(selectableTimes);
|
||||
|
||||
Assert.assertTrue(limiter.isOutOfRange(input, MINUTE_INDEX, Timepoint.TYPE.SECOND));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isOutOfRangeHourShouldReturnFalseWhenMinTimeEqualsToTheHour() {
|
||||
Timepoint minTime = new Timepoint(12, 13, 14);
|
||||
Timepoint input = new Timepoint(12);
|
||||
DefaultTimepointLimiter limiter = new DefaultTimepointLimiter();
|
||||
|
||||
limiter.setMinTime(minTime);
|
||||
|
||||
Assert.assertFalse(limiter.isOutOfRange(input, HOUR_INDEX, Timepoint.TYPE.SECOND));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isOutOfRangeHourShouldReturnFalseWhenMaxTimeEqualsToTheHour() {
|
||||
Timepoint maxTime = new Timepoint(12, 13, 14);
|
||||
Timepoint input = new Timepoint(12);
|
||||
DefaultTimepointLimiter limiter = new DefaultTimepointLimiter();
|
||||
|
||||
limiter.setMaxTime(maxTime);
|
||||
|
||||
Assert.assertFalse(limiter.isOutOfRange(input, HOUR_INDEX, Timepoint.TYPE.SECOND));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isOutOfRangeHourShouldReturnFalseWhenTimeEqualsSelectableTimeToTheHour() {
|
||||
Timepoint[] selectableTimes = {
|
||||
new Timepoint(11, 12, 13),
|
||||
new Timepoint(12, 13, 14),
|
||||
new Timepoint(13, 14, 15)
|
||||
};
|
||||
Timepoint input = new Timepoint(12);
|
||||
DefaultTimepointLimiter limiter = new DefaultTimepointLimiter();
|
||||
|
||||
limiter.setSelectableTimes(selectableTimes);
|
||||
|
||||
Assert.assertFalse(limiter.isOutOfRange(input, HOUR_INDEX, Timepoint.TYPE.SECOND));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isOutOfRangeHourShouldReturnFalseWhenTimeEqualsSelectableTimeToTheHour2() {
|
||||
Timepoint[] selectableTimes = {
|
||||
new Timepoint(11, 12, 13),
|
||||
new Timepoint(12, 13, 14),
|
||||
new Timepoint(13, 14, 15)
|
||||
};
|
||||
Timepoint input = new Timepoint(13, 15, 15);
|
||||
DefaultTimepointLimiter limiter = new DefaultTimepointLimiter();
|
||||
|
||||
limiter.setSelectableTimes(selectableTimes);
|
||||
|
||||
Assert.assertFalse(limiter.isOutOfRange(input, HOUR_INDEX, Timepoint.TYPE.SECOND));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isOutOfRangeHourShouldReturnFalseWhenTimeEqualsSelectableTimeToTheHour3() {
|
||||
Timepoint[] selectableTimes = {
|
||||
new Timepoint(11, 12, 13),
|
||||
new Timepoint(12, 13, 14),
|
||||
new Timepoint(13, 14, 15)
|
||||
};
|
||||
Timepoint input = new Timepoint(11);
|
||||
DefaultTimepointLimiter limiter = new DefaultTimepointLimiter();
|
||||
|
||||
limiter.setSelectableTimes(selectableTimes);
|
||||
|
||||
Assert.assertFalse(limiter.isOutOfRange(input, HOUR_INDEX, Timepoint.TYPE.SECOND));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isOutOfRangeShouldWorkWhenSelectableTimesContainsDuplicateEntries() {
|
||||
Timepoint[] selectableTimes = {
|
||||
new Timepoint(11),
|
||||
new Timepoint(12),
|
||||
new Timepoint(12),
|
||||
new Timepoint(13)
|
||||
};
|
||||
Timepoint input = new Timepoint(11, 30);
|
||||
DefaultTimepointLimiter limiter = new DefaultTimepointLimiter();
|
||||
|
||||
limiter.setSelectableTimes(selectableTimes);
|
||||
|
||||
Assert.assertTrue(limiter.isOutOfRange(input));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isOutOfRangeShouldReturnTrueWhenInputIsInDisabledTimes() {
|
||||
Timepoint[] disabledTimes = {
|
||||
new Timepoint(11),
|
||||
new Timepoint(12),
|
||||
new Timepoint(13)
|
||||
};
|
||||
Timepoint input = disabledTimes[0];
|
||||
DefaultTimepointLimiter limiter = new DefaultTimepointLimiter();
|
||||
|
||||
limiter.setDisabledTimes(disabledTimes);
|
||||
|
||||
Assert.assertTrue(limiter.isOutOfRange(input));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isOutOfRangeShouldUseDisabledOverSelectable() {
|
||||
Timepoint[] disabledTimes = {
|
||||
new Timepoint(11),
|
||||
new Timepoint(12),
|
||||
new Timepoint(13)
|
||||
};
|
||||
Timepoint[] selectableTimes = {
|
||||
new Timepoint(12),
|
||||
new Timepoint(14)
|
||||
};
|
||||
Timepoint input = new Timepoint(12);
|
||||
DefaultTimepointLimiter limiter = new DefaultTimepointLimiter();
|
||||
|
||||
limiter.setDisabledTimes(disabledTimes);
|
||||
limiter.setSelectableTimes(selectableTimes);
|
||||
|
||||
Assert.assertTrue(limiter.isOutOfRange(input));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isOutOfRangeHourShouldReturnFalseWhenADisabledTimeIsTestedWithSecondResolution() {
|
||||
// If there are only disabledTimes, there will still be other times that are valid
|
||||
Timepoint[] disabledTimes = {
|
||||
new Timepoint(12),
|
||||
new Timepoint(13),
|
||||
new Timepoint(14)
|
||||
};
|
||||
Timepoint input = disabledTimes[0];
|
||||
DefaultTimepointLimiter limiter = new DefaultTimepointLimiter();
|
||||
|
||||
limiter.setDisabledTimes(disabledTimes);
|
||||
|
||||
Assert.assertFalse(limiter.isOutOfRange(input, HOUR_INDEX, Timepoint.TYPE.SECOND));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isOutOfRangeHourShouldReturnFalseWhenADisabledTimeIsTestedWithMinuteResolution() {
|
||||
// If there are only disabledTimes, there will still be other times that are valid
|
||||
Timepoint[] disabledTimes = {
|
||||
new Timepoint(12),
|
||||
new Timepoint(13),
|
||||
new Timepoint(14)
|
||||
};
|
||||
Timepoint input = disabledTimes[0];
|
||||
DefaultTimepointLimiter limiter = new DefaultTimepointLimiter();
|
||||
|
||||
limiter.setDisabledTimes(disabledTimes);
|
||||
|
||||
Assert.assertFalse(limiter.isOutOfRange(input, HOUR_INDEX, Timepoint.TYPE.MINUTE));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isOutOfRangeHourShouldReturnTrueWhenADisabledTimeIsTestedWithHourResolution() {
|
||||
// If there are only disabledTimes, there will still be other times that are valid
|
||||
Timepoint[] disabledTimes = {
|
||||
new Timepoint(12),
|
||||
new Timepoint(13),
|
||||
new Timepoint(14)
|
||||
};
|
||||
Timepoint input = disabledTimes[0];
|
||||
DefaultTimepointLimiter limiter = new DefaultTimepointLimiter();
|
||||
|
||||
limiter.setDisabledTimes(disabledTimes);
|
||||
|
||||
Assert.assertTrue(limiter.isOutOfRange(input, HOUR_INDEX, Timepoint.TYPE.HOUR));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isOutOfRangeMinuteShouldReturnFalseWhenADisabledTimeIsTestedWithSecondResolution() {
|
||||
// If there are only disabledTimes, there will still be other times that are valid
|
||||
Timepoint[] disabledTimes = {
|
||||
new Timepoint(12, 15),
|
||||
new Timepoint(13, 16),
|
||||
new Timepoint(14, 17)
|
||||
};
|
||||
Timepoint input = disabledTimes[0];
|
||||
DefaultTimepointLimiter limiter = new DefaultTimepointLimiter();
|
||||
|
||||
limiter.setDisabledTimes(disabledTimes);
|
||||
|
||||
Assert.assertFalse(limiter.isOutOfRange(input, MINUTE_INDEX, Timepoint.TYPE.SECOND));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isOutOfRangeMinuteShouldReturnFalseWhenADisabledTimeIsTestedWithMinuteResolution() {
|
||||
// If there are only disabledTimes, there will still be other times that are valid
|
||||
Timepoint[] disabledTimes = {
|
||||
new Timepoint(12, 15),
|
||||
new Timepoint(13, 16),
|
||||
new Timepoint(14, 17)
|
||||
};
|
||||
Timepoint input = disabledTimes[0];
|
||||
DefaultTimepointLimiter limiter = new DefaultTimepointLimiter();
|
||||
|
||||
limiter.setDisabledTimes(disabledTimes);
|
||||
|
||||
Assert.assertTrue(limiter.isOutOfRange(input, MINUTE_INDEX, Timepoint.TYPE.MINUTE));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isOutOfRangeHourShouldReturnTrueWhenADisabledTimeCancelsASelectableTime() {
|
||||
Timepoint[] disabledTimes = {
|
||||
new Timepoint(12),
|
||||
new Timepoint(13)
|
||||
};
|
||||
Timepoint[] selectableTimes = {
|
||||
new Timepoint(12),
|
||||
new Timepoint(14),
|
||||
new Timepoint(15)
|
||||
};
|
||||
Timepoint input = new Timepoint(12);
|
||||
DefaultTimepointLimiter limiter = new DefaultTimepointLimiter();
|
||||
|
||||
limiter.setDisabledTimes(disabledTimes);
|
||||
limiter.setSelectableTimes(selectableTimes);
|
||||
|
||||
Assert.assertTrue(limiter.isOutOfRange(input, HOUR_INDEX, Timepoint.TYPE.SECOND));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void roundToNearestShouldWorkWhenSelectableTimesContainsDuplicateEntries() {
|
||||
Timepoint[] selectableTimes = {
|
||||
new Timepoint(11),
|
||||
new Timepoint(12),
|
||||
new Timepoint(12),
|
||||
new Timepoint(13)
|
||||
};
|
||||
Timepoint input = new Timepoint(12, 29);
|
||||
Timepoint expected = new Timepoint(12);
|
||||
DefaultTimepointLimiter limiter = new DefaultTimepointLimiter();
|
||||
|
||||
limiter.setSelectableTimes(selectableTimes);
|
||||
|
||||
Assert.assertEquals(limiter.roundToNearest(input, null, Timepoint.TYPE.SECOND), expected);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void roundToNearestShouldReturnMaxTimeIfBiggerThanMaxTime() {
|
||||
Timepoint maxTime = new Timepoint(8);
|
||||
Timepoint input = new Timepoint(12);
|
||||
DefaultTimepointLimiter limiter = new DefaultTimepointLimiter();
|
||||
|
||||
limiter.setMaxTime(maxTime);
|
||||
|
||||
Assert.assertEquals(limiter.roundToNearest(input, null, Timepoint.TYPE.SECOND), maxTime);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void roundToNearestShouldReturnMinTimeIfSmallerThanMinTime() {
|
||||
Timepoint minTime = new Timepoint(8);
|
||||
Timepoint input = new Timepoint(7);
|
||||
DefaultTimepointLimiter limiter = new DefaultTimepointLimiter();
|
||||
|
||||
limiter.setMinTime(minTime);
|
||||
|
||||
Assert.assertEquals(limiter.roundToNearest(input, null, Timepoint.TYPE.SECOND), minTime);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void roundToNearestShouldReturnInputIfNotOutOfRange() {
|
||||
Timepoint input = new Timepoint(12, 13, 14);
|
||||
DefaultTimepointLimiter limiter = new DefaultTimepointLimiter();
|
||||
|
||||
Assert.assertEquals(limiter.roundToNearest(input, null, Timepoint.TYPE.SECOND), input);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void roundToNearestShouldReturnSelectableTime() {
|
||||
Timepoint[] selectableTimes = {
|
||||
new Timepoint(11, 12, 14),
|
||||
new Timepoint(12, 13, 14),
|
||||
new Timepoint(13, 14, 15)
|
||||
};
|
||||
Timepoint input = new Timepoint(11);
|
||||
DefaultTimepointLimiter limiter = new DefaultTimepointLimiter();
|
||||
|
||||
limiter.setSelectableTimes(selectableTimes);
|
||||
|
||||
Assert.assertEquals(limiter.roundToNearest(input, null, Timepoint.TYPE.SECOND), selectableTimes[0]);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void roundToNearestShouldNotChangeTheMinutesWhenOptionIsSet() {
|
||||
Timepoint[] selectableTimes = {
|
||||
new Timepoint(11, 12, 13),
|
||||
new Timepoint(12),
|
||||
new Timepoint(12, 13, 14),
|
||||
new Timepoint(15, 16, 17)
|
||||
};
|
||||
Timepoint input = new Timepoint(11, 12, 59);
|
||||
DefaultTimepointLimiter limiter = new DefaultTimepointLimiter();
|
||||
|
||||
limiter.setSelectableTimes(selectableTimes);
|
||||
|
||||
Assert.assertEquals(limiter.roundToNearest(input, Timepoint.TYPE.MINUTE, Timepoint.TYPE.SECOND).getHour(), input.getHour());
|
||||
Assert.assertEquals(limiter.roundToNearest(input, Timepoint.TYPE.MINUTE, Timepoint.TYPE.SECOND).getMinute(), input.getMinute());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void roundToNearestShouldNotChangeTheHourWhenOptionIsSet() {
|
||||
Timepoint[] selectableTimes = {
|
||||
new Timepoint(11, 12, 13),
|
||||
new Timepoint(12),
|
||||
new Timepoint(12, 13, 14),
|
||||
new Timepoint(13),
|
||||
new Timepoint(15, 16, 17)
|
||||
};
|
||||
Timepoint input = new Timepoint(12, 59, 59);
|
||||
DefaultTimepointLimiter limiter = new DefaultTimepointLimiter();
|
||||
|
||||
limiter.setSelectableTimes(selectableTimes);
|
||||
|
||||
Assert.assertEquals(limiter.roundToNearest(input, Timepoint.TYPE.HOUR, Timepoint.TYPE.SECOND).getHour(), input.getHour());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void roundToNearestShouldNotChangeTheHourWhenOptionIsSet2() {
|
||||
Timepoint[] selectableTimes = {
|
||||
new Timepoint(11, 12, 13),
|
||||
new Timepoint(12),
|
||||
new Timepoint(12, 13, 14),
|
||||
new Timepoint(13),
|
||||
new Timepoint(15, 16, 17)
|
||||
};
|
||||
Timepoint input = new Timepoint(15, 59, 59);
|
||||
DefaultTimepointLimiter limiter = new DefaultTimepointLimiter();
|
||||
|
||||
limiter.setSelectableTimes(selectableTimes);
|
||||
|
||||
Assert.assertEquals(limiter.roundToNearest(input, Timepoint.TYPE.HOUR, Timepoint.TYPE.SECOND).getHour(), input.getHour());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void roundToNearestShouldNotChangeAnythingWhenSecondOptionIsSet() {
|
||||
Timepoint[] selectableTimes = {
|
||||
new Timepoint(11, 12, 13),
|
||||
new Timepoint(12),
|
||||
new Timepoint(12, 13, 14),
|
||||
new Timepoint(13),
|
||||
new Timepoint(15, 16, 17)
|
||||
};
|
||||
Timepoint input = new Timepoint(12, 59, 59);
|
||||
DefaultTimepointLimiter limiter = new DefaultTimepointLimiter();
|
||||
|
||||
limiter.setSelectableTimes(selectableTimes);
|
||||
|
||||
Assert.assertEquals(limiter.roundToNearest(input, Timepoint.TYPE.SECOND, Timepoint.TYPE.SECOND), input);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void roundToNearestShouldRoundToNearest() {
|
||||
Timepoint[] selectableTimes = {
|
||||
new Timepoint(11, 12, 13),
|
||||
new Timepoint(11, 12, 16),
|
||||
new Timepoint(12)
|
||||
};
|
||||
Timepoint input = new Timepoint(11, 12, 14);
|
||||
DefaultTimepointLimiter limiter = new DefaultTimepointLimiter();
|
||||
|
||||
limiter.setSelectableTimes(selectableTimes);
|
||||
|
||||
Assert.assertEquals(limiter.roundToNearest(input, null, Timepoint.TYPE.SECOND), selectableTimes[0]);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void roundToNearestShouldRoundToNearestSelectableThatIsNotDisabled() {
|
||||
Timepoint[] selectableTimes = {
|
||||
new Timepoint(11, 12, 13),
|
||||
new Timepoint(12, 13, 14),
|
||||
new Timepoint(13)
|
||||
};
|
||||
Timepoint[] disabledTimes = {
|
||||
new Timepoint(12, 13, 14)
|
||||
};
|
||||
Timepoint input = new Timepoint(12, 13, 15);
|
||||
DefaultTimepointLimiter limiter = new DefaultTimepointLimiter();
|
||||
|
||||
limiter.setSelectableTimes(selectableTimes);
|
||||
limiter.setDisabledTimes(disabledTimes);
|
||||
|
||||
Assert.assertEquals(limiter.roundToNearest(input, null, Timepoint.TYPE.SECOND), selectableTimes[2]);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void roundToNearestShouldRoundWithSecondIncrementsIfInputIsDisabled() {
|
||||
Timepoint[] disabledTimes = {
|
||||
new Timepoint(11, 12, 13),
|
||||
new Timepoint(12, 13, 14),
|
||||
new Timepoint(13, 14, 15)
|
||||
};
|
||||
Timepoint input = disabledTimes[0];
|
||||
DefaultTimepointLimiter limiter = new DefaultTimepointLimiter();
|
||||
Timepoint expected = new Timepoint(11, 12, 14);
|
||||
|
||||
limiter.setDisabledTimes(disabledTimes);
|
||||
|
||||
Assert.assertEquals(limiter.roundToNearest(input, null, Timepoint.TYPE.SECOND), expected);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void roundToNearestShouldRoundWithSecondIncrementsIfInputIsDisabled2() {
|
||||
Timepoint[] disabledTimes = {
|
||||
new Timepoint(11, 12, 13),
|
||||
new Timepoint(11, 12, 14),
|
||||
new Timepoint(12, 13, 14),
|
||||
new Timepoint(13, 14, 15)
|
||||
};
|
||||
Timepoint input = disabledTimes[0];
|
||||
DefaultTimepointLimiter limiter = new DefaultTimepointLimiter();
|
||||
Timepoint expected = new Timepoint(11, 12, 12);
|
||||
|
||||
limiter.setDisabledTimes(disabledTimes);
|
||||
|
||||
Assert.assertEquals(limiter.roundToNearest(input, null, Timepoint.TYPE.SECOND), expected);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void roundToNearestShouldRoundWithSecondIncrementsIfInputIsDisabled3() {
|
||||
Timepoint[] disabledTimes = {
|
||||
new Timepoint(11, 12, 13),
|
||||
new Timepoint(11, 12, 12),
|
||||
new Timepoint(11, 12, 14),
|
||||
new Timepoint(12, 13, 14),
|
||||
new Timepoint(13, 14, 15)
|
||||
};
|
||||
Timepoint input = disabledTimes[0];
|
||||
DefaultTimepointLimiter limiter = new DefaultTimepointLimiter();
|
||||
Timepoint expected = new Timepoint(11, 12, 15);
|
||||
|
||||
limiter.setDisabledTimes(disabledTimes);
|
||||
|
||||
Assert.assertEquals(limiter.roundToNearest(input, null, Timepoint.TYPE.SECOND), expected);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void roundToNearestShouldRoundWithMinuteIncrementsIfInputIsDisabled() {
|
||||
Timepoint[] disabledTimes = {
|
||||
new Timepoint(11, 12, 13),
|
||||
new Timepoint(12, 13, 14),
|
||||
new Timepoint(13, 14, 15)
|
||||
};
|
||||
Timepoint input = disabledTimes[0];
|
||||
DefaultTimepointLimiter limiter = new DefaultTimepointLimiter();
|
||||
Timepoint expected = new Timepoint(11, 13, 13);
|
||||
|
||||
limiter.setDisabledTimes(disabledTimes);
|
||||
|
||||
Assert.assertEquals(limiter.roundToNearest(input, null, Timepoint.TYPE.MINUTE), expected);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void roundToNearestShouldRoundWithHourIncrementsIfInputIsDisabled() {
|
||||
Timepoint[] disabledTimes = {
|
||||
new Timepoint(11, 12, 13),
|
||||
new Timepoint(12, 13, 14),
|
||||
new Timepoint(13, 14, 15)
|
||||
};
|
||||
Timepoint input = disabledTimes[0];
|
||||
DefaultTimepointLimiter limiter = new DefaultTimepointLimiter();
|
||||
Timepoint expected = new Timepoint(10, 12, 13);
|
||||
|
||||
limiter.setDisabledTimes(disabledTimes);
|
||||
|
||||
Assert.assertEquals(limiter.roundToNearest(input, null, Timepoint.TYPE.HOUR), expected);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void roundToNearestIfInputDisablesAtLowerAndUpperTime() {
|
||||
Timepoint[] disabledTimes = new Timepoint[180];
|
||||
for(int l=0; l<=59; l++){ disabledTimes[l] = new Timepoint(0, l); }
|
||||
for(int l=0; l<=59; l++){ disabledTimes[60+l] = new Timepoint(1, l); }
|
||||
for(int l=0; l<=59; l++){ disabledTimes[120+l] = new Timepoint(23, l); }
|
||||
|
||||
Timepoint input = new Timepoint(0, 29, 0);
|
||||
DefaultTimepointLimiter limiter = new DefaultTimepointLimiter();
|
||||
Timepoint expected = new Timepoint(2, 0, 0);
|
||||
Timepoint expected2 = new Timepoint(2, 29, 0);
|
||||
|
||||
limiter.setDisabledTimes(disabledTimes);
|
||||
|
||||
Assert.assertEquals(limiter.roundToNearest(input, null, Timepoint.TYPE.MINUTE), expected);
|
||||
Assert.assertEquals(limiter.roundToNearest(input, null, Timepoint.TYPE.HOUR), expected2);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,28 @@
|
||||
package com.wdullaer.materialdatetimepicker.time;
|
||||
|
||||
import org.junit.Assert;
|
||||
import org.junit.Test;
|
||||
|
||||
public class TimePickerDialogTest {
|
||||
@Test
|
||||
public void getPickerResolutionShouldReturnSecondIfSecondsAreEnabled() {
|
||||
TimePickerDialog tpd = TimePickerDialog.newInstance(null, false);
|
||||
tpd.enableSeconds(true);
|
||||
Assert.assertEquals(tpd.getPickerResolution(), Timepoint.TYPE.SECOND);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void getPickerResolutionShouldReturnMinuteIfMinutesAreEnabled() {
|
||||
TimePickerDialog tpd = TimePickerDialog.newInstance(null, false);
|
||||
tpd.enableSeconds(false);
|
||||
tpd.enableMinutes(true);
|
||||
Assert.assertEquals(tpd.getPickerResolution(), Timepoint.TYPE.MINUTE);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void getPickerResolutionShouldReturnHourIfMinutesAndSecondsAreDisabled() {
|
||||
TimePickerDialog tpd = TimePickerDialog.newInstance(null, false);
|
||||
tpd.enableMinutes(false);
|
||||
Assert.assertEquals(tpd.getPickerResolution(), Timepoint.TYPE.HOUR);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,233 @@
|
||||
package com.wdullaer.materialdatetimepicker.time;
|
||||
|
||||
import org.junit.Test;
|
||||
import org.junit.Assert;
|
||||
|
||||
import java.util.HashSet;
|
||||
|
||||
public class TimepointTest {
|
||||
|
||||
@Test
|
||||
public void timepointsWithSameFieldsShouldHaveSameHashCode() {
|
||||
Timepoint first = new Timepoint(12, 0, 0);
|
||||
Timepoint second = new Timepoint(12, 0, 0);
|
||||
Assert.assertEquals(first.hashCode(), second.hashCode());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void timepointsWithSameFieldsShouldBeEquals() {
|
||||
Timepoint first = new Timepoint(12, 0, 0);
|
||||
Timepoint second = new Timepoint(12, 0, 0);
|
||||
Assert.assertEquals(first, second);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void timepointsWithSameFieldsShouldBeDistinctInHashSet() {
|
||||
HashSet<Timepoint> timepoints = new HashSet<>(4);
|
||||
timepoints.add(new Timepoint(12, 0, 0));
|
||||
timepoints.add(new Timepoint(12, 0, 0));
|
||||
timepoints.add(new Timepoint(12, 0, 0));
|
||||
timepoints.add(new Timepoint(12, 0, 0));
|
||||
Assert.assertEquals(timepoints.size(), 1);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void timepointsWithDifferentFieldsShouldNotBeDistinctInHashSet() {
|
||||
HashSet<Timepoint> timepoints = new HashSet<>(4);
|
||||
timepoints.add(new Timepoint(12, 1, 0));
|
||||
timepoints.add(new Timepoint(12, 2, 0));
|
||||
timepoints.add(new Timepoint(12, 3, 0));
|
||||
timepoints.add(new Timepoint(12, 4, 0));
|
||||
Assert.assertEquals(timepoints.size(), 4);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void compareToShouldReturnNegativeIfArgumentIsBigger() {
|
||||
Timepoint orig = new Timepoint(12, 11, 10);
|
||||
Timepoint arg = new Timepoint(13, 14, 15);
|
||||
Assert.assertTrue(orig.compareTo(arg) < 0);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void compareToShouldReturnPositiveIfArgumentIsSmaller() {
|
||||
Timepoint orig = new Timepoint(12, 11, 10);
|
||||
Timepoint arg = new Timepoint(10, 14, 15);
|
||||
Assert.assertTrue(orig.compareTo(arg) > 0);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void compareToShouldReturnZeroIfArgumentIsEqual() {
|
||||
Timepoint orig = new Timepoint(12, 11, 10);
|
||||
Timepoint arg = new Timepoint(12, 11, 10);
|
||||
Assert.assertEquals(0, orig.compareTo(arg));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isAMShouldReturnTrueIfTimepointIsBeforeMidday() {
|
||||
Timepoint timepoint = new Timepoint(11);
|
||||
Assert.assertTrue(timepoint.isAM());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isAMShouldReturnFalseIfTimepointIsMidday() {
|
||||
Timepoint timepoint = new Timepoint(12);
|
||||
Assert.assertFalse(timepoint.isAM());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isAMShouldReturnFalseIfTimepointIsAfterMidday() {
|
||||
Timepoint timepoint = new Timepoint(13);
|
||||
Assert.assertFalse(timepoint.isAM());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isAMShouldReturnTrueIfTimepointIsMidnight() {
|
||||
Timepoint timepoint = new Timepoint(0);
|
||||
Assert.assertTrue(timepoint.isAM());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isPMShouldReturnFalseIfTimepointIsBeforeMidday() {
|
||||
Timepoint timepoint = new Timepoint(11);
|
||||
Assert.assertFalse(timepoint.isPM());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isPMShouldReturnTrueIfTimepointIsMidday() {
|
||||
Timepoint timepoint = new Timepoint(12);
|
||||
Assert.assertTrue(timepoint.isPM());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isPMShouldReturnTrueIfTimepointIsAfterMidday() {
|
||||
Timepoint timepoint = new Timepoint(13);
|
||||
Assert.assertTrue(timepoint.isPM());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isPMShouldReturnFalseIfTimepointIsMidnight() {
|
||||
Timepoint timepoint = new Timepoint(0);
|
||||
Assert.assertFalse(timepoint.isPM());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void setAMShouldDoNothingIfTimepointIsBeforeMidday() {
|
||||
Timepoint timepoint = new Timepoint(11);
|
||||
timepoint.setAM();
|
||||
Assert.assertEquals(timepoint.getHour(), 11);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void setAMShouldSetToMidnightIfTimepointIsMidday() {
|
||||
Timepoint timepoint = new Timepoint(12);
|
||||
timepoint.setAM();
|
||||
Assert.assertEquals(timepoint.getHour(), 0);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void setAMShouldSetBeforeMiddayIfTimepointIsAfterMidday() {
|
||||
Timepoint timepoint = new Timepoint(13);
|
||||
timepoint.setAM();
|
||||
Assert.assertEquals(timepoint.getHour(), 1);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void setAMShouldDoNothingIfTimepointIsMidnight() {
|
||||
Timepoint timepoint = new Timepoint(0);
|
||||
timepoint.setAM();
|
||||
Assert.assertEquals(timepoint.getHour(), 0);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void setAMShouldNotChangeMinutesOrSeconds() {
|
||||
Timepoint timepoint = new Timepoint(13, 14, 15);
|
||||
timepoint.setAM();
|
||||
Assert.assertEquals(timepoint.getMinute(), 14);
|
||||
Assert.assertEquals(timepoint.getSecond(), 15);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void setPMShouldDoNothingIfTimepointIsAfterMidday() {
|
||||
Timepoint timepoint = new Timepoint(13);
|
||||
timepoint.setPM();
|
||||
Assert.assertEquals(timepoint.getHour(), 13);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void setPMShouldSetToMiddayIfTimepointIsMidnight() {
|
||||
Timepoint timepoint = new Timepoint(0);
|
||||
timepoint.setPM();
|
||||
Assert.assertEquals(timepoint.getHour(), 12);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void setPMShouldSetAfterMiddayIfTimepointIsBeforeMidday() {
|
||||
Timepoint timepoint = new Timepoint(5);
|
||||
timepoint.setPM();
|
||||
Assert.assertEquals(timepoint.getHour(), 17);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void setPMShouldDoNothingIfTimepointIsMidday() {
|
||||
Timepoint timepoint = new Timepoint(12);
|
||||
timepoint.setPM();
|
||||
Assert.assertEquals(timepoint.getHour(), 12);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void setPMShouldNotChangeMinutesOrSeconds() {
|
||||
Timepoint timepoint = new Timepoint(1, 14, 15);
|
||||
timepoint.setPM();
|
||||
Assert.assertEquals(timepoint.getMinute(), 14);
|
||||
Assert.assertEquals(timepoint.getSecond(), 15);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void equalsShouldReturnTrueWhenInputsAreEqualWithSecondsResolution() {
|
||||
Timepoint timepoint1 = new Timepoint(1, 14, 15);
|
||||
Timepoint timepoint2 = new Timepoint(1, 14, 15);
|
||||
Assert.assertTrue(timepoint1.equals(timepoint2, Timepoint.TYPE.SECOND));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void equalsShouldReturnFalseWhenInputsDifferWithSecondsResolution() {
|
||||
Timepoint timepoint1 = new Timepoint(1, 14, 15);
|
||||
Timepoint timepoint2 = new Timepoint(1, 14, 16);
|
||||
Assert.assertFalse(timepoint1.equals(timepoint2, Timepoint.TYPE.SECOND));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void equalsShouldIgnoreSecondsWithMinuteResolution() {
|
||||
Timepoint timepoint1 = new Timepoint(1, 14, 15);
|
||||
Timepoint timepoint2 = new Timepoint(1, 14, 16);
|
||||
Assert.assertTrue(timepoint1.equals(timepoint2, Timepoint.TYPE.MINUTE));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void equalsShouldReturnFalseWhenInputsDifferWithMinuteResolution() {
|
||||
Timepoint timepoint1 = new Timepoint(1, 14, 15);
|
||||
Timepoint timepoint2 = new Timepoint(1, 15, 15);
|
||||
Assert.assertFalse(timepoint1.equals(timepoint2, Timepoint.TYPE.MINUTE));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void equalsShouldIgnoreSecondsWithHourResolution() {
|
||||
Timepoint timepoint1 = new Timepoint(1, 14, 15);
|
||||
Timepoint timepoint2 = new Timepoint(1, 14, 16);
|
||||
Assert.assertTrue(timepoint1.equals(timepoint2, Timepoint.TYPE.HOUR));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void equalsShouldIgnoreMinutesWithHourResolution() {
|
||||
Timepoint timepoint1 = new Timepoint(1, 14, 15);
|
||||
Timepoint timepoint2 = new Timepoint(1, 15, 16);
|
||||
Assert.assertTrue(timepoint1.equals(timepoint2, Timepoint.TYPE.HOUR));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void equalsShouldReturnFalseWhenInputsDifferWithHourResolution() {
|
||||
Timepoint timepoint1 = new Timepoint(1, 14, 15);
|
||||
Timepoint timepoint2 = new Timepoint(2, 14, 15);
|
||||
Assert.assertFalse(timepoint1.equals(timepoint2, Timepoint.TYPE.HOUR));
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user