rife2/rife2
rife2/rife2
2
0
Fork 0
mirror of https://github.com/ethauvin/rife2.git synced 2025-05-01 11:08:11 -07:00
Code Activity

Scheduler javadocs

Browse source
This commit is contained in:
Geert Bevin 2023-01-21 12:01:09 -05:00
parent 6ae39a05d4
commit db116e2723
14 changed files with 827 additions and 343 deletions
Download patch file Download diff file Expand all files Collapse all files

3
lib/src/main/java/rife/scheduler/Frequency.java
View file

@ -6,7 +6,6 @@ package rife.scheduler;
import rife.config.RifeConfig;
import rife.scheduler.exceptions.FrequencyException;
import rife.tools.Localization;
import rife.tools.StringUtils;
import java.time.DayOfWeek;
@ -522,7 +521,7 @@ public class Frequency {
weekdays_ = Arrays.copyOf(ALL_WEEKDAYS, ALL_WEEKDAYS.length);
}
long getNextDate(long start)
long getNextTimestamp(long start)
throws FrequencyException {
if (start < 0) throw new IllegalArgumentException("start should be positive");

272
lib/src/main/java/rife/scheduler/Task.java
View file

@ -7,12 +7,20 @@ package rife.scheduler;
import rife.config.RifeConfig;
import rife.scheduler.exceptions.FrequencyException;
import rife.scheduler.exceptions.SchedulerException;
import rife.tools.Localization;
import rife.validation.*;
import java.util.Calendar;
import java.util.Date;
/**
* A task contains all the information for the scheduler to plan its execution.
* <p>
* For a task to be valid, it needs to have a type and either the one-shat planned execution
* needs to be specified, or the repeating frequency.
*
* @author Geert Bevin (gbevin[remove] at uwyn dot com)
* @since 1.0
*/
public class Task extends MetaData implements Cloneable {
private int id_ = -1;
private String type_ = null;
@ -22,6 +30,11 @@ public class Task extends MetaData implements Cloneable {
private TaskManager taskManager_ = null;
/**
* Create a new task.
*
* @since 1.0
*/
public Task() {
}
@ -31,14 +44,43 @@ public class Task extends MetaData implements Cloneable {
addRule(new InvalidPlanned());
}
/**
* Sets this task's task manager.
* <p>
* This is not intended to be used by the user and will be set by RIFE2
* when processing tasks.
*
* @param taskManager the task manager to set
* @since 1.0
*/
public void setTaskManager(TaskManager taskManager) {
taskManager_ = taskManager;
}
/**
* Retrieve this task's task manager.
*
* @return this task's task manager; or
* {@code null} if no task manager has been assigned to this task
* @since 1.0
*/
public TaskManager getTaskManager() {
return taskManager_;
}
/**
* Retrieve the value of a named task option for this task.
* <p>
* This method relies on RIFE2 having set the task manager first,
* without that, the option value will always be {@code null}.
*
* @param name the name of the task option to retrieve
* @return the value for the named option; or {@code null} if the option
* wasn't available or couldn't be found
* @throws SchedulerException when an error occurs during the retrieval
* of the task option
* @since 1.0
*/
public String getTaskOptionValue(String name)
throws SchedulerException {
if (null == name) throw new IllegalArgumentException("name can't be null.");
@ -66,7 +108,16 @@ public class Task extends MetaData implements Cloneable {
return taskoption.getValue();
}
public long getNextDate()
/**
* Calculate the next timestamp in milliseconds since epoch at which this
* task should execute.
*
* @return the next execution timestamp; or
* {@code -1} if there's no next scheduled time
* @throws FrequencyException when an error occurred during the timestamp calculation
* @since 1.0
*/
public long getNextTimestamp()
throws FrequencyException {
// lower towards the minute, remove seconds and milliseconds
var current_calendar = RifeConfig.tools().getCalendarInstance();
@ -74,46 +125,91 @@ public class Task extends MetaData implements Cloneable {
current_calendar.set(Calendar.MILLISECOND, 0);
var current_time = current_calendar.getTimeInMillis();
if (planned_ <= current_time) {
return getNextDate(current_time);
return getNextTimestamp(current_time);
}
return -1;
}
public long getNextDate(long start)
/**
* Calculate the next timestamp in milliseconds since epoch at which this
* task should execute, starting from a provided timestamp.
*
* @param start the starting timestamp in milliseconds since epoch to look
* for the next execution timestamp
* @return the next execution timestamp; or
* {@code -1} if there's no next scheduled time
* @throws FrequencyException when an error occurred during the timestamp calculation
* @since 1.0
*/
public long getNextTimestamp(long start)
throws FrequencyException {
if (null == frequency_) {
return -1;
} else {
return frequency_.getNextDate(start);
return frequency_.getNextTimestamp(start);
}
}
public void setId(int id) {
id_ = id;
}
public int getId() {
return id_;
}
/**
* Sets the type of the task, which will be used to execute
* this task with the {@link Executor} that handles the same task type.
*
* @param type this task's type
* @since 1.0
*/
public void setType(String type) {
type_ = type;
}
/**
* Sets the type of the task, which will be used to execute
* this task with the {@link Executor} that handles the same task type.
*
* @param type this task's type
* @return this task instance
* @since 1.0
*/
public Task type(String type) {
setType(type);
return this;
}
/**
* Retrieves the type of this task
*
* @return this task's type; or
* {@code null} if no type was set
*/
public String getType() {
return type_;
}
/**
* Sets the planned timestamp at which this task should execute next.
* <p>
* This can be set manually for one-shot task execution, or when providing
* a frequency, RIFE2 will automatically set the planned timestamp based
* on the frequency specification.
*
* @param planned the date instance for one-shot task execution
* @since 1.0
*/
public void setPlanned(Date planned) {
setPlanned(planned.getTime());
}
/**
* Sets the planned timestamp at which this task should execute next.
* <p>
* This can be set manually for one-shot task execution, or when providing
* a frequency, RIFE2 will automatically set the planned timestamp based
* on the frequency specification.
*
* @param planned the timestamp in milliseconds since epoch for one-shot
* task execution
* @since 1.0
*/
public void setPlanned(long planned) {
// lower towards the minute, remove seconds and milliseconds
var planned_calendar = RifeConfig.tools().getCalendarInstance();
@ -124,42 +220,88 @@ public class Task extends MetaData implements Cloneable {
planned_ = planned_calendar.getTimeInMillis();
}
/**
* Sets the planned timestamp at which this task should execute next.
* <p>
* This can be set manually for one-shot task execution, or when providing
* a frequency, RIFE2 will automatically set the planned timestamp based
* on the frequency specification.
*
* @param planned the date instance for one-shot task execution
* @return this task instance
* @since 1.0
*/
public Task planned(Date planned) {
setPlanned(planned);
return this;
}
/**
* Sets the planned timestamp at which this task should execute next.
*
* @param planned the timestamp in milliseconds since epoch for one-shot
* task execution
* @return this task instance
* @since 1.0
*/
public Task planned(long planned) {
setPlanned(planned);
return this;
}
/**
* Retrieve the timestamp at which this task is scheduled for the next
* execution.
*
* @return the next execution timestamp in milliseconds since epoch
* @since 1.0
*/
public long getPlanned() {
return planned_;
}
public void setFrequency(Frequency frequency)
throws FrequencyException {
if (null == frequency) {
frequency_ = null;
} else {
frequency_ = frequency;
}
/**
* Sets the frequency at which this task should execute repeatedly.
*
* @param frequency this task's frequency
* @since 1.0
*/
public void setFrequency(Frequency frequency) {
frequency_ = frequency;
}
public Task frequency(Frequency frequency)
throws FrequencyException {
/**
* Sets the frequency at which this task should execute repeatedly.
*
* @param frequency this task's frequency
* @return this task instance
* @since 1.0
*/
public Task frequency(Frequency frequency) {
setFrequency(frequency);
return this;
}
/**
* Retrieves the frequency at which this task should execute repeatedly.
*
* @return this task's frequency; or
* {@code null} if the frequency hasn't been set
* @since 1.0
*/
public Frequency getFrequency() {
if (null == frequency_) {
return null;
}
return frequency_;
}
/**
* Sets the frequency crontab-like specification at which this task should
* execute repeatedly.
*
* @param specification the frequency specification
* @throws FrequencyException when an error occurred during the parsing
* of the frequency specification
* @since 1.0
*/
public void setFrequencySpecification(String specification)
throws FrequencyException {
if (specification == null) {
@ -169,12 +311,30 @@ public class Task extends MetaData implements Cloneable {
}
}
/**
* Sets the frequency crontab-like specification at which this task should
* execute repeatedly.
*
* @param specification the frequency specification
* @return this task instance
* @throws FrequencyException when an error occurred during the parsing
* of the frequency specification
* @since 1.0
*/
public Task frequencySpecification(String specification)
throws FrequencyException {
setFrequencySpecification(specification);
return this;
}
/**
* Retrieves the frequency specification at which this task should execute
* repeatedly.
*
* @return this task's frequency specification; or
* {@code null} if the frequency hasn't been set
* @since 1.0
*/
public String getFrequencySpecification() {
if (frequency_ == null) {
return null;
@ -182,23 +342,67 @@ public class Task extends MetaData implements Cloneable {
return frequency_.toString();
}
/**
* Create a new task option for this task.
* <p>
* Make sure to first add this task to a task manager or scheduler so that
* it receives its unique ID. Without this, the task option will not be
* properly associated with the task.
*
* @return the newly created task option.
* @since 1.0
*/
public TaskOption createTaskOption() {
return new TaskOption().taskId(id_);
}
/**
* Sets the unique ID of this task.
* <p>
* This is intended to be used internally by RIFE2.
*
* @param id the unique ID of this task.
* @since 1.0
*/
public void setId(int id) {
id_ = id;
}
/**
* Retrieves the unique ID of this task.
*
* @return this task's unique ID; or
* {@code -1} if the ID hasn't been set yet
* @since 1.0
*/
public int getId() {
return id_;
}
/**
* Sets whether the task is currently busy being processed by an {@link Executor}.
* <p>
* This is intended to be used internally by RIFE2.
*
* @param busy {@code true} if the task is busy; or
* {@code false} otherwise
* @since 1.0
*/
public void setBusy(boolean busy) {
busy_ = busy;
}
public Task busy(boolean busy) {
setBusy(busy);
return this;
}
/**
* Indicates whether this task is currently being processed by an {@link Executor}.
*
* @return {@code true} if the task is busy; or
* {@code false} otherwise
* @since 1.0
*/
public boolean isBusy() {
return busy_;
}
public TaskOption createTaskOption() {
return new TaskOption().taskId(id_);
}
public Task clone()
throws CloneNotSupportedException {
return (Task) super.clone();

153
lib/src/main/java/rife/scheduler/TaskManager.java
View file

@ -8,41 +8,172 @@ import rife.scheduler.exceptions.TaskManagerException;
import java.util.Collection;
/**
* This interface defines the methods that classes with
* {@code TaskManager} functionalities have to implement.
*
* @author Geert Bevin (gbevin[remove] at uwyn dot com)
* @since 1.0
*/
public interface TaskManager {
/**
* Sets the scheduler that uses this task manager.
*
* @param scheduler this task manager's scheduler
* @since 1.0
*/
void setScheduler(Scheduler scheduler);
/**
* Retrieves the scheduler of this task manager.
*
* @return this task manager's scheduler; or
* {@code null} if the scheduler hasn't been set
* @since 1.0
*/
Scheduler getScheduler();
/**
* Adds a new task.
* <p>
* After the task addition, the unique ID of the task should
* be stored in the provided task instance.
*
* @param task the task to add
* @return this unique ID of the added task
* @throws TaskManagerException when an error occurred during the task addition
* @since 1.0
*/
int addTask(Task task)
throws TaskManagerException;
/**
* Update an existing task.
* <p>
* The task instance should have the unique ID set to be able to
* update the existing one.
*
* @param task the updated task
* @return {@code true} if the task was successfully updated; or
* {@code false} otherwise
* @throws TaskManagerException when an error occurred during the task update
* @since 1.0
*/
boolean updateTask(Task task)
throws TaskManagerException;
/**
* Retrieves a task from it's unique ID.
*
* @param id the unique ID of the task to retrieve
* @return the retrieved task; or
* {@code null} if no such task could be found
* @throws TaskManagerException when an error occurred during the task retrieval
* @since 1.0
*/
Task getTask(int id)
throws TaskManagerException;
Collection<Task> getAllTasks()
throws TaskManagerException;
Collection<Task> getTasksToProcess()
throws TaskManagerException;
Collection<Task> getScheduledTasks()
throws TaskManagerException;
/**
* Remove a task.
*
* @param id the unique ID of the task to remove
* @return {@code true} if the task was successfully removed; or
* {@code false} otherwise
* @throws TaskManagerException when an error occurred during the task removal
* @since 1.0
*/
boolean removeTask(int id)
throws TaskManagerException;
boolean rescheduleTask(Task task, long interval, Frequency frequency)
/**
* Retrieves all the tasks that are registered with this task manager.
*
* @return a collection of all the task manager tasks
* @throws TaskManagerException when an error occurred during the collection of the tasks
* @since 1.0
*/
Collection<Task> getAllTasks()
throws TaskManagerException;
boolean concludeTask(Task task)
/**
* Retrieves the tasks that are not busy and that should be processed
* next by the scheduled based on the current time.
*
* @return a collection of all the tasks that need to be processed
* @throws TaskManagerException when an error occurred during the collection of the tasks
* @since 1.0
*/
Collection<Task> getTasksToProcess()
throws TaskManagerException;
/**
* Retrieves the tasks that are not busy and that are schedule to
* execute some time in the future.
*
* @return a collection of all the tasks that are scheduled
* @throws TaskManagerException when an error occurred during the collection of the tasks
* @since 1.0
*/
Collection<Task> getScheduledTasks()
throws TaskManagerException;
/**
* Reschedule an existing task at a particular timestamp.
* <p>
* This method will also change the task instance that's provided.
* <p>
* The task instance should have the unique ID set to be able to
* update the existing one.
*
* @param task the task to reschedule
* @param planned the planned timestamp in milliseconds since epoch
* @param frequency the new frequency of the task
* @return {@code true} if the task was successfully rescheduled; or
* {@code false} otherwise
* @throws TaskManagerException when an error occurred during the rescheduling of the task
* @since 1.0
*/
boolean rescheduleTask(Task task, long planned, Frequency frequency)
throws TaskManagerException;
/**
* This method will be called when the scheduler processes a
* particular task. While being processed, the task should be set as {@code busy}.
*
* @param id the unique ID of the task to activate
* @return {@code true} if the task was successfully activated; or
* {@code false} otherwise
* @throws TaskManagerException when an error occurred during the activation of the task
* @since 1.0
*/
boolean activateTask(int id)
throws TaskManagerException;
/**
* This method will be called when the task is fully done being executed.
* The task should be set as not busy.
*
* @param id the unique ID of the task to activate
* @return {@code true} if the task was successfully deactivated; or
* {@code false} otherwise
* @throws TaskManagerException when an error occurred during the deactivation of the task
* @since 1.0
*/
boolean deactivateTask(int id)
throws TaskManagerException;
/**
* This method will be called by the scheduler when the task has done
* processing, any resources should be cleaned up and any task rescheduling, removal
* or deactivation should be done by the manager here.
*
* @param task the task to conclude
* @return @{true} when the task was successfully concluded; or
* {@code false} otherwise
* @throws TaskManagerException when an error occurred during the conclusion of the task
* @since 1.0
*/
boolean concludeTask(Task task)
throws TaskManagerException;
}

80
lib/src/main/java/rife/scheduler/TaskOption.java
View file

@ -8,11 +8,25 @@ import rife.validation.Validation;
import rife.validation.ValidationRuleNotNull;
import rife.validation.ValidationRuleRange;
/**
* A task option provides a way to configure an existing task.
* <p>
* For a task option to be valid, a task ID needs to be associated and
* both the task option name and value have to be set.
*
* @author Geert Bevin (gbevin[remove] at uwyn dot com)
* @since 1.0
*/
public class TaskOption extends Validation implements Cloneable {
private int taskId_ = -1;
private String name_ = null;
private String value_ = null;
/**
* Create a new task option instance that is not associated with any task.
*
* @since 1.0
*/
public TaskOption() {
}
@ -22,47 +36,105 @@ public class TaskOption extends Validation implements Cloneable {
addRule(new ValidationRuleNotNull("value"));
}
/**
* Sets the task ID that this task option is associated with.
*
* @param taskId the associated task ID
* @since 1.0
*/
public void setTaskId(int taskId) {
taskId_ = taskId;
}
/**
* Sets the task ID that this task option is associated with.
*
* @param taskId the associated task ID
* @return this task option instance
* @since 1.0
*/
public TaskOption taskId(int taskId) {
setTaskId(taskId);
return this;
}
/**
* Retrieves the task ID this task option is associated with.
*
* @return the associated task ID; or
* {@code -1} when no task has been associated
*/
public int getTaskId() {
return taskId_;
}
/**
* Sets the name of this task option.
*
* @param name this task option's name
* @since 1.0
*/
public void setName(String name) {
if (null == name && 0 == name.length()) throw new IllegalArgumentException("name can't be empty.");
name_ = name;
}
/**
* Sets the name of this task option.
*
* @param name this task option's name
* @return this task option instance
* @since 1.0
*/
public TaskOption name(String name) {
setName(name);
return this;
}
/**
* Retrieves the name of this task option.
*
* @return this task option's name; or
* {@code null} if the name hasn't been set yet
*/
public String getName() {
return name_;
}
/**
* Sets the value of this task option.
*
* @param value this task option's value
* @since 1.0
*/
public void setValue(String value) {
value_ = value;
}
public String getValue() {
return value_;
}
/**
* Sets the value of this task option.
*
* @param value this task option's value
* @return this task option instance
* @since 1.0
*/
public TaskOption value(String value) {
setValue(value);
return this;
}
/**
* Retrieves the value of this task option.
*
* @return this task option's value; or
* {@code null} if the value hasn't been set yet
* @since 1.0
*/
public String getValue() {
return value_;
}
public TaskOption clone()
throws CloneNotSupportedException {
return (TaskOption) super.clone();

93
lib/src/main/java/rife/scheduler/TaskOptionManager.java
View file

@ -4,30 +4,115 @@
*/
package rife.scheduler;
import rife.scheduler.exceptions.TaskManagerException;
import rife.scheduler.exceptions.TaskOptionManagerException;
import java.util.Collection;
/**
* This interface defines the methods that classes with
* {@code TaskOptionManager} functionalities have to implement.
*
* @author Geert Bevin (gbevin[remove] at uwyn dot com)
* @since 1.0
*/
public interface TaskOptionManager {
/**
* Sets the scheduler that uses this task option manager.
*
* @param scheduler this task option manager's scheduler
* @since 1.0
*/
void setScheduler(Scheduler scheduler);
/**
* Retrieves the scheduler of this task option manager.
*
* @return this task option manager's scheduler; or
* {@code null} if the scheduler hasn't been set
* @since 1.0
*/
Scheduler getScheduler();
boolean addTaskOption(TaskOption taskoption)
/**
* Adds a new task option to a task.
* <p>
* The provided task option needs to have the appropriate
* task ID set, otherwise the addition will fail.
*
* @param taskOption the task option to add
* @return {@code true} when the task option was successfully added; or
* {@code false} otherwise
* @throws TaskOptionManagerException when an error occurred during the task option addition
* @since 1.0
*/
boolean addTaskOption(TaskOption taskOption)
throws TaskOptionManagerException;
boolean updateTaskOption(TaskOption taskoption)
/**
* Update an existing task option.
* <p>
* The provided task option needs to have the appropriate
* task ID set, otherwise the update will fail.
*
* @param taskOption the updated task option
* @return {@code true} if the task option was successfully updated; or
* {@code false} otherwise
* @throws TaskManagerException when an error occurred during the task option update
* @since 1.0
*/
boolean updateTaskOption(TaskOption taskOption)
throws TaskOptionManagerException;
/**
* Retrieves a named task options for a particular task.
*
* @param taskId the unique ID of the task to retrieve the task option for
* @param name the name of the task option
* @return the retrieved task option instance; or
* {@code null} when the task option couldn't be found
* @throws TaskOptionManagerException when an error occurred during the task option retrieval
* @since 1.0
*/
TaskOption getTaskOption(int taskId, String name)
throws TaskOptionManagerException;
/**
* Retrieves all the task options for a particular task.
*
* @param taskId the unique ID of the task to retrieve the task options for
* @return the retrieved task options collection
* @throws TaskOptionManagerException when an error occurred during the task option retrieval
* @since 1.0
*/
Collection<TaskOption> getTaskOptions(int taskId)
throws TaskOptionManagerException;
boolean removeTaskOption(TaskOption taskoption)
/**
* Remove a particular task option.
* <p>
* The provided task option needs to have the appropriate
* task ID set, otherwise the removal will fail.
*
* @param taskOption the task option to remove
* @return {@code true} when the task option was successfully removed; or
* {@code false} otherwise
* @throws TaskOptionManagerException when an error occurred during the task option removal
* @since 1.0
*/
boolean removeTaskOption(TaskOption taskOption)
throws TaskOptionManagerException;
boolean removeTaskOption(int taskid, String name)
/**
* Remove a particular task option.
*
* @param taskId the unique ID of the task to retrieve the task option for
* @param name the name of the task option
* @return {@code true} when the task option was successfully removed; or
* {@code false} otherwise
* @throws TaskOptionManagerException when an error occurred during the task option removal
* @since 1.0
*/
boolean removeTaskOption(int taskId, String name)
throws TaskOptionManagerException;
}

11
lib/src/main/java/rife/scheduler/taskmanagers/DatabaseTasks.java
View file

@ -14,8 +14,7 @@ import rife.scheduler.taskmanagers.exceptions.*;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.*;
public abstract class DatabaseTasks extends DbQueryManager implements TaskManager {
private Scheduler scheduler_ = null;
@ -159,7 +158,7 @@ public abstract class DatabaseTasks extends DbQueryManager implements TaskManage
assert tasks != null;
return tasks;
return Collections.unmodifiableCollection(tasks);
}
protected Collection<Task> getTasksToProcess_(Select getTasksToProcess, ProcessTask processTask)
@ -177,7 +176,7 @@ public abstract class DatabaseTasks extends DbQueryManager implements TaskManage
assert tasks_to_process != null;
return tasks_to_process;
return Collections.unmodifiableCollection(tasks_to_process);
}
protected Collection<Task> getScheduledTasks_(Select getScheduledTasks, ProcessTask processTask)
@ -193,7 +192,7 @@ public abstract class DatabaseTasks extends DbQueryManager implements TaskManage
assert scheduled_tasks != null;
return scheduled_tasks;
return Collections.unmodifiableCollection(scheduled_tasks);
}
protected boolean removeTask_(Delete removeTask, final int id)
@ -251,7 +250,7 @@ public abstract class DatabaseTasks extends DbQueryManager implements TaskManage
}
try {
var next_date = task.getNextDate();
var next_date = task.getNextTimestamp();
if (next_date >= 0 &&
rescheduleTask(task, next_date, task.getFrequency()) &&
deactivateTask(task.getId())) {

23
lib/src/main/java/rife/scheduler/taskmanagers/MemoryTasks.java
View file

@ -4,10 +4,7 @@
*/
package rife.scheduler.taskmanagers;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.*;
import rife.scheduler.*;
import rife.scheduler.exceptions.FrequencyException;
@ -82,7 +79,7 @@ public class MemoryTasks implements TaskManager {
public Collection<Task> getAllTasks()
throws TaskManagerException {
synchronized (this) {
return new ArrayList<>(taskMapping_.values());
return Collections.unmodifiableCollection(taskMapping_.values());
}
}
@ -99,7 +96,7 @@ public class MemoryTasks implements TaskManager {
}
}
return tasks_to_process;
return Collections.unmodifiableCollection(tasks_to_process);
}
public Collection<Task> getScheduledTasks()
@ -115,7 +112,7 @@ public class MemoryTasks implements TaskManager {
}
}
return scheduled_tasks;
return Collections.unmodifiableCollection(scheduled_tasks);
}
public boolean removeTask(int id)
@ -127,23 +124,23 @@ public class MemoryTasks implements TaskManager {
}
}
public boolean rescheduleTask(Task task, long newPlanned, Frequency frequency)
public boolean rescheduleTask(Task task, long planned, Frequency frequency)
throws TaskManagerException {
if (null == task) throw new IllegalArgumentException("task can't be null.");
if (newPlanned <= 0) throw new IllegalArgumentException("newPlanned has to be bigger than 0.");
if (planned <= 0) throw new IllegalArgumentException("newPlanned has to be bigger than 0.");
var result = false;
Task task_tmp;
try {
task_tmp = task.clone();
task_tmp.setPlanned(newPlanned);
task_tmp.setPlanned(planned);
task_tmp.setFrequency(frequency);
} catch (Throwable e) {
if (null == frequency) {
throw new RescheduleTaskErrorException(task.getId(), newPlanned, e);
throw new RescheduleTaskErrorException(task.getId(), planned, e);
} else {
throw new RescheduleTaskErrorException(task.getId(), newPlanned, frequency, e);
throw new RescheduleTaskErrorException(task.getId(), planned, frequency, e);
}
}
result = updateTask(task_tmp);
@ -163,7 +160,7 @@ public class MemoryTasks implements TaskManager {
}
try {
var next_date = task.getNextDate();
var next_date = task.getNextTimestamp();
if (next_date >= 0 &&
rescheduleTask(task, next_date, task.getFrequency()) &&
deactivateTask(task.getId())) {

4
lib/src/main/java/rife/scheduler/taskmanagers/databasedrivers/generic.java
View file

@ -162,9 +162,9 @@ public class generic extends DatabaseTasks {
return removeTask_(removeTask_, id);
}
public boolean rescheduleTask(Task task, long interval, Frequency frequency)
public boolean rescheduleTask(Task task, long planned, Frequency frequency)
throws TaskManagerException {
return rescheduleTask_(task, interval, frequency);
return rescheduleTask_(task, planned, frequency);
}
public boolean concludeTask(Task task)

17
lib/src/main/java/rife/scheduler/taskoptionmanagers/DatabaseTaskOptions.java
View file

@ -19,8 +19,7 @@ import rife.scheduler.exceptions.TaskOptionManagerException;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.*;
public abstract class DatabaseTaskOptions extends DbQueryManager implements TaskOptionManager {
private Scheduler scheduler_ = null;
@ -73,7 +72,7 @@ public abstract class DatabaseTaskOptions extends DbQueryManager implements Task
throws TaskOptionManagerException {
assert addTaskOption != null;
if (null == taskoption) throw new IllegalArgumentException("taskoption can't be null.");
if (null == taskoption) throw new IllegalArgumentException("taskOption can't be null.");
var result = false;
@ -93,7 +92,7 @@ public abstract class DatabaseTaskOptions extends DbQueryManager implements Task
throws TaskOptionManagerException {
assert updateTaskOption != null;
if (null == taskoption) throw new IllegalArgumentException("taskoption can't be null.");
if (null == taskoption) throw new IllegalArgumentException("taskOption can't be null.");
var result = false;
try {
@ -112,7 +111,7 @@ public abstract class DatabaseTaskOptions extends DbQueryManager implements Task
throws TaskOptionManagerException {
assert getTaskOption != null;
if (taskId < 0) throw new IllegalArgumentException("taskid can't be negative.");
if (taskId < 0) throw new IllegalArgumentException("taskId can't be negative.");
if (null == name) throw new IllegalArgumentException("name can't be null.");
if (0 == name.length()) throw new IllegalArgumentException("name can't be empty.");
@ -134,7 +133,7 @@ public abstract class DatabaseTaskOptions extends DbQueryManager implements Task
throws TaskOptionManagerException {
assert getTaskOptions != null;
if (taskId < 0) throw new IllegalArgumentException("taskid can't be negative.");
if (taskId < 0) throw new IllegalArgumentException("taskId can't be negative.");
var task_options = new ArrayList<TaskOption>();
processTaskOption.setCollection(task_options);
@ -147,12 +146,12 @@ public abstract class DatabaseTaskOptions extends DbQueryManager implements Task
assert task_options != null;
return task_options;
return Collections.unmodifiableCollection(task_options);
}
protected boolean _removeTaskOption(Delete removeTaskOption, TaskOption taskoption)
throws TaskOptionManagerException {
if (null == taskoption) throw new IllegalArgumentException("taskoption can't be null.");
if (null == taskoption) throw new IllegalArgumentException("taskOption can't be null.");
return _removeTaskOption(removeTaskOption, taskoption.getTaskId(), taskoption.getName());
}
@ -161,7 +160,7 @@ public abstract class DatabaseTaskOptions extends DbQueryManager implements Task
throws TaskOptionManagerException {
assert removeTaskOption != null;
if (taskId < 0) throw new IllegalArgumentException("taskid can't be negative.");
if (taskId < 0) throw new IllegalArgumentException("taskId can't be negative.");
if (null == name) throw new IllegalArgumentException("name can't be null.");
if (0 == name.length()) throw new IllegalArgumentException("name can't be empty.");

45
lib/src/main/java/rife/scheduler/taskoptionmanagers/MemoryTaskOptions.java
View file

@ -4,10 +4,7 @@
*/
package rife.scheduler.taskoptionmanagers;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.*;
import rife.scheduler.Scheduler;
import rife.scheduler.TaskOption;
@ -35,15 +32,15 @@ public class MemoryTaskOptions implements TaskOptionManager {
return scheduler_;
}
public boolean addTaskOption(TaskOption taskoption)
public boolean addTaskOption(TaskOption taskOption)
throws TaskOptionManagerException {
if (null == taskoption) throw new IllegalArgumentException("taskoption can't be null.");
if (taskoption.getTaskId() < 0) throw new IllegalArgumentException("the task id is required.");
if (null == taskOption) throw new IllegalArgumentException("taskOption can't be null.");
if (taskOption.getTaskId() < 0) throw new IllegalArgumentException("the task id is required.");
synchronized (this) {
TaskOption cloned_taskoption = null;
try {
cloned_taskoption = taskoption.clone();
cloned_taskoption = taskOption.clone();
} catch (CloneNotSupportedException e) {
throw new AddTaskOptionErrorException(cloned_taskoption, e);
}
@ -80,15 +77,15 @@ public class MemoryTaskOptions implements TaskOptionManager {
}
}
public boolean updateTaskOption(TaskOption taskoption)
public boolean updateTaskOption(TaskOption taskOption)
throws TaskOptionManagerException {
if (null == taskoption) throw new IllegalArgumentException("taskoption can't be null.");
if (taskoption.getTaskId() < 0) throw new IllegalArgumentException("the task id is required.");
if (null == taskOption) throw new IllegalArgumentException("taskOption can't be null.");
if (taskOption.getTaskId() < 0) throw new IllegalArgumentException("the task id is required.");
synchronized (this) {
TaskOption cloned_taskoption = null;
try {
cloned_taskoption = taskoption.clone();
cloned_taskoption = taskOption.clone();
} catch (CloneNotSupportedException e) {
throw new AddTaskOptionErrorException(cloned_taskoption, e);
}
@ -104,15 +101,15 @@ public class MemoryTaskOptions implements TaskOptionManager {
// get the task options for the same task id
var task_id = cloned_taskoption.getTaskId();
var taskoptions = taskOptionsMapping_.get(task_id);
if (null == taskoptions) {
var task_options = taskOptionsMapping_.get(task_id);
if (null == task_options) {
return false;
}
// obtain the task option with same name
TaskOption task_option_to_remove = null;
for (var taskoption_to_check : taskoptions) {
if (taskoption_to_check.getName().equals(cloned_taskoption.getName())) {
task_option_to_remove = taskoption_to_check;
for (var task_option_to_check : task_options) {
if (task_option_to_check.getName().equals(cloned_taskoption.getName())) {
task_option_to_remove = task_option_to_check;
break;
}
}
@ -122,9 +119,9 @@ public class MemoryTaskOptions implements TaskOptionManager {
return false;
}
// remove the old taskoption and store the new one
taskoptions.remove(task_option_to_remove);
taskoptions.add(cloned_taskoption);
// remove the old task option and store the new one
task_options.remove(task_option_to_remove);
task_options.add(cloned_taskoption);
return true;
}
@ -158,15 +155,15 @@ public class MemoryTaskOptions implements TaskOptionManager {
if (taskId < 0) throw new IllegalArgumentException("taskId can't be negative.");
synchronized (this) {
return taskOptionsMapping_.get(taskId);
return Collections.unmodifiableCollection(taskOptionsMapping_.get(taskId));
}
}
public boolean removeTaskOption(TaskOption taskoption)
public boolean removeTaskOption(TaskOption taskOption)
throws TaskOptionManagerException {
if (null == taskoption) throw new IllegalArgumentException("taskoption can't be null.");
if (null == taskOption) throw new IllegalArgumentException("taskOption can't be null.");
return removeTaskOption(taskoption.getTaskId(), taskoption.getName());
return removeTaskOption(taskOption.getTaskId(), taskOption.getName());
}
public boolean removeTaskOption(int taskId, String name)

40
lib/src/main/java/rife/scheduler/taskoptionmanagers/databasedrivers/com_mysql_cj_jdbc_Driver.java
View file

@ -36,38 +36,38 @@ public class com_mysql_cj_jdbc_Driver extends generic {
.whereParameter("id", "=");
}
public boolean addTaskOption(final TaskOption taskoption)
public boolean addTaskOption(final TaskOption taskOption)
throws TaskOptionManagerException {
if (null == taskoption) throw new IllegalArgumentException("taskoption can't be null.");
if (null == taskOption) throw new IllegalArgumentException("taskoption can't be null.");
// simulate TaskID foreign key
try {
if (!executeHasResultRows(taskIdExists_, new DbPreparedStatementHandler() {
public void setParameters(DbPreparedStatement statement) {
statement
.setInt("id", taskoption.getTaskId());
.setInt("id", taskOption.getTaskId());
}
})) {
throw new InexistentTaskIdException(taskoption.getTaskId());
throw new InexistentTaskIdException(taskOption.getTaskId());
}
} catch (DatabaseException e) {
throw new AddTaskOptionErrorException(taskoption, e);
throw new AddTaskOptionErrorException(taskOption, e);
}
try {
return _addTaskOption(addTaskOption_, new DbPreparedStatementHandler() {
public void setParameters(DbPreparedStatement statement) {
statement
.setInt("task_id", taskoption.getTaskId())
.setString("name", taskoption.getName())
.setString("val", taskoption.getValue());
.setInt("task_id", taskOption.getTaskId())
.setString("name", taskOption.getName())
.setString("val", taskOption.getValue());
}
}, taskoption);
}, taskOption);
} catch (TaskOptionManagerException e) {
if (null != e.getCause() &&
null != e.getCause().getCause()) {
if (-1 != e.getCause().getCause().getMessage().toLowerCase().indexOf("duplicate")) {
throw new DuplicateTaskOptionException(taskoption.getTaskId(), taskoption.getName());
throw new DuplicateTaskOptionException(taskOption.getTaskId(), taskOption.getName());
}
}
@ -75,38 +75,38 @@ public class com_mysql_cj_jdbc_Driver extends generic {
}
}
public boolean updateTaskOption(final TaskOption taskoption)
public boolean updateTaskOption(final TaskOption taskOption)
throws TaskOptionManagerException {
if (null == taskoption) throw new IllegalArgumentException("taskoption can't be null.");
if (null == taskOption) throw new IllegalArgumentException("taskoption can't be null.");
// simulate TaskID foreign key
try {
if (!executeHasResultRows(taskIdExists_, new DbPreparedStatementHandler() {
public void setParameters(DbPreparedStatement statement) {
statement
.setInt("id", taskoption.getTaskId());
.setInt("id", taskOption.getTaskId());
}
})) {
throw new InexistentTaskIdException(taskoption.getTaskId());
throw new InexistentTaskIdException(taskOption.getTaskId());
}
} catch (DatabaseException e) {
throw new UpdateTaskOptionErrorException(taskoption, e);
throw new UpdateTaskOptionErrorException(taskOption, e);
}
try {
return _updateTaskOption(updateTaskOption_, new DbPreparedStatementHandler() {
public void setParameters(DbPreparedStatement statement) {
statement
.setInt("task_id", taskoption.getTaskId())
.setString("name", taskoption.getName())
.setString("val", taskoption.getValue());
.setInt("task_id", taskOption.getTaskId())
.setString("name", taskOption.getName())
.setString("val", taskOption.getValue());
}
}, taskoption);
}, taskOption);
} catch (TaskOptionManagerException e) {
if (null != e.getCause() &&
null != e.getCause().getCause()) {
if (e.getCause().getCause().getMessage().toLowerCase().contains("duplicate")) {
throw new DuplicateTaskOptionException(taskoption.getTaskId(), taskoption.getName());
throw new DuplicateTaskOptionException(taskOption.getTaskId(), taskOption.getName());
}
}

32
lib/src/main/java/rife/scheduler/taskoptionmanagers/databasedrivers/generic.java
View file

@ -78,25 +78,25 @@ public class generic extends DatabaseTaskOptions {
return remove_(dropTableTaskOption_);
}
public boolean addTaskOption(final TaskOption taskoption)
public boolean addTaskOption(final TaskOption taskOption)
throws TaskOptionManagerException {
try {
return _addTaskOption(addTaskOption_, new DbPreparedStatementHandler() {
public void setParameters(DbPreparedStatement statement) {
statement
.setInt("task_id", taskoption.getTaskId())
.setString("name", taskoption.getName())
.setString("val", taskoption.getValue());
.setInt("task_id", taskOption.getTaskId())
.setString("name", taskOption.getName())
.setString("val", taskOption.getValue());
}
}, taskoption);
}, taskOption);
} catch (TaskOptionManagerException e) {
if (null != e.getCause() &&
null != e.getCause().getCause()) {
String message = e.getCause().getCause().getMessage().toUpperCase();
if (message.contains(createTableTaskOption_.getForeignKeys().get(0).getName())) {
throw new InexistentTaskIdException(taskoption.getTaskId());
throw new InexistentTaskIdException(taskOption.getTaskId());
} else if (message.contains(createTableTaskOption_.getPrimaryKeys().get(0).getName())) {
throw new DuplicateTaskOptionException(taskoption.getTaskId(), taskoption.getName());
throw new DuplicateTaskOptionException(taskOption.getTaskId(), taskOption.getName());
}
}
@ -104,25 +104,25 @@ public class generic extends DatabaseTaskOptions {
}
}
public boolean updateTaskOption(final TaskOption taskoption)
public boolean updateTaskOption(final TaskOption taskOption)
throws TaskOptionManagerException {
try {
return _updateTaskOption(updateTaskOption_, new DbPreparedStatementHandler() {
public void setParameters(DbPreparedStatement statement) {
statement
.setInt("task_id", taskoption.getTaskId())
.setString("name", taskoption.getName())
.setString("val", taskoption.getValue());
.setInt("task_id", taskOption.getTaskId())
.setString("name", taskOption.getName())
.setString("val", taskOption.getValue());
}
}, taskoption);
}, taskOption);
} catch (TaskOptionManagerException e) {
if (null != e.getCause() &&
null != e.getCause().getCause()) {
String message = e.getCause().getCause().getMessage().toUpperCase();
if (message.contains(createTableTaskOption_.getForeignKeys().get(0).getName())) {
throw new InexistentTaskIdException(taskoption.getTaskId());
throw new InexistentTaskIdException(taskOption.getTaskId());
} else if (message.contains(createTableTaskOption_.getPrimaryKeys().get(0).getName())) {
throw new DuplicateTaskOptionException(taskoption.getTaskId(), taskoption.getName());
throw new DuplicateTaskOptionException(taskOption.getTaskId(), taskOption.getName());
}
}
@ -140,9 +140,9 @@ public class generic extends DatabaseTaskOptions {
return _getTaskOptions(getTaskOptions_, new ProcessTaskOption(), taskId);
}
public boolean removeTaskOption(TaskOption taskoption)
public boolean removeTaskOption(TaskOption taskOption)
throws TaskOptionManagerException {
return _removeTaskOption(removeTaskOption_, taskoption);
return _removeTaskOption(removeTaskOption_, taskOption);
}
public boolean removeTaskOption(int taskId, String name)

394
lib/src/test/java/rife/scheduler/TestFrequency.java
View file

@ -1290,119 +1290,119 @@ public class TestFrequency {
frequency = new Frequency("* * * * *");
previous = calendar_time;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(minute, next - previous);
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(minute, next - previous);
frequency = new Frequency("28 * * * *"); // 2002/09/01 10:29
previous = calendar_time;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(59 * minute, next - previous); // 2002/09/01 11:28
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(hour, next - previous); // 2002/09/01 12:28
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(hour, next - previous); // 2002/09/01 13:28
frequency = new Frequency("*/3 * * * *"); // 2002/09/01 10:29
previous = calendar_time;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(minute, next - previous); // 2002/09/01 10:30
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(3 * minute, next - previous); // 2002/09/01 10:33
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(3 * minute, next - previous); // 2002/09/01 10:36
frequency = new Frequency("28-56/7 * * * *"); // 2002/09/01 10:29
previous = calendar_time;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(6 * minute, next - previous); // 2002/09/01 10:35
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(7 * minute, next - previous); // 2002/09/01 10:42
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(7 * minute, next - previous); // 2002/09/01 10:49
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(7 * minute, next - previous); // 2002/09/01 10:56
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(32 * minute, next - previous); // 2002/09/01 11:28
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(7 * minute, next - previous); // 2002/09/01 11:35
frequency = new Frequency("56-40/13 * * * *"); // 2002/09/01 10:29
previous = calendar_time;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(6 * minute, next - previous); // 2002/09/01 10:35
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(21 * minute, next - previous); // 2002/09/01 10:56
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(13 * minute, next - previous); // 2002/09/01 11:09
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(13 * minute, next - previous); // 2002/09/01 11:22
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(13 * minute, next - previous); // 2002/09/01 11:35
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(21 * minute, next - previous); // 2002/09/01 11:56
frequency = new Frequency("31,37-57/4,59-4,7 * * * *"); // 2002/09/01 10:29
previous = calendar_time;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(2 * minute, next - previous); // 2002/09/01 10:31
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(6 * minute, next - previous); // 2002/09/01 10:37
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(4 * minute, next - previous); // 2002/09/01 10:41
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(4 * minute, next - previous); // 2002/09/01 10:45
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(4 * minute, next - previous); // 2002/09/01 10:49
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(4 * minute, next - previous); // 2002/09/01 10:53
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(4 * minute, next - previous); // 2002/09/01 10:57
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(2 * minute, next - previous); // 2002/09/01 10:59
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(minute, next - previous); // 2002/09/01 11:00
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(minute, next - previous); // 2002/09/01 11:01
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(minute, next - previous); // 2002/09/01 11:02
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(minute, next - previous); // 2002/09/01 11:03
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(minute, next - previous); // 2002/09/01 11:04
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(3 * minute, next - previous); // 2002/09/01 11:07
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(24 * minute, next - previous); // 2002/09/01 11:31
} catch (FrequencyException e) {
fail(ExceptionUtils.getExceptionStackTrace(e));
@ -1425,113 +1425,113 @@ public class TestFrequency {
frequency = new Frequency("*/30 13 * * *"); // 2002/09/01 10:29
previous = calendar_time;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(2 * hour + 31 * minute, next - previous); // 2002/09/01 13:00
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(30 * minute, next - previous); // 2002/09/01 13:30
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(day - (30 * minute), next - previous); // 2002/09/02 13:00
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(30 * minute, next - previous); // 2002/09/02 13:30
frequency = new Frequency("10 13 * * *"); // 2002/09/01 10:29
previous = calendar_time;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(2 * hour + 41 * minute, next - previous); // 2002/09/01 13:10
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(day, next - previous); // 2002/09/02 13:10
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(day, next - previous); // 2002/09/03 13:10
frequency = new Frequency("34 */5 * * *"); // 2002/09/01 10:29
previous = calendar_time;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(5 * minute, next - previous); // 2002/09/01 10:34
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(5 * hour, next - previous); // 2002/09/02 15:34
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(5 * hour, next - previous); // 2002/09/02 20:34
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(4 * hour, next - previous); // 2002/09/03 00:34
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(5 * hour, next - previous); // 2002/09/03 05:34
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(5 * hour, next - previous); // 2002/09/03 10:34
frequency = new Frequency("13 7-23/7 * * *"); // 2002/09/01 10:29
previous = calendar_time;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(31 * minute + 3 * hour + 13 * minute, next - previous); // 2002/09/01 14:13
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(7 * hour, next - previous); // 2002/09/02 21:13
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(10 * hour, next - previous); // 2002/09/03 07:13
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(7 * hour, next - previous); // 2002/09/03 14:13
frequency = new Frequency("48 18-7/3 * * *"); // 2002/09/01 10:29
previous = calendar_time;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(31 * minute + 7 * hour + 48 * minute, next - previous); // 2002/09/01 18:48
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(3 * hour, next - previous); // 2002/09/01 21:48
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(3 * hour, next - previous); // 2002/09/02 00:48
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(3 * hour, next - previous); // 2002/09/02 03:48
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(3 * hour, next - previous); // 2002/09/02 06:48
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(12 * hour, next - previous); // 2002/09/02 18:48
frequency = new Frequency("14 2,4-7,10-18/3,21-0/3 * * *"); // 2002/09/01 10:29
previous = calendar_time;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(31 * minute + 2 * hour + 14 * minute, next - previous); // 2002/09/01 13:14
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(3 * hour, next - previous); // 2002/09/01 16:14
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(5 * hour, next - previous); // 2002/09/01 21:14
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(3 * hour, next - previous); // 2002/09/02 00:14
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(2 * hour, next - previous); // 2002/09/02 02:14
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(2 * hour, next - previous); // 2002/09/02 04:14
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(hour, next - previous); // 2002/09/02 05:14
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(hour, next - previous); // 2002/09/02 06:14
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(hour, next - previous); // 2002/09/02 07:14
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(3 * hour, next - previous); // 2002/09/02 10:14
} catch (FrequencyException e) {
fail(ExceptionUtils.getExceptionStackTrace(e));
@ -1554,109 +1554,109 @@ public class TestFrequency {
frequency = new Frequency("*/30 */12 6 * *"); // 2002/09/01 10:29
previous = calendar_time;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(31 * minute + 13 * hour + 4 * day, next - previous); // 2002/09/06 00:00
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(30 * minute, next - previous); // 2002/09/06 00:30
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(30 * minute + 11 * hour, next - previous); // 2002/09/06 12:00
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(30 * minute, next - previous); // 2002/09/06 12:30
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(30 * minute + 11 * hour + 29 * day, next - previous); // 2002/10/06 00:00
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(30 * minute, next - previous); // 2002/10/06 00:30
frequency = new Frequency("19 10 */11 * *"); // 2002/09/01 10:29
previous = calendar_time;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(11 * day - 10 * minute, next - previous); // 2002/09/12 10:19
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(11 * day, next - previous); // 2002/09/23 10:19
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(8 * day, next - previous); // 2002/10/01 10:19
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(11 * day, next - previous); // 2002/10/12 10:19
frequency = new Frequency("57 10 6-18/5 * *"); // 2002/09/01 10:29
previous = calendar_time;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(28 * minute + 5 * day, next - previous); // 2002/09/06 10:57
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(5 * day, next - previous); // 2002/09/11 10:57
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(5 * day, next - previous); // 2002/09/16 10:57
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(20 * day, next - previous); // 2002/10/06 10:57
frequency = new Frequency("24 19 27-9/4 * *"); // 2002/09/01 10:29
previous = calendar_time;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(9 * hour - 5 * minute + 3 * day, next - previous); // 2002/09/04 19:24
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(4 * day, next - previous); // 2002/09/08 19:24
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(19 * day, next - previous); // 2002/09/27 19:24
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(4 * day, next - previous); // 2002/10/01 19:24
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(4 * day, next - previous); // 2002/10/05 19:24
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(4 * day, next - previous); // 2002/10/09 19:24
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(18 * day + hour, next - previous); // 2002/10/27 19:24 (daylight savings)
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(4 * day, next - previous); // 2002/10/31 19:24
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(4 * day, next - previous); // 2002/11/04 19:24
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(4 * day, next - previous); // 2002/11/08 19:24
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(19 * day, next - previous); // 2002/11/27 19:24
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(4 * day, next - previous); // 2002/12/01 19:24
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(4 * day, next - previous); // 2002/12/05 19:24
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(4 * day, next - previous); // 2002/12/09 19:24
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(18 * day, next - previous); // 2002/12/27 19:24
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(4 * day, next - previous); // 2002/12/31 19:24
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(4 * day, next - previous); // 2003/01/04 19:24
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(4 * day, next - previous); // 2003/01/08 19:24
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(19 * day, next - previous); // 2003/01/27 19:24
calendar.set(2002, Calendar.APRIL, 28, 8, 15);
@ -1664,19 +1664,19 @@ public class TestFrequency {
frequency = new Frequency("30 9 29-4/3 * *"); // 2002/04/28 08:15
previous = calendar_time;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(15 * minute + hour + day, next - previous); // 2002/04/29 09:30
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(3 * day, next - previous); // 2002/04/02 09:30
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(27 * day, next - previous); // 2002/04/29 09:30
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(3 * day, next - previous); // 2002/05/01 09:30
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(3 * day, next - previous); // 2002/05/04 09:30
calendar.set(2002, Calendar.FEBRUARY, 1, 8, 15);
@ -1684,28 +1684,28 @@ public class TestFrequency {
frequency = new Frequency("30 8 18-10/9 * *"); // 2002/02/01 08:15
previous = calendar_time;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(15 * minute + 4 * day, next - previous); // 2002/02/05 08:30
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(13 * day, next - previous); // 2002/02/18 08:30
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(9 * day, next - previous); // 2002/02/27 08:30
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(9 * day, next - previous); // 2002/03/08 08:30
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(10 * day, next - previous); // 2002/03/18 08:30
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(9 * day, next - previous); // 2002/03/27 08:30
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(9 * day - hour, next - previous); // 2002/04/05 08:30 (daylight savings)
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(13 * day, next - previous); // 2002/04/18 08:30
calendar.set(2004, Calendar.FEBRUARY, 1, 8, 15);
@ -1713,105 +1713,105 @@ public class TestFrequency {
frequency = new Frequency("30 8 18-10/9 * *"); // 2004/02/01 08:15
previous = calendar_time;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(15 * minute + 4 * day, next - previous); // 2004/02/05 08:30
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(13 * day, next - previous); // 2004/02/18 08:30
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(9 * day, next - previous); // 2004/02/27 08:30
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(9 * day, next - previous); // 2004/03/07 08:30 (leap year)
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(11 * day, next - previous); // 2004/03/18 08:30
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(9 * day, next - previous); // 2004/03/27 08:30
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(9 * day - hour, next - previous); // 2004/04/05 08:30 (daylight savings)
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(13 * day, next - previous); // 2004/04/18 08:30
frequency = new Frequency("15 7 6,9-12,15-27/4,26-4/3 * *"); // 2004/02/01 08:15
previous = calendar_time;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(3 * day - hour, next - previous); // 2004/02/04 07:15
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(2 * day, next - previous); // 2004/02/06 07:15
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(3 * day, next - previous); // 2004/02/09 07:15
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(day, next - previous); // 2004/02/10 07:15
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(day, next - previous); // 2004/02/11 07:15
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(day, next - previous); // 2004/02/12 07:15
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(3 * day, next - previous); // 2004/02/15 07:15
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(4 * day, next - previous); // 2004/02/19 07:15
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(4 * day, next - previous); // 2004/02/23 07:15
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(3 * day, next - previous); // 2004/02/26 07:15
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(day, next - previous); // 2004/02/27 07:15
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(2 * day, next - previous); // 2004/02/29 07:15
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(3 * day, next - previous); // 2004/03/03 07:15 (leap year)
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(3 * day, next - previous); // 2004/03/06 07:15
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(3 * day, next - previous); // 2004/03/09 07:15
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(day, next - previous); // 2004/03/10 07:15
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(day, next - previous); // 2004/03/11 07:15
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(day, next - previous); // 2004/03/12 07:15
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(3 * day, next - previous); // 2004/03/15 07:15
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(4 * day, next - previous); // 2004/03/19 07:15
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(4 * day, next - previous); // 2004/03/23 07:15
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(3 * day, next - previous); // 2004/03/26 07:15
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(day, next - previous); // 2004/03/27 07:15
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(2 * day - hour, next - previous); // 2004/03/29 07:15 (daylight savings)
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(3 * day, next - previous); // 2004/04/01 07:15
calendar.set(2003, Calendar.DECEMBER, 20, 17, 10);
@ -1819,25 +1819,25 @@ public class TestFrequency {
frequency = new Frequency("20 19 20-10/5 * *"); // 2003/12/20 17:10
previous = calendar_time;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(10 * minute + 2 * hour, next - previous); // 2003/12/20 19:20
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(5 * day, next - previous); // 2003/12/25 19:20
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(5 * day, next - previous); // 2003/12/30 19:20
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(5 * day, next - previous); // 2004/01/04 19:20
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(5 * day, next - previous); // 2004/01/09 19:20
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(11 * day, next - previous); // 2004/01/20 19:20
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(5 * day, next - previous); // 2004/01/25 19:20
} catch (FrequencyException e) {
fail(ExceptionUtils.getExceptionStackTrace(e));
@ -1860,114 +1860,114 @@ public class TestFrequency {
frequency = new Frequency("*/30 */12 */20 10 *"); // 2002/09/01 10:29
previous = calendar_time;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(31 * minute + 13 * hour + 29 * day, next - previous); // 2002/10/01 00:00
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(30 * minute, next - previous); // 2002/10/01 00:30
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(30 * minute + 11 * hour, next - previous); // 2002/10/01 12:00
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(30 * minute, next - previous); // 2002/10/01 12:30
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(30 * minute + 11 * hour + 19 * day, next - previous); // 2002/10/21 00:00
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(30 * minute, next - previous); // 2002/10/21 00:30
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(30 * minute + 11 * hour, next - previous); // 2002/10/21 12:00
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(30 * minute, next - previous); // 2002/10/21 12:30
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(30 * minute + 11 * hour + 344 * day, next - previous); // 2003/10/01 00:00
frequency = new Frequency("10 19 7 */4 *"); // 2002/09/01 10:29
previous = calendar_time;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(31 * minute + 8 * hour + 6 * day + 10 * minute, next - previous); // 2002/09/07 19:10
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals((30 + 31 + 30 + 31) * day + hour, next - previous); // 2003/01/07 19:10 (daylight savings)
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals((31 + 28 + 31 + 30) * day - hour, next - previous); // 2003/05/07 19:10 (daylight savings)
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals((31 + 30 + 31 + 31) * day, next - previous); // 2003/09/07 19:10
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals((30 + 31 + 30 + 31) * day + hour, next - previous); // 2004/01/07 19:10 (daylight savings)
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals((31 + 29 + 31 + 30) * day - hour, next - previous); // 2004/05/07 19:10 (daylight savings)
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals((31 + 30 + 31 + 31) * day, next - previous); // 2003/09/07 19:10
frequency = new Frequency("50 06 18 4-11/3 *"); // 2002/09/01 10:29
previous = calendar_time;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(31 * minute + 13 * hour + (29 + 17) * day + 6 * hour + 50 * minute, next - previous); // 2002/10/18 06:50
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals((31 + 30 + 31 + 31 + 28 + 31) * day, next - previous); // 2003/04/18 06:50
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals((30 + 31 + 30) * day, next - previous); // 2003/07/18 06:50
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals((31 + 31 + 30) * day, next - previous); // 2003/10/18 06:50
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals((31 + 30 + 31 + 31 + 29 + 31) * day, next - previous); // 2004/04/18 06:50
frequency = new Frequency("15 12 06 8-4/3 *"); // 2002/09/01 10:29
previous = calendar_time;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(31 * minute + (5 + 30 + 31) * day + hour + 15 * minute + hour, next - previous); // 2002/11/06 12:15 (daylight savings)
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals((30 + 31 + 31) * day, next - previous); // 2003/02/06 12:15
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals((28 + 31 + 30 + 31 + 30 + 31) * day - hour, next - previous); // 2003/08/06 12:15 (daylight savings)
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals((31 + 30 + 31) * day + hour, next - previous); // 2003/11/06 12:15 (daylight savings)
frequency = new Frequency("40 11 27 2,5-6,11-4/2 *"); // 2002/09/01 10:29
previous = calendar_time;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(11 * minute + hour + (26 + 30 + 31) * day + hour, next - previous); // 2002/11/27 11:40
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals((30 + 31) * day, next - previous); // 2003/01/27 11:40
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(31 * day, next - previous); // 2003/02/27 11:40
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(28 * day, next - previous); // 2003/03/27 11:40
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals((31 + 30) * day - hour, next - previous); // 2003/05/27 11:40 (daylight savings)
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(31 * day, next - previous); // 2003/06/27 11:40
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals((30 + 31 + 31 + 30 + 31) * day + hour, next - previous); // 2003/11/27 11:40
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals((30 + 31) * day, next - previous); // 2004/01/27 11:40
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(31 * day, next - previous); // 2004/02/27 11:40
} catch (FrequencyException e) {
fail(ExceptionUtils.getExceptionStackTrace(e));
@ -1990,28 +1990,28 @@ public class TestFrequency {
frequency = new Frequency("30 12 * 10 1"); // 2002/09/01 10:29
previous = calendar_time;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(minute + 30 * day + 6 * day + 2 * hour, next - previous); // 2002/10/07 12:30
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(7 * day, next - previous); // 2002/10/14 12:30
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(7 * day, next - previous); // 2002/10/21 12:30
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(7 * day + hour, next - previous); // 2002/10/28 12:30 (daylight savings)
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(365 * day - 22 * day - hour, next - previous); // 2003/10/06 12:30 (daylight savings)
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(7 * day, next - previous); // 2003/10/13 12:30
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(7 * day, next - previous); // 2003/10/20 12:30
previous = next;
next = frequency.getNextDate(previous);
next = frequency.getNextTimestamp(previous);
assertEquals(7 * day + hour, next - previous); // 2003/10/27 12:30 (daylight savings)
} catch (FrequencyException e) {
fail(ExceptionUtils.getExceptionStackTrace(e));
@ -2028,7 +2028,7 @@ public class TestFrequency {
frequency = new Frequency("* * 31 2 *");
try {
frequency.getNextDate(calendar_time);
frequency.getNextTimestamp(calendar_time);
fail();
} catch (FrequencyException e) {
assertTrue(true);

3
lib/src/test/java/rife/scheduler/taskmanagers/TestMemoryTasks.java
View file

@ -35,7 +35,8 @@ public class TestMemoryTasks {
var task = new Task();
try {
task.type(type).planned(planned).frequency(frequency).busy(busy);
task.type(type).planned(planned).frequency(frequency);
task.setBusy(busy);
} catch (FrequencyException e) {
fail(ExceptionUtils.getExceptionStackTrace(e));
}