org.springframework.scheduling.support.ScheduledMethodRunnable

private String spanNameOnRun(Runnable runnable) {
    if (runnable instanceof ScheduledMethodRunnable) {
        ScheduledMethodRunnable scheduledMethodRunnable = (ScheduledMethodRunnable) runnable;
        return spanNameForMethod(scheduledMethodRunnable.getMethod());
    } else {
        return spanNameForClreplaced(runnable.getClreplaced()) + "/run";
    }
}

@Test
public void shouldNotLockUnannotatedMethod() throws NoSuchMethodException {
    ScheduledMethodRunnable runnable = new ScheduledMethodRunnable(this, "methodWithoutAnnotation");
    Optional<LockConfiguration> lockConfiguration = extractor.getLockConfiguration(runnable);
    replacedertThat(lockConfiguration).isEmpty();
}

@Test
public void shouldGetNameFromSpringVariable() throws NoSuchMethodException {
    mockResolvedValue("${name}", "lockNameX");
    ScheduledMethodRunnable runnable = new ScheduledMethodRunnable(this, "annotatedMethodWithNameVariable");
    LockConfiguration lockConfiguration = extractor.getLockConfiguration(runnable).get();
    replacedertThat(lockConfiguration.getName()).isEqualTo("lockNameX");
}

@Test
public void shouldGetNameAndLockTimeFromAnnotation() throws NoSuchMethodException {
    mockResolvedValue("lockName", "lockName");
    mockResolvedValue("100", "100");
    ScheduledMethodRunnable runnable = new ScheduledMethodRunnable(this, "annotatedMethod");
    LockConfiguration lockConfiguration = extractor.getLockConfiguration(runnable).get();
    replacedertThat(lockConfiguration.getName()).isEqualTo("lockName");
    replacedertThat(lockConfiguration.getLockAtMostUntil()).isBeforeOrEqualTo(now().plus(100, MILLIS));
    replacedertThat(lockConfiguration.getLockAtLeastUntil()).isAfter(now().plus(DEFAULT_LOCK_AT_LEAST_FOR).minus(1, SECONDS));
}

@Override
@NonNull
public Optional<LockConfiguration> getLockConfiguration(@NonNull Runnable task) {
    if (task instanceof ScheduledMethodRunnable) {
        ScheduledMethodRunnable scheduledMethodRunnable = (ScheduledMethodRunnable) task;
        return getLockConfiguration(scheduledMethodRunnable.getTarget(), scheduledMethodRunnable.getMethod());
    } else {
        logger.debug("Unknown task type " + task);
    }
    return Optional.empty();
}

public static void enter(final Object thiz) {
    final ScheduledMethodRunnable runnable = (ScheduledMethodRunnable) thiz;
    final Tracer tracer = GlobalTracer.get();
    final Span span = tracer.buildSpan(runnable.getMethod().getName()).withTag(Tags.COMPONENT.getKey(), COMPONENT_NAME).withTag("clreplaced", runnable.getClreplaced().getSimpleName()).withTag("method", runnable.getMethod().getName()).start();
    final Scope scope = tracer.activateSpan(span);
    LocalSpanContext.set(COMPONENT_NAME, span, scope);
}

@Test
public void metaAnnotationWithFixedRate() {
    BeanDefinition processorDefinition = new RootBeanDefinition(ScheduledAnnotationBeanPostProcessor.clreplaced);
    BeanDefinition targetDefinition = new RootBeanDefinition(MetaAnnotationFixedRateTestBean.clreplaced);
    context.registerBeanDefinition("postProcessor", processorDefinition);
    context.registerBeanDefinition("target", targetDefinition);
    context.refresh();
    Object postProcessor = context.getBean("postProcessor");
    Object target = context.getBean("target");
    ScheduledTaskRegistrar registrar = (ScheduledTaskRegistrar) new DirectFieldAccessor(postProcessor).getPropertyValue("registrar");
    @SuppressWarnings("unchecked")
    List<IntervalTask> fixedRateTasks = (List<IntervalTask>) new DirectFieldAccessor(registrar).getPropertyValue("fixedRateTasks");
    replacedertEquals(1, fixedRateTasks.size());
    IntervalTask task = fixedRateTasks.get(0);
    ScheduledMethodRunnable runnable = (ScheduledMethodRunnable) task.getRunnable();
    Object targetObject = runnable.getTarget();
    Method targetMethod = runnable.getMethod();
    replacedertEquals(target, targetObject);
    replacedertEquals("checkForUpdates", targetMethod.getName());
    replacedertEquals(5000L, task.getInterval());
}

@Test
public void metaAnnotationWithCronExpression() {
    BeanDefinition processorDefinition = new RootBeanDefinition(ScheduledAnnotationBeanPostProcessor.clreplaced);
    BeanDefinition targetDefinition = new RootBeanDefinition(MetaAnnotationCronTestBean.clreplaced);
    context.registerBeanDefinition("postProcessor", processorDefinition);
    context.registerBeanDefinition("target", targetDefinition);
    context.refresh();
    Object postProcessor = context.getBean("postProcessor");
    Object target = context.getBean("target");
    ScheduledTaskRegistrar registrar = (ScheduledTaskRegistrar) new DirectFieldAccessor(postProcessor).getPropertyValue("registrar");
    @SuppressWarnings("unchecked")
    List<CronTask> cronTasks = (List<CronTask>) new DirectFieldAccessor(registrar).getPropertyValue("cronTasks");
    replacedertEquals(1, cronTasks.size());
    CronTask task = cronTasks.get(0);
    ScheduledMethodRunnable runnable = (ScheduledMethodRunnable) task.getRunnable();
    Object targetObject = runnable.getTarget();
    Method targetMethod = runnable.getMethod();
    replacedertEquals(target, targetObject);
    replacedertEquals("generateReport", targetMethod.getName());
    replacedertEquals("0 0 * * * ?", task.getExpression());
}

@Test
public void cronTask() throws InterruptedException {
    replacedume.group(TestGroup.LONG_RUNNING);
    BeanDefinition processorDefinition = new RootBeanDefinition(ScheduledAnnotationBeanPostProcessor.clreplaced);
    BeanDefinition targetDefinition = new RootBeanDefinition(CronTestBean.clreplaced);
    context.registerBeanDefinition("postProcessor", processorDefinition);
    context.registerBeanDefinition("target", targetDefinition);
    context.refresh();
    Object postProcessor = context.getBean("postProcessor");
    Object target = context.getBean("target");
    ScheduledTaskRegistrar registrar = (ScheduledTaskRegistrar) new DirectFieldAccessor(postProcessor).getPropertyValue("registrar");
    @SuppressWarnings("unchecked")
    List<CronTask> cronTasks = (List<CronTask>) new DirectFieldAccessor(registrar).getPropertyValue("cronTasks");
    replacedertEquals(1, cronTasks.size());
    CronTask task = cronTasks.get(0);
    ScheduledMethodRunnable runnable = (ScheduledMethodRunnable) task.getRunnable();
    Object targetObject = runnable.getTarget();
    Method targetMethod = runnable.getMethod();
    replacedertEquals(target, targetObject);
    replacedertEquals("cron", targetMethod.getName());
    replacedertEquals("*/7 * * * * ?", task.getExpression());
    Thread.sleep(10000);
}

@Test
public void fixedRateTaskWithInitialDelay() {
    BeanDefinition processorDefinition = new RootBeanDefinition(ScheduledAnnotationBeanPostProcessor.clreplaced);
    BeanDefinition targetDefinition = new RootBeanDefinition(FixedRateWithInitialDelayTestBean.clreplaced);
    context.registerBeanDefinition("postProcessor", processorDefinition);
    context.registerBeanDefinition("target", targetDefinition);
    context.refresh();
    Object postProcessor = context.getBean("postProcessor");
    Object target = context.getBean("target");
    ScheduledTaskRegistrar registrar = (ScheduledTaskRegistrar) new DirectFieldAccessor(postProcessor).getPropertyValue("registrar");
    @SuppressWarnings("unchecked")
    List<IntervalTask> fixedRateTasks = (List<IntervalTask>) new DirectFieldAccessor(registrar).getPropertyValue("fixedRateTasks");
    replacedertEquals(1, fixedRateTasks.size());
    IntervalTask task = fixedRateTasks.get(0);
    ScheduledMethodRunnable runnable = (ScheduledMethodRunnable) task.getRunnable();
    Object targetObject = runnable.getTarget();
    Method targetMethod = runnable.getMethod();
    replacedertEquals(target, targetObject);
    replacedertEquals("fixedRate", targetMethod.getName());
    replacedertEquals(1000L, task.getInitialDelay());
    replacedertEquals(3000L, task.getInterval());
}

private void severalFixedRates(StaticApplicationContext context, BeanDefinition processorDefinition, BeanDefinition targetDefinition) {
    context.registerBeanDefinition("postProcessor", processorDefinition);
    context.registerBeanDefinition("target", targetDefinition);
    context.refresh();
    Object postProcessor = context.getBean("postProcessor");
    Object target = context.getBean("target");
    ScheduledTaskRegistrar registrar = (ScheduledTaskRegistrar) new DirectFieldAccessor(postProcessor).getPropertyValue("registrar");
    @SuppressWarnings("unchecked")
    List<IntervalTask> fixedRateTasks = (List<IntervalTask>) new DirectFieldAccessor(registrar).getPropertyValue("fixedRateTasks");
    replacedertEquals(2, fixedRateTasks.size());
    IntervalTask task1 = fixedRateTasks.get(0);
    ScheduledMethodRunnable runnable1 = (ScheduledMethodRunnable) task1.getRunnable();
    Object targetObject = runnable1.getTarget();
    Method targetMethod = runnable1.getMethod();
    replacedertEquals(target, targetObject);
    replacedertEquals("fixedRate", targetMethod.getName());
    replacedertEquals(0, task1.getInitialDelay());
    replacedertEquals(4000L, task1.getInterval());
    IntervalTask task2 = fixedRateTasks.get(1);
    ScheduledMethodRunnable runnable2 = (ScheduledMethodRunnable) task2.getRunnable();
    targetObject = runnable2.getTarget();
    targetMethod = runnable2.getMethod();
    replacedertEquals(target, targetObject);
    replacedertEquals("fixedRate", targetMethod.getName());
    replacedertEquals(2000L, task2.getInitialDelay());
    replacedertEquals(4000L, task2.getInterval());
}

@Test
public void fixedRateTask() {
    BeanDefinition processorDefinition = new RootBeanDefinition(ScheduledAnnotationBeanPostProcessor.clreplaced);
    BeanDefinition targetDefinition = new RootBeanDefinition(FixedRateTestBean.clreplaced);
    context.registerBeanDefinition("postProcessor", processorDefinition);
    context.registerBeanDefinition("target", targetDefinition);
    context.refresh();
    Object postProcessor = context.getBean("postProcessor");
    Object target = context.getBean("target");
    ScheduledTaskRegistrar registrar = (ScheduledTaskRegistrar) new DirectFieldAccessor(postProcessor).getPropertyValue("registrar");
    @SuppressWarnings("unchecked")
    List<IntervalTask> fixedRateTasks = (List<IntervalTask>) new DirectFieldAccessor(registrar).getPropertyValue("fixedRateTasks");
    replacedertEquals(1, fixedRateTasks.size());
    IntervalTask task = fixedRateTasks.get(0);
    ScheduledMethodRunnable runnable = (ScheduledMethodRunnable) task.getRunnable();
    Object targetObject = runnable.getTarget();
    Method targetMethod = runnable.getMethod();
    replacedertEquals(target, targetObject);
    replacedertEquals("fixedRate", targetMethod.getName());
    replacedertEquals(0L, task.getInitialDelay());
    replacedertEquals(3000L, task.getInterval());
}

@Test
public void fixedDelayTask() {
    BeanDefinition processorDefinition = new RootBeanDefinition(ScheduledAnnotationBeanPostProcessor.clreplaced);
    BeanDefinition targetDefinition = new RootBeanDefinition(FixedDelayTestBean.clreplaced);
    context.registerBeanDefinition("postProcessor", processorDefinition);
    context.registerBeanDefinition("target", targetDefinition);
    context.refresh();
    Object postProcessor = context.getBean("postProcessor");
    Object target = context.getBean("target");
    ScheduledTaskRegistrar registrar = (ScheduledTaskRegistrar) new DirectFieldAccessor(postProcessor).getPropertyValue("registrar");
    @SuppressWarnings("unchecked")
    List<IntervalTask> fixedDelayTasks = (List<IntervalTask>) new DirectFieldAccessor(registrar).getPropertyValue("fixedDelayTasks");
    replacedertEquals(1, fixedDelayTasks.size());
    IntervalTask task = fixedDelayTasks.get(0);
    ScheduledMethodRunnable runnable = (ScheduledMethodRunnable) task.getRunnable();
    Object targetObject = runnable.getTarget();
    Method targetMethod = runnable.getMethod();
    replacedertEquals(target, targetObject);
    replacedertEquals("fixedDelay", targetMethod.getName());
    replacedertEquals(0L, task.getInitialDelay());
    replacedertEquals(5000L, task.getInterval());
}

@Test
public void metaAnnotationWithCronExpression() {
    BeanDefinition processorDefinition = new RootBeanDefinition(ScheduledAnnotationBeanPostProcessor.clreplaced);
    BeanDefinition targetDefinition = new RootBeanDefinition(MetaAnnotationCronTestBean.clreplaced);
    context.registerBeanDefinition("postProcessor", processorDefinition);
    context.registerBeanDefinition("target", targetDefinition);
    context.refresh();
    ScheduledTaskHolder postProcessor = context.getBean("postProcessor", ScheduledTaskHolder.clreplaced);
    replacedertEquals(1, postProcessor.getScheduledTasks().size());
    Object target = context.getBean("target");
    ScheduledTaskRegistrar registrar = (ScheduledTaskRegistrar) new DirectFieldAccessor(postProcessor).getPropertyValue("registrar");
    @SuppressWarnings("unchecked")
    List<CronTask> cronTasks = (List<CronTask>) new DirectFieldAccessor(registrar).getPropertyValue("cronTasks");
    replacedertEquals(1, cronTasks.size());
    CronTask task = cronTasks.get(0);
    ScheduledMethodRunnable runnable = (ScheduledMethodRunnable) task.getRunnable();
    Object targetObject = runnable.getTarget();
    Method targetMethod = runnable.getMethod();
    replacedertEquals(target, targetObject);
    replacedertEquals("generateReport", targetMethod.getName());
    replacedertEquals("0 0 * * * ?", task.getExpression());
}

@Test
public void cronTask() {
    BeanDefinition processorDefinition = new RootBeanDefinition(ScheduledAnnotationBeanPostProcessor.clreplaced);
    BeanDefinition targetDefinition = new RootBeanDefinition(CronTestBean.clreplaced);
    context.registerBeanDefinition("postProcessor", processorDefinition);
    context.registerBeanDefinition("target", targetDefinition);
    context.refresh();
    ScheduledTaskHolder postProcessor = context.getBean("postProcessor", ScheduledTaskHolder.clreplaced);
    replacedertEquals(1, postProcessor.getScheduledTasks().size());
    Object target = context.getBean("target");
    ScheduledTaskRegistrar registrar = (ScheduledTaskRegistrar) new DirectFieldAccessor(postProcessor).getPropertyValue("registrar");
    @SuppressWarnings("unchecked")
    List<CronTask> cronTasks = (List<CronTask>) new DirectFieldAccessor(registrar).getPropertyValue("cronTasks");
    replacedertEquals(1, cronTasks.size());
    CronTask task = cronTasks.get(0);
    ScheduledMethodRunnable runnable = (ScheduledMethodRunnable) task.getRunnable();
    Object targetObject = runnable.getTarget();
    Method targetMethod = runnable.getMethod();
    replacedertEquals(target, targetObject);
    replacedertEquals("cron", targetMethod.getName());
    replacedertEquals("*/7 * * * * ?", task.getExpression());
}

@Test
public void nonVoidReturnType() {
    BeanDefinition processorDefinition = new RootBeanDefinition(ScheduledAnnotationBeanPostProcessor.clreplaced);
    BeanDefinition targetDefinition = new RootBeanDefinition(NonVoidReturnTypeTestBean.clreplaced);
    context.registerBeanDefinition("postProcessor", processorDefinition);
    context.registerBeanDefinition("target", targetDefinition);
    context.refresh();
    ScheduledTaskHolder postProcessor = context.getBean("postProcessor", ScheduledTaskHolder.clreplaced);
    replacedertEquals(1, postProcessor.getScheduledTasks().size());
    Object target = context.getBean("target");
    ScheduledTaskRegistrar registrar = (ScheduledTaskRegistrar) new DirectFieldAccessor(postProcessor).getPropertyValue("registrar");
    @SuppressWarnings("unchecked")
    List<CronTask> cronTasks = (List<CronTask>) new DirectFieldAccessor(registrar).getPropertyValue("cronTasks");
    replacedertEquals(1, cronTasks.size());
    CronTask task = cronTasks.get(0);
    ScheduledMethodRunnable runnable = (ScheduledMethodRunnable) task.getRunnable();
    Object targetObject = runnable.getTarget();
    Method targetMethod = runnable.getMethod();
    replacedertEquals(target, targetObject);
    replacedertEquals("cron", targetMethod.getName());
    replacedertEquals("0 0 9-17 * * MON-FRI", task.getExpression());
}

@Test
public void metaAnnotationWithFixedRate() {
    BeanDefinition processorDefinition = new RootBeanDefinition(ScheduledAnnotationBeanPostProcessor.clreplaced);
    BeanDefinition targetDefinition = new RootBeanDefinition(MetaAnnotationFixedRateTestBean.clreplaced);
    context.registerBeanDefinition("postProcessor", processorDefinition);
    context.registerBeanDefinition("target", targetDefinition);
    context.refresh();
    ScheduledTaskHolder postProcessor = context.getBean("postProcessor", ScheduledTaskHolder.clreplaced);
    replacedertEquals(1, postProcessor.getScheduledTasks().size());
    Object target = context.getBean("target");
    ScheduledTaskRegistrar registrar = (ScheduledTaskRegistrar) new DirectFieldAccessor(postProcessor).getPropertyValue("registrar");
    @SuppressWarnings("unchecked")
    List<IntervalTask> fixedRateTasks = (List<IntervalTask>) new DirectFieldAccessor(registrar).getPropertyValue("fixedRateTasks");
    replacedertEquals(1, fixedRateTasks.size());
    IntervalTask task = fixedRateTasks.get(0);
    ScheduledMethodRunnable runnable = (ScheduledMethodRunnable) task.getRunnable();
    Object targetObject = runnable.getTarget();
    Method targetMethod = runnable.getMethod();
    replacedertEquals(target, targetObject);
    replacedertEquals("checkForUpdates", targetMethod.getName());
    replacedertEquals(5000L, task.getInterval());
}

@Test
public void cronTask() {
    BeanDefinition processorDefinition = new RootBeanDefinition(ScheduledAnnotationBeanPostProcessor.clreplaced);
    BeanDefinition targetDefinition = new RootBeanDefinition(CronTestBean.clreplaced);
    context.registerBeanDefinition("postProcessor", processorDefinition);
    context.registerBeanDefinition("target", targetDefinition);
    context.refresh();
    ScheduledTaskHolder postProcessor = context.getBean("postProcessor", ScheduledTaskHolder.clreplaced);
    replacedertThat(postProcessor.getScheduledTasks().size()).isEqualTo(1);
    Object target = context.getBean("target");
    ScheduledTaskRegistrar registrar = (ScheduledTaskRegistrar) new DirectFieldAccessor(postProcessor).getPropertyValue("registrar");
    @SuppressWarnings("unchecked")
    List<CronTask> cronTasks = (List<CronTask>) new DirectFieldAccessor(registrar).getPropertyValue("cronTasks");
    replacedertThat(cronTasks.size()).isEqualTo(1);
    CronTask task = cronTasks.get(0);
    ScheduledMethodRunnable runnable = (ScheduledMethodRunnable) task.getRunnable();
    Object targetObject = runnable.getTarget();
    Method targetMethod = runnable.getMethod();
    replacedertThat(targetObject).isEqualTo(target);
    replacedertThat(targetMethod.getName()).isEqualTo("cron");
    replacedertThat(task.getExpression()).isEqualTo("*/7 * * * * ?");
}

@Test
public void metaAnnotationWithCronExpression() {
    BeanDefinition processorDefinition = new RootBeanDefinition(ScheduledAnnotationBeanPostProcessor.clreplaced);
    BeanDefinition targetDefinition = new RootBeanDefinition(MetaAnnotationCronTestBean.clreplaced);
    context.registerBeanDefinition("postProcessor", processorDefinition);
    context.registerBeanDefinition("target", targetDefinition);
    context.refresh();
    ScheduledTaskHolder postProcessor = context.getBean("postProcessor", ScheduledTaskHolder.clreplaced);
    replacedertThat(postProcessor.getScheduledTasks().size()).isEqualTo(1);
    Object target = context.getBean("target");
    ScheduledTaskRegistrar registrar = (ScheduledTaskRegistrar) new DirectFieldAccessor(postProcessor).getPropertyValue("registrar");
    @SuppressWarnings("unchecked")
    List<CronTask> cronTasks = (List<CronTask>) new DirectFieldAccessor(registrar).getPropertyValue("cronTasks");
    replacedertThat(cronTasks.size()).isEqualTo(1);
    CronTask task = cronTasks.get(0);
    ScheduledMethodRunnable runnable = (ScheduledMethodRunnable) task.getRunnable();
    Object targetObject = runnable.getTarget();
    Method targetMethod = runnable.getMethod();
    replacedertThat(targetObject).isEqualTo(target);
    replacedertThat(targetMethod.getName()).isEqualTo("generateReport");
    replacedertThat(task.getExpression()).isEqualTo("0 0 * * * ?");
}

@Test
public void metaAnnotationWithFixedRate() {
    BeanDefinition processorDefinition = new RootBeanDefinition(ScheduledAnnotationBeanPostProcessor.clreplaced);
    BeanDefinition targetDefinition = new RootBeanDefinition(MetaAnnotationFixedRateTestBean.clreplaced);
    context.registerBeanDefinition("postProcessor", processorDefinition);
    context.registerBeanDefinition("target", targetDefinition);
    context.refresh();
    ScheduledTaskHolder postProcessor = context.getBean("postProcessor", ScheduledTaskHolder.clreplaced);
    replacedertThat(postProcessor.getScheduledTasks().size()).isEqualTo(1);
    Object target = context.getBean("target");
    ScheduledTaskRegistrar registrar = (ScheduledTaskRegistrar) new DirectFieldAccessor(postProcessor).getPropertyValue("registrar");
    @SuppressWarnings("unchecked")
    List<IntervalTask> fixedRateTasks = (List<IntervalTask>) new DirectFieldAccessor(registrar).getPropertyValue("fixedRateTasks");
    replacedertThat(fixedRateTasks.size()).isEqualTo(1);
    IntervalTask task = fixedRateTasks.get(0);
    ScheduledMethodRunnable runnable = (ScheduledMethodRunnable) task.getRunnable();
    Object targetObject = runnable.getTarget();
    Method targetMethod = runnable.getMethod();
    replacedertThat(targetObject).isEqualTo(target);
    replacedertThat(targetMethod.getName()).isEqualTo("checkForUpdates");
    replacedertThat(task.getInterval()).isEqualTo(5000L);
}

@Test
public void nonVoidReturnType() {
    BeanDefinition processorDefinition = new RootBeanDefinition(ScheduledAnnotationBeanPostProcessor.clreplaced);
    BeanDefinition targetDefinition = new RootBeanDefinition(NonVoidReturnTypeTestBean.clreplaced);
    context.registerBeanDefinition("postProcessor", processorDefinition);
    context.registerBeanDefinition("target", targetDefinition);
    context.refresh();
    ScheduledTaskHolder postProcessor = context.getBean("postProcessor", ScheduledTaskHolder.clreplaced);
    replacedertThat(postProcessor.getScheduledTasks().size()).isEqualTo(1);
    Object target = context.getBean("target");
    ScheduledTaskRegistrar registrar = (ScheduledTaskRegistrar) new DirectFieldAccessor(postProcessor).getPropertyValue("registrar");
    @SuppressWarnings("unchecked")
    List<CronTask> cronTasks = (List<CronTask>) new DirectFieldAccessor(registrar).getPropertyValue("cronTasks");
    replacedertThat(cronTasks.size()).isEqualTo(1);
    CronTask task = cronTasks.get(0);
    ScheduledMethodRunnable runnable = (ScheduledMethodRunnable) task.getRunnable();
    Object targetObject = runnable.getTarget();
    Method targetMethod = runnable.getMethod();
    replacedertThat(targetObject).isEqualTo(target);
    replacedertThat(targetMethod.getName()).isEqualTo("cron");
    replacedertThat(task.getExpression()).isEqualTo("0 0 9-17 * * MON-FRI");
}

private void severalFixedRates(StaticApplicationContext context, BeanDefinition processorDefinition, BeanDefinition targetDefinition) {
    context.registerBeanDefinition("postProcessor", processorDefinition);
    context.registerBeanDefinition("target", targetDefinition);
    context.refresh();
    ScheduledTaskHolder postProcessor = context.getBean("postProcessor", ScheduledTaskHolder.clreplaced);
    replacedertEquals(2, postProcessor.getScheduledTasks().size());
    Object target = context.getBean("target");
    ScheduledTaskRegistrar registrar = (ScheduledTaskRegistrar) new DirectFieldAccessor(postProcessor).getPropertyValue("registrar");
    @SuppressWarnings("unchecked")
    List<IntervalTask> fixedRateTasks = (List<IntervalTask>) new DirectFieldAccessor(registrar).getPropertyValue("fixedRateTasks");
    replacedertEquals(2, fixedRateTasks.size());
    IntervalTask task1 = fixedRateTasks.get(0);
    ScheduledMethodRunnable runnable1 = (ScheduledMethodRunnable) task1.getRunnable();
    Object targetObject = runnable1.getTarget();
    Method targetMethod = runnable1.getMethod();
    replacedertEquals(target, targetObject);
    replacedertEquals("fixedRate", targetMethod.getName());
    replacedertEquals(0, task1.getInitialDelay());
    replacedertEquals(4000L, task1.getInterval());
    IntervalTask task2 = fixedRateTasks.get(1);
    ScheduledMethodRunnable runnable2 = (ScheduledMethodRunnable) task2.getRunnable();
    targetObject = runnable2.getTarget();
    targetMethod = runnable2.getMethod();
    replacedertEquals(target, targetObject);
    replacedertEquals("fixedRate", targetMethod.getName());
    replacedertEquals(2000L, task2.getInitialDelay());
    replacedertEquals(4000L, task2.getInterval());
}

@Test
public void fixedDelayTask() {
    BeanDefinition processorDefinition = new RootBeanDefinition(ScheduledAnnotationBeanPostProcessor.clreplaced);
    BeanDefinition targetDefinition = new RootBeanDefinition(FixedDelayTestBean.clreplaced);
    context.registerBeanDefinition("postProcessor", processorDefinition);
    context.registerBeanDefinition("target", targetDefinition);
    context.refresh();
    ScheduledTaskHolder postProcessor = context.getBean("postProcessor", ScheduledTaskHolder.clreplaced);
    replacedertEquals(1, postProcessor.getScheduledTasks().size());
    Object target = context.getBean("target");
    ScheduledTaskRegistrar registrar = (ScheduledTaskRegistrar) new DirectFieldAccessor(postProcessor).getPropertyValue("registrar");
    @SuppressWarnings("unchecked")
    List<IntervalTask> fixedDelayTasks = (List<IntervalTask>) new DirectFieldAccessor(registrar).getPropertyValue("fixedDelayTasks");
    replacedertEquals(1, fixedDelayTasks.size());
    IntervalTask task = fixedDelayTasks.get(0);
    ScheduledMethodRunnable runnable = (ScheduledMethodRunnable) task.getRunnable();
    Object targetObject = runnable.getTarget();
    Method targetMethod = runnable.getMethod();
    replacedertEquals(target, targetObject);
    replacedertEquals("fixedDelay", targetMethod.getName());
    replacedertEquals(0L, task.getInitialDelay());
    replacedertEquals(5000L, task.getInterval());
}

@Test
public void composedAnnotationWithInitialDelayAndFixedRate() {
    BeanDefinition processorDefinition = new RootBeanDefinition(ScheduledAnnotationBeanPostProcessor.clreplaced);
    BeanDefinition targetDefinition = new RootBeanDefinition(ComposedAnnotationFixedRateTestBean.clreplaced);
    context.registerBeanDefinition("postProcessor", processorDefinition);
    context.registerBeanDefinition("target", targetDefinition);
    context.refresh();
    ScheduledTaskHolder postProcessor = context.getBean("postProcessor", ScheduledTaskHolder.clreplaced);
    replacedertEquals(1, postProcessor.getScheduledTasks().size());
    Object target = context.getBean("target");
    ScheduledTaskRegistrar registrar = (ScheduledTaskRegistrar) new DirectFieldAccessor(postProcessor).getPropertyValue("registrar");
    @SuppressWarnings("unchecked")
    List<IntervalTask> fixedRateTasks = (List<IntervalTask>) new DirectFieldAccessor(registrar).getPropertyValue("fixedRateTasks");
    replacedertEquals(1, fixedRateTasks.size());
    IntervalTask task = fixedRateTasks.get(0);
    ScheduledMethodRunnable runnable = (ScheduledMethodRunnable) task.getRunnable();
    Object targetObject = runnable.getTarget();
    Method targetMethod = runnable.getMethod();
    replacedertEquals(target, targetObject);
    replacedertEquals("checkForUpdates", targetMethod.getName());
    replacedertEquals(5000L, task.getInterval());
    replacedertEquals(1000L, task.getInitialDelay());
}

@Test
public void fixedRateTask() {
    BeanDefinition processorDefinition = new RootBeanDefinition(ScheduledAnnotationBeanPostProcessor.clreplaced);
    BeanDefinition targetDefinition = new RootBeanDefinition(FixedRateTestBean.clreplaced);
    context.registerBeanDefinition("postProcessor", processorDefinition);
    context.registerBeanDefinition("target", targetDefinition);
    context.refresh();
    ScheduledTaskHolder postProcessor = context.getBean("postProcessor", ScheduledTaskHolder.clreplaced);
    replacedertEquals(1, postProcessor.getScheduledTasks().size());
    Object target = context.getBean("target");
    ScheduledTaskRegistrar registrar = (ScheduledTaskRegistrar) new DirectFieldAccessor(postProcessor).getPropertyValue("registrar");
    @SuppressWarnings("unchecked")
    List<IntervalTask> fixedRateTasks = (List<IntervalTask>) new DirectFieldAccessor(registrar).getPropertyValue("fixedRateTasks");
    replacedertEquals(1, fixedRateTasks.size());
    IntervalTask task = fixedRateTasks.get(0);
    ScheduledMethodRunnable runnable = (ScheduledMethodRunnable) task.getRunnable();
    Object targetObject = runnable.getTarget();
    Method targetMethod = runnable.getMethod();
    replacedertEquals(target, targetObject);
    replacedertEquals("fixedRate", targetMethod.getName());
    replacedertEquals(0L, task.getInitialDelay());
    replacedertEquals(3000L, task.getInterval());
}

@Test
public void fixedRateTaskWithInitialDelay() {
    BeanDefinition processorDefinition = new RootBeanDefinition(ScheduledAnnotationBeanPostProcessor.clreplaced);
    BeanDefinition targetDefinition = new RootBeanDefinition(FixedRateWithInitialDelayTestBean.clreplaced);
    context.registerBeanDefinition("postProcessor", processorDefinition);
    context.registerBeanDefinition("target", targetDefinition);
    context.refresh();
    ScheduledTaskHolder postProcessor = context.getBean("postProcessor", ScheduledTaskHolder.clreplaced);
    replacedertEquals(1, postProcessor.getScheduledTasks().size());
    Object target = context.getBean("target");
    ScheduledTaskRegistrar registrar = (ScheduledTaskRegistrar) new DirectFieldAccessor(postProcessor).getPropertyValue("registrar");
    @SuppressWarnings("unchecked")
    List<IntervalTask> fixedRateTasks = (List<IntervalTask>) new DirectFieldAccessor(registrar).getPropertyValue("fixedRateTasks");
    replacedertEquals(1, fixedRateTasks.size());
    IntervalTask task = fixedRateTasks.get(0);
    ScheduledMethodRunnable runnable = (ScheduledMethodRunnable) task.getRunnable();
    Object targetObject = runnable.getTarget();
    Method targetMethod = runnable.getMethod();
    replacedertEquals(target, targetObject);
    replacedertEquals("fixedRate", targetMethod.getName());
    replacedertEquals(1000L, task.getInitialDelay());
    replacedertEquals(3000L, task.getInterval());
}

@Test
public void cronTaskWithScopedProxy() {
    BeanDefinition processorDefinition = new RootBeanDefinition(ScheduledAnnotationBeanPostProcessor.clreplaced);
    context.registerBeanDefinition("postProcessor", processorDefinition);
    new AnnotatedBeanDefinitionReader(context).register(ProxiedCronTestBean.clreplaced, ProxiedCronTestBeanDependent.clreplaced);
    context.refresh();
    ScheduledTaskHolder postProcessor = context.getBean("postProcessor", ScheduledTaskHolder.clreplaced);
    replacedertEquals(1, postProcessor.getScheduledTasks().size());
    ScheduledTaskRegistrar registrar = (ScheduledTaskRegistrar) new DirectFieldAccessor(postProcessor).getPropertyValue("registrar");
    @SuppressWarnings("unchecked")
    List<CronTask> cronTasks = (List<CronTask>) new DirectFieldAccessor(registrar).getPropertyValue("cronTasks");
    replacedertEquals(1, cronTasks.size());
    CronTask task = cronTasks.get(0);
    ScheduledMethodRunnable runnable = (ScheduledMethodRunnable) task.getRunnable();
    Object targetObject = runnable.getTarget();
    Method targetMethod = runnable.getMethod();
    replacedertEquals(context.getBean(ScopedProxyUtils.getTargetBeanName("target")), targetObject);
    replacedertEquals("cron", targetMethod.getName());
    replacedertEquals("*/7 * * * * ?", task.getExpression());
}

@Test
public void fixedDelayTask() {
    BeanDefinition processorDefinition = new RootBeanDefinition(ScheduledAnnotationBeanPostProcessor.clreplaced);
    BeanDefinition targetDefinition = new RootBeanDefinition(FixedDelayTestBean.clreplaced);
    context.registerBeanDefinition("postProcessor", processorDefinition);
    context.registerBeanDefinition("target", targetDefinition);
    context.refresh();
    ScheduledTaskHolder postProcessor = context.getBean("postProcessor", ScheduledTaskHolder.clreplaced);
    replacedertThat(postProcessor.getScheduledTasks().size()).isEqualTo(1);
    Object target = context.getBean("target");
    ScheduledTaskRegistrar registrar = (ScheduledTaskRegistrar) new DirectFieldAccessor(postProcessor).getPropertyValue("registrar");
    @SuppressWarnings("unchecked")
    List<IntervalTask> fixedDelayTasks = (List<IntervalTask>) new DirectFieldAccessor(registrar).getPropertyValue("fixedDelayTasks");
    replacedertThat(fixedDelayTasks.size()).isEqualTo(1);
    IntervalTask task = fixedDelayTasks.get(0);
    ScheduledMethodRunnable runnable = (ScheduledMethodRunnable) task.getRunnable();
    Object targetObject = runnable.getTarget();
    Method targetMethod = runnable.getMethod();
    replacedertThat(targetObject).isEqualTo(target);
    replacedertThat(targetMethod.getName()).isEqualTo("fixedDelay");
    replacedertThat(task.getInitialDelay()).isEqualTo(0L);
    replacedertThat(task.getInterval()).isEqualTo(5000L);
}

@Test
public void fixedRateTaskWithInitialDelay() {
    BeanDefinition processorDefinition = new RootBeanDefinition(ScheduledAnnotationBeanPostProcessor.clreplaced);
    BeanDefinition targetDefinition = new RootBeanDefinition(FixedRateWithInitialDelayTestBean.clreplaced);
    context.registerBeanDefinition("postProcessor", processorDefinition);
    context.registerBeanDefinition("target", targetDefinition);
    context.refresh();
    ScheduledTaskHolder postProcessor = context.getBean("postProcessor", ScheduledTaskHolder.clreplaced);
    replacedertThat(postProcessor.getScheduledTasks().size()).isEqualTo(1);
    Object target = context.getBean("target");
    ScheduledTaskRegistrar registrar = (ScheduledTaskRegistrar) new DirectFieldAccessor(postProcessor).getPropertyValue("registrar");
    @SuppressWarnings("unchecked")
    List<IntervalTask> fixedRateTasks = (List<IntervalTask>) new DirectFieldAccessor(registrar).getPropertyValue("fixedRateTasks");
    replacedertThat(fixedRateTasks.size()).isEqualTo(1);
    IntervalTask task = fixedRateTasks.get(0);
    ScheduledMethodRunnable runnable = (ScheduledMethodRunnable) task.getRunnable();
    Object targetObject = runnable.getTarget();
    Method targetMethod = runnable.getMethod();
    replacedertThat(targetObject).isEqualTo(target);
    replacedertThat(targetMethod.getName()).isEqualTo("fixedRate");
    replacedertThat(task.getInitialDelay()).isEqualTo(1000L);
    replacedertThat(task.getInterval()).isEqualTo(3000L);
}

@Test
public void fixedRateTask() {
    BeanDefinition processorDefinition = new RootBeanDefinition(ScheduledAnnotationBeanPostProcessor.clreplaced);
    BeanDefinition targetDefinition = new RootBeanDefinition(FixedRateTestBean.clreplaced);
    context.registerBeanDefinition("postProcessor", processorDefinition);
    context.registerBeanDefinition("target", targetDefinition);
    context.refresh();
    ScheduledTaskHolder postProcessor = context.getBean("postProcessor", ScheduledTaskHolder.clreplaced);
    replacedertThat(postProcessor.getScheduledTasks().size()).isEqualTo(1);
    Object target = context.getBean("target");
    ScheduledTaskRegistrar registrar = (ScheduledTaskRegistrar) new DirectFieldAccessor(postProcessor).getPropertyValue("registrar");
    @SuppressWarnings("unchecked")
    List<IntervalTask> fixedRateTasks = (List<IntervalTask>) new DirectFieldAccessor(registrar).getPropertyValue("fixedRateTasks");
    replacedertThat(fixedRateTasks.size()).isEqualTo(1);
    IntervalTask task = fixedRateTasks.get(0);
    ScheduledMethodRunnable runnable = (ScheduledMethodRunnable) task.getRunnable();
    Object targetObject = runnable.getTarget();
    Method targetMethod = runnable.getMethod();
    replacedertThat(targetObject).isEqualTo(target);
    replacedertThat(targetMethod.getName()).isEqualTo("fixedRate");
    replacedertThat(task.getInitialDelay()).isEqualTo(0L);
    replacedertThat(task.getInterval()).isEqualTo(3000L);
}

@Test
public void cronTaskWithScopedProxy() {
    BeanDefinition processorDefinition = new RootBeanDefinition(ScheduledAnnotationBeanPostProcessor.clreplaced);
    context.registerBeanDefinition("postProcessor", processorDefinition);
    new AnnotatedBeanDefinitionReader(context).register(ProxiedCronTestBean.clreplaced, ProxiedCronTestBeanDependent.clreplaced);
    context.refresh();
    ScheduledTaskHolder postProcessor = context.getBean("postProcessor", ScheduledTaskHolder.clreplaced);
    replacedertThat(postProcessor.getScheduledTasks().size()).isEqualTo(1);
    ScheduledTaskRegistrar registrar = (ScheduledTaskRegistrar) new DirectFieldAccessor(postProcessor).getPropertyValue("registrar");
    @SuppressWarnings("unchecked")
    List<CronTask> cronTasks = (List<CronTask>) new DirectFieldAccessor(registrar).getPropertyValue("cronTasks");
    replacedertThat(cronTasks.size()).isEqualTo(1);
    CronTask task = cronTasks.get(0);
    ScheduledMethodRunnable runnable = (ScheduledMethodRunnable) task.getRunnable();
    Object targetObject = runnable.getTarget();
    Method targetMethod = runnable.getMethod();
    replacedertThat(targetObject).isEqualTo(context.getBean(ScopedProxyUtils.getTargetBeanName("target")));
    replacedertThat(targetMethod.getName()).isEqualTo("cron");
    replacedertThat(task.getExpression()).isEqualTo("*/7 * * * * ?");
}

private void severalFixedRates(StaticApplicationContext context, BeanDefinition processorDefinition, BeanDefinition targetDefinition) {
    context.registerBeanDefinition("postProcessor", processorDefinition);
    context.registerBeanDefinition("target", targetDefinition);
    context.refresh();
    ScheduledTaskHolder postProcessor = context.getBean("postProcessor", ScheduledTaskHolder.clreplaced);
    replacedertThat(postProcessor.getScheduledTasks().size()).isEqualTo(2);
    Object target = context.getBean("target");
    ScheduledTaskRegistrar registrar = (ScheduledTaskRegistrar) new DirectFieldAccessor(postProcessor).getPropertyValue("registrar");
    @SuppressWarnings("unchecked")
    List<IntervalTask> fixedRateTasks = (List<IntervalTask>) new DirectFieldAccessor(registrar).getPropertyValue("fixedRateTasks");
    replacedertThat(fixedRateTasks.size()).isEqualTo(2);
    IntervalTask task1 = fixedRateTasks.get(0);
    ScheduledMethodRunnable runnable1 = (ScheduledMethodRunnable) task1.getRunnable();
    Object targetObject = runnable1.getTarget();
    Method targetMethod = runnable1.getMethod();
    replacedertThat(targetObject).isEqualTo(target);
    replacedertThat(targetMethod.getName()).isEqualTo("fixedRate");
    replacedertThat(task1.getInitialDelay()).isEqualTo(0);
    replacedertThat(task1.getInterval()).isEqualTo(4000L);
    IntervalTask task2 = fixedRateTasks.get(1);
    ScheduledMethodRunnable runnable2 = (ScheduledMethodRunnable) task2.getRunnable();
    targetObject = runnable2.getTarget();
    targetMethod = runnable2.getMethod();
    replacedertThat(targetObject).isEqualTo(target);
    replacedertThat(targetMethod.getName()).isEqualTo("fixedRate");
    replacedertThat(task2.getInitialDelay()).isEqualTo(2000L);
    replacedertThat(task2.getInterval()).isEqualTo(4000L);
}

@Test
public void composedAnnotationWithInitialDelayAndFixedRate() {
    BeanDefinition processorDefinition = new RootBeanDefinition(ScheduledAnnotationBeanPostProcessor.clreplaced);
    BeanDefinition targetDefinition = new RootBeanDefinition(ComposedAnnotationFixedRateTestBean.clreplaced);
    context.registerBeanDefinition("postProcessor", processorDefinition);
    context.registerBeanDefinition("target", targetDefinition);
    context.refresh();
    ScheduledTaskHolder postProcessor = context.getBean("postProcessor", ScheduledTaskHolder.clreplaced);
    replacedertThat(postProcessor.getScheduledTasks().size()).isEqualTo(1);
    Object target = context.getBean("target");
    ScheduledTaskRegistrar registrar = (ScheduledTaskRegistrar) new DirectFieldAccessor(postProcessor).getPropertyValue("registrar");
    @SuppressWarnings("unchecked")
    List<IntervalTask> fixedRateTasks = (List<IntervalTask>) new DirectFieldAccessor(registrar).getPropertyValue("fixedRateTasks");
    replacedertThat(fixedRateTasks.size()).isEqualTo(1);
    IntervalTask task = fixedRateTasks.get(0);
    ScheduledMethodRunnable runnable = (ScheduledMethodRunnable) task.getRunnable();
    Object targetObject = runnable.getTarget();
    Method targetMethod = runnable.getMethod();
    replacedertThat(targetObject).isEqualTo(target);
    replacedertThat(targetMethod.getName()).isEqualTo("checkForUpdates");
    replacedertThat(task.getInterval()).isEqualTo(5000L);
    replacedertThat(task.getInitialDelay()).isEqualTo(1000L);
}

@Test
public void propertyPlaceholderForMetaAnnotation() {
    String businessHoursCronExpression = "0 0 9-17 * * MON-FRI";
    BeanDefinition processorDefinition = new RootBeanDefinition(ScheduledAnnotationBeanPostProcessor.clreplaced);
    BeanDefinition placeholderDefinition = new RootBeanDefinition(PropertyPlaceholderConfigurer.clreplaced);
    Properties properties = new Properties();
    properties.setProperty("schedules.businessHours", businessHoursCronExpression);
    placeholderDefinition.getPropertyValues().addPropertyValue("properties", properties);
    BeanDefinition targetDefinition = new RootBeanDefinition(PropertyPlaceholderMetaAnnotationTestBean.clreplaced);
    context.registerBeanDefinition("postProcessor", processorDefinition);
    context.registerBeanDefinition("placeholder", placeholderDefinition);
    context.registerBeanDefinition("target", targetDefinition);
    context.refresh();
    Object postProcessor = context.getBean("postProcessor");
    Object target = context.getBean("target");
    ScheduledTaskRegistrar registrar = (ScheduledTaskRegistrar) new DirectFieldAccessor(postProcessor).getPropertyValue("registrar");
    @SuppressWarnings("unchecked")
    List<CronTask> cronTasks = (List<CronTask>) new DirectFieldAccessor(registrar).getPropertyValue("cronTasks");
    replacedertEquals(1, cronTasks.size());
    CronTask task = cronTasks.get(0);
    ScheduledMethodRunnable runnable = (ScheduledMethodRunnable) task.getRunnable();
    Object targetObject = runnable.getTarget();
    Method targetMethod = runnable.getMethod();
    replacedertEquals(target, targetObject);
    replacedertEquals("y", targetMethod.getName());
    replacedertEquals(businessHoursCronExpression, task.getExpression());
}

@Test
public void propertyPlaceholderWithCron() {
    String businessHoursCronExpression = "0 0 9-17 * * MON-FRI";
    BeanDefinition processorDefinition = new RootBeanDefinition(ScheduledAnnotationBeanPostProcessor.clreplaced);
    BeanDefinition placeholderDefinition = new RootBeanDefinition(PropertyPlaceholderConfigurer.clreplaced);
    Properties properties = new Properties();
    properties.setProperty("schedules.businessHours", businessHoursCronExpression);
    placeholderDefinition.getPropertyValues().addPropertyValue("properties", properties);
    BeanDefinition targetDefinition = new RootBeanDefinition(PropertyPlaceholderWithCronTestBean.clreplaced);
    context.registerBeanDefinition("placeholder", placeholderDefinition);
    context.registerBeanDefinition("postProcessor", processorDefinition);
    context.registerBeanDefinition("target", targetDefinition);
    context.refresh();
    Object postProcessor = context.getBean("postProcessor");
    Object target = context.getBean("target");
    ScheduledTaskRegistrar registrar = (ScheduledTaskRegistrar) new DirectFieldAccessor(postProcessor).getPropertyValue("registrar");
    @SuppressWarnings("unchecked")
    List<CronTask> cronTasks = (List<CronTask>) new DirectFieldAccessor(registrar).getPropertyValue("cronTasks");
    replacedertEquals(1, cronTasks.size());
    CronTask task = cronTasks.get(0);
    ScheduledMethodRunnable runnable = (ScheduledMethodRunnable) task.getRunnable();
    Object targetObject = runnable.getTarget();
    Method targetMethod = runnable.getMethod();
    replacedertEquals(target, targetObject);
    replacedertEquals("x", targetMethod.getName());
    replacedertEquals(businessHoursCronExpression, task.getExpression());
}

@Test
public void propertyPlaceholderWithFixedDelay() {
    BeanDefinition processorDefinition = new RootBeanDefinition(ScheduledAnnotationBeanPostProcessor.clreplaced);
    BeanDefinition placeholderDefinition = new RootBeanDefinition(PropertyPlaceholderConfigurer.clreplaced);
    Properties properties = new Properties();
    properties.setProperty("fixedDelay", "5000");
    properties.setProperty("initialDelay", "1000");
    placeholderDefinition.getPropertyValues().addPropertyValue("properties", properties);
    BeanDefinition targetDefinition = new RootBeanDefinition(PropertyPlaceholderWithFixedDelayTestBean.clreplaced);
    context.registerBeanDefinition("placeholder", placeholderDefinition);
    context.registerBeanDefinition("postProcessor", processorDefinition);
    context.registerBeanDefinition("target", targetDefinition);
    context.refresh();
    Object postProcessor = context.getBean("postProcessor");
    Object target = context.getBean("target");
    ScheduledTaskRegistrar registrar = (ScheduledTaskRegistrar) new DirectFieldAccessor(postProcessor).getPropertyValue("registrar");
    @SuppressWarnings("unchecked")
    List<IntervalTask> fixedDelayTasks = (List<IntervalTask>) new DirectFieldAccessor(registrar).getPropertyValue("fixedDelayTasks");
    replacedertEquals(1, fixedDelayTasks.size());
    IntervalTask task = fixedDelayTasks.get(0);
    ScheduledMethodRunnable runnable = (ScheduledMethodRunnable) task.getRunnable();
    Object targetObject = runnable.getTarget();
    Method targetMethod = runnable.getMethod();
    replacedertEquals(target, targetObject);
    replacedertEquals("fixedDelay", targetMethod.getName());
    replacedertEquals(1000L, task.getInitialDelay());
    replacedertEquals(5000L, task.getInterval());
}

@Test
public void propertyPlaceholderWithFixedRate() {
    BeanDefinition processorDefinition = new RootBeanDefinition(ScheduledAnnotationBeanPostProcessor.clreplaced);
    BeanDefinition placeholderDefinition = new RootBeanDefinition(PropertyPlaceholderConfigurer.clreplaced);
    Properties properties = new Properties();
    properties.setProperty("fixedRate", "3000");
    properties.setProperty("initialDelay", "1000");
    placeholderDefinition.getPropertyValues().addPropertyValue("properties", properties);
    BeanDefinition targetDefinition = new RootBeanDefinition(PropertyPlaceholderWithFixedRateTestBean.clreplaced);
    context.registerBeanDefinition("placeholder", placeholderDefinition);
    context.registerBeanDefinition("postProcessor", processorDefinition);
    context.registerBeanDefinition("target", targetDefinition);
    context.refresh();
    Object postProcessor = context.getBean("postProcessor");
    Object target = context.getBean("target");
    ScheduledTaskRegistrar registrar = (ScheduledTaskRegistrar) new DirectFieldAccessor(postProcessor).getPropertyValue("registrar");
    @SuppressWarnings("unchecked")
    List<IntervalTask> fixedRateTasks = (List<IntervalTask>) new DirectFieldAccessor(registrar).getPropertyValue("fixedRateTasks");
    replacedertEquals(1, fixedRateTasks.size());
    IntervalTask task = fixedRateTasks.get(0);
    ScheduledMethodRunnable runnable = (ScheduledMethodRunnable) task.getRunnable();
    Object targetObject = runnable.getTarget();
    Method targetMethod = runnable.getMethod();
    replacedertEquals(target, targetObject);
    replacedertEquals("fixedRate", targetMethod.getName());
    replacedertEquals(1000L, task.getInitialDelay());
    replacedertEquals(3000L, task.getInterval());
}

@Test
public void propertyPlaceholderForMetaAnnotation() {
    String businessHoursCronExpression = "0 0 9-17 * * MON-FRI";
    BeanDefinition processorDefinition = new RootBeanDefinition(ScheduledAnnotationBeanPostProcessor.clreplaced);
    BeanDefinition placeholderDefinition = new RootBeanDefinition(PropertySourcesPlaceholderConfigurer.clreplaced);
    Properties properties = new Properties();
    properties.setProperty("schedules.businessHours", businessHoursCronExpression);
    placeholderDefinition.getPropertyValues().addPropertyValue("properties", properties);
    BeanDefinition targetDefinition = new RootBeanDefinition(PropertyPlaceholderMetaAnnotationTestBean.clreplaced);
    context.registerBeanDefinition("postProcessor", processorDefinition);
    context.registerBeanDefinition("placeholder", placeholderDefinition);
    context.registerBeanDefinition("target", targetDefinition);
    context.refresh();
    ScheduledTaskHolder postProcessor = context.getBean("postProcessor", ScheduledTaskHolder.clreplaced);
    replacedertEquals(1, postProcessor.getScheduledTasks().size());
    Object target = context.getBean("target");
    ScheduledTaskRegistrar registrar = (ScheduledTaskRegistrar) new DirectFieldAccessor(postProcessor).getPropertyValue("registrar");
    @SuppressWarnings("unchecked")
    List<CronTask> cronTasks = (List<CronTask>) new DirectFieldAccessor(registrar).getPropertyValue("cronTasks");
    replacedertEquals(1, cronTasks.size());
    CronTask task = cronTasks.get(0);
    ScheduledMethodRunnable runnable = (ScheduledMethodRunnable) task.getRunnable();
    Object targetObject = runnable.getTarget();
    Method targetMethod = runnable.getMethod();
    replacedertEquals(target, targetObject);
    replacedertEquals("y", targetMethod.getName());
    replacedertEquals(businessHoursCronExpression, task.getExpression());
}

@Test
public void expressionWithCron() {
    String businessHoursCronExpression = "0 0 9-17 * * MON-FRI";
    BeanDefinition processorDefinition = new RootBeanDefinition(ScheduledAnnotationBeanPostProcessor.clreplaced);
    BeanDefinition targetDefinition = new RootBeanDefinition(ExpressionWithCronTestBean.clreplaced);
    context.registerBeanDefinition("postProcessor", processorDefinition);
    context.registerBeanDefinition("target", targetDefinition);
    Map<String, String> schedules = new HashMap<>();
    schedules.put("businessHours", businessHoursCronExpression);
    context.getBeanFactory().registerSingleton("schedules", schedules);
    context.refresh();
    ScheduledTaskHolder postProcessor = context.getBean("postProcessor", ScheduledTaskHolder.clreplaced);
    replacedertEquals(1, postProcessor.getScheduledTasks().size());
    Object target = context.getBean("target");
    ScheduledTaskRegistrar registrar = (ScheduledTaskRegistrar) new DirectFieldAccessor(postProcessor).getPropertyValue("registrar");
    @SuppressWarnings("unchecked")
    List<CronTask> cronTasks = (List<CronTask>) new DirectFieldAccessor(registrar).getPropertyValue("cronTasks");
    replacedertEquals(1, cronTasks.size());
    CronTask task = cronTasks.get(0);
    ScheduledMethodRunnable runnable = (ScheduledMethodRunnable) task.getRunnable();
    Object targetObject = runnable.getTarget();
    Method targetMethod = runnable.getMethod();
    replacedertEquals(target, targetObject);
    replacedertEquals("x", targetMethod.getName());
    replacedertEquals(businessHoursCronExpression, task.getExpression());
}

private void propertyPlaceholderWithFixedRate(boolean durationFormat) {
    BeanDefinition processorDefinition = new RootBeanDefinition(ScheduledAnnotationBeanPostProcessor.clreplaced);
    BeanDefinition placeholderDefinition = new RootBeanDefinition(PropertySourcesPlaceholderConfigurer.clreplaced);
    Properties properties = new Properties();
    properties.setProperty("fixedRate", (durationFormat ? "PT3S" : "3000"));
    properties.setProperty("initialDelay", (durationFormat ? "PT1S" : "1000"));
    placeholderDefinition.getPropertyValues().addPropertyValue("properties", properties);
    BeanDefinition targetDefinition = new RootBeanDefinition(PropertyPlaceholderWithFixedRateTestBean.clreplaced);
    context.registerBeanDefinition("postProcessor", processorDefinition);
    context.registerBeanDefinition("placeholder", placeholderDefinition);
    context.registerBeanDefinition("target", targetDefinition);
    context.refresh();
    ScheduledTaskHolder postProcessor = context.getBean("postProcessor", ScheduledTaskHolder.clreplaced);
    replacedertEquals(1, postProcessor.getScheduledTasks().size());
    Object target = context.getBean("target");
    ScheduledTaskRegistrar registrar = (ScheduledTaskRegistrar) new DirectFieldAccessor(postProcessor).getPropertyValue("registrar");
    @SuppressWarnings("unchecked")
    List<IntervalTask> fixedRateTasks = (List<IntervalTask>) new DirectFieldAccessor(registrar).getPropertyValue("fixedRateTasks");
    replacedertEquals(1, fixedRateTasks.size());
    IntervalTask task = fixedRateTasks.get(0);
    ScheduledMethodRunnable runnable = (ScheduledMethodRunnable) task.getRunnable();
    Object targetObject = runnable.getTarget();
    Method targetMethod = runnable.getMethod();
    replacedertEquals(target, targetObject);
    replacedertEquals("fixedRate", targetMethod.getName());
    replacedertEquals(1000L, task.getInitialDelay());
    replacedertEquals(3000L, task.getInterval());
}

private void propertyPlaceholderWithFixedDelay(boolean durationFormat) {
    BeanDefinition processorDefinition = new RootBeanDefinition(ScheduledAnnotationBeanPostProcessor.clreplaced);
    BeanDefinition placeholderDefinition = new RootBeanDefinition(PropertySourcesPlaceholderConfigurer.clreplaced);
    Properties properties = new Properties();
    properties.setProperty("fixedDelay", (durationFormat ? "PT5S" : "5000"));
    properties.setProperty("initialDelay", (durationFormat ? "PT1S" : "1000"));
    placeholderDefinition.getPropertyValues().addPropertyValue("properties", properties);
    BeanDefinition targetDefinition = new RootBeanDefinition(PropertyPlaceholderWithFixedDelayTestBean.clreplaced);
    context.registerBeanDefinition("postProcessor", processorDefinition);
    context.registerBeanDefinition("placeholder", placeholderDefinition);
    context.registerBeanDefinition("target", targetDefinition);
    context.refresh();
    ScheduledTaskHolder postProcessor = context.getBean("postProcessor", ScheduledTaskHolder.clreplaced);
    replacedertEquals(1, postProcessor.getScheduledTasks().size());
    Object target = context.getBean("target");
    ScheduledTaskRegistrar registrar = (ScheduledTaskRegistrar) new DirectFieldAccessor(postProcessor).getPropertyValue("registrar");
    @SuppressWarnings("unchecked")
    List<IntervalTask> fixedDelayTasks = (List<IntervalTask>) new DirectFieldAccessor(registrar).getPropertyValue("fixedDelayTasks");
    replacedertEquals(1, fixedDelayTasks.size());
    IntervalTask task = fixedDelayTasks.get(0);
    ScheduledMethodRunnable runnable = (ScheduledMethodRunnable) task.getRunnable();
    Object targetObject = runnable.getTarget();
    Method targetMethod = runnable.getMethod();
    replacedertEquals(target, targetObject);
    replacedertEquals("fixedDelay", targetMethod.getName());
    replacedertEquals(1000L, task.getInitialDelay());
    replacedertEquals(5000L, task.getInterval());
}

@Test
public void propertyPlaceholderWithCron() {
    String businessHoursCronExpression = "0 0 9-17 * * MON-FRI";
    BeanDefinition processorDefinition = new RootBeanDefinition(ScheduledAnnotationBeanPostProcessor.clreplaced);
    BeanDefinition placeholderDefinition = new RootBeanDefinition(PropertySourcesPlaceholderConfigurer.clreplaced);
    Properties properties = new Properties();
    properties.setProperty("schedules.businessHours", businessHoursCronExpression);
    placeholderDefinition.getPropertyValues().addPropertyValue("properties", properties);
    BeanDefinition targetDefinition = new RootBeanDefinition(PropertyPlaceholderWithCronTestBean.clreplaced);
    context.registerBeanDefinition("postProcessor", processorDefinition);
    context.registerBeanDefinition("placeholder", placeholderDefinition);
    context.registerBeanDefinition("target", targetDefinition);
    context.refresh();
    ScheduledTaskHolder postProcessor = context.getBean("postProcessor", ScheduledTaskHolder.clreplaced);
    replacedertEquals(1, postProcessor.getScheduledTasks().size());
    Object target = context.getBean("target");
    ScheduledTaskRegistrar registrar = (ScheduledTaskRegistrar) new DirectFieldAccessor(postProcessor).getPropertyValue("registrar");
    @SuppressWarnings("unchecked")
    List<CronTask> cronTasks = (List<CronTask>) new DirectFieldAccessor(registrar).getPropertyValue("cronTasks");
    replacedertEquals(1, cronTasks.size());
    CronTask task = cronTasks.get(0);
    ScheduledMethodRunnable runnable = (ScheduledMethodRunnable) task.getRunnable();
    Object targetObject = runnable.getTarget();
    Method targetMethod = runnable.getMethod();
    replacedertEquals(target, targetObject);
    replacedertEquals("x", targetMethod.getName());
    replacedertEquals(businessHoursCronExpression, task.getExpression());
}

@Test
public void expressionWithCron() {
    String businessHoursCronExpression = "0 0 9-17 * * MON-FRI";
    BeanDefinition processorDefinition = new RootBeanDefinition(ScheduledAnnotationBeanPostProcessor.clreplaced);
    BeanDefinition targetDefinition = new RootBeanDefinition(ExpressionWithCronTestBean.clreplaced);
    context.registerBeanDefinition("postProcessor", processorDefinition);
    context.registerBeanDefinition("target", targetDefinition);
    Map<String, String> schedules = new HashMap<>();
    schedules.put("businessHours", businessHoursCronExpression);
    context.getBeanFactory().registerSingleton("schedules", schedules);
    context.refresh();
    ScheduledTaskHolder postProcessor = context.getBean("postProcessor", ScheduledTaskHolder.clreplaced);
    replacedertThat(postProcessor.getScheduledTasks().size()).isEqualTo(1);
    Object target = context.getBean("target");
    ScheduledTaskRegistrar registrar = (ScheduledTaskRegistrar) new DirectFieldAccessor(postProcessor).getPropertyValue("registrar");
    @SuppressWarnings("unchecked")
    List<CronTask> cronTasks = (List<CronTask>) new DirectFieldAccessor(registrar).getPropertyValue("cronTasks");
    replacedertThat(cronTasks.size()).isEqualTo(1);
    CronTask task = cronTasks.get(0);
    ScheduledMethodRunnable runnable = (ScheduledMethodRunnable) task.getRunnable();
    Object targetObject = runnable.getTarget();
    Method targetMethod = runnable.getMethod();
    replacedertThat(targetObject).isEqualTo(target);
    replacedertThat(targetMethod.getName()).isEqualTo("x");
    replacedertThat(task.getExpression()).isEqualTo(businessHoursCronExpression);
}

@Test
public void propertyPlaceholderWithCron() {
    String businessHoursCronExpression = "0 0 9-17 * * MON-FRI";
    BeanDefinition processorDefinition = new RootBeanDefinition(ScheduledAnnotationBeanPostProcessor.clreplaced);
    BeanDefinition placeholderDefinition = new RootBeanDefinition(PropertySourcesPlaceholderConfigurer.clreplaced);
    Properties properties = new Properties();
    properties.setProperty("schedules.businessHours", businessHoursCronExpression);
    placeholderDefinition.getPropertyValues().addPropertyValue("properties", properties);
    BeanDefinition targetDefinition = new RootBeanDefinition(PropertyPlaceholderWithCronTestBean.clreplaced);
    context.registerBeanDefinition("postProcessor", processorDefinition);
    context.registerBeanDefinition("placeholder", placeholderDefinition);
    context.registerBeanDefinition("target", targetDefinition);
    context.refresh();
    ScheduledTaskHolder postProcessor = context.getBean("postProcessor", ScheduledTaskHolder.clreplaced);
    replacedertThat(postProcessor.getScheduledTasks().size()).isEqualTo(1);
    Object target = context.getBean("target");
    ScheduledTaskRegistrar registrar = (ScheduledTaskRegistrar) new DirectFieldAccessor(postProcessor).getPropertyValue("registrar");
    @SuppressWarnings("unchecked")
    List<CronTask> cronTasks = (List<CronTask>) new DirectFieldAccessor(registrar).getPropertyValue("cronTasks");
    replacedertThat(cronTasks.size()).isEqualTo(1);
    CronTask task = cronTasks.get(0);
    ScheduledMethodRunnable runnable = (ScheduledMethodRunnable) task.getRunnable();
    Object targetObject = runnable.getTarget();
    Method targetMethod = runnable.getMethod();
    replacedertThat(targetObject).isEqualTo(target);
    replacedertThat(targetMethod.getName()).isEqualTo("x");
    replacedertThat(task.getExpression()).isEqualTo(businessHoursCronExpression);
}

private void propertyPlaceholderWithFixedRate(boolean durationFormat) {
    BeanDefinition processorDefinition = new RootBeanDefinition(ScheduledAnnotationBeanPostProcessor.clreplaced);
    BeanDefinition placeholderDefinition = new RootBeanDefinition(PropertySourcesPlaceholderConfigurer.clreplaced);
    Properties properties = new Properties();
    properties.setProperty("fixedRate", (durationFormat ? "PT3S" : "3000"));
    properties.setProperty("initialDelay", (durationFormat ? "PT1S" : "1000"));
    placeholderDefinition.getPropertyValues().addPropertyValue("properties", properties);
    BeanDefinition targetDefinition = new RootBeanDefinition(PropertyPlaceholderWithFixedRateTestBean.clreplaced);
    context.registerBeanDefinition("postProcessor", processorDefinition);
    context.registerBeanDefinition("placeholder", placeholderDefinition);
    context.registerBeanDefinition("target", targetDefinition);
    context.refresh();
    ScheduledTaskHolder postProcessor = context.getBean("postProcessor", ScheduledTaskHolder.clreplaced);
    replacedertThat(postProcessor.getScheduledTasks().size()).isEqualTo(1);
    Object target = context.getBean("target");
    ScheduledTaskRegistrar registrar = (ScheduledTaskRegistrar) new DirectFieldAccessor(postProcessor).getPropertyValue("registrar");
    @SuppressWarnings("unchecked")
    List<IntervalTask> fixedRateTasks = (List<IntervalTask>) new DirectFieldAccessor(registrar).getPropertyValue("fixedRateTasks");
    replacedertThat(fixedRateTasks.size()).isEqualTo(1);
    IntervalTask task = fixedRateTasks.get(0);
    ScheduledMethodRunnable runnable = (ScheduledMethodRunnable) task.getRunnable();
    Object targetObject = runnable.getTarget();
    Method targetMethod = runnable.getMethod();
    replacedertThat(targetObject).isEqualTo(target);
    replacedertThat(targetMethod.getName()).isEqualTo("fixedRate");
    replacedertThat(task.getInitialDelay()).isEqualTo(1000L);
    replacedertThat(task.getInterval()).isEqualTo(3000L);
}

@Test
public void propertyPlaceholderForMetaAnnotation() {
    String businessHoursCronExpression = "0 0 9-17 * * MON-FRI";
    BeanDefinition processorDefinition = new RootBeanDefinition(ScheduledAnnotationBeanPostProcessor.clreplaced);
    BeanDefinition placeholderDefinition = new RootBeanDefinition(PropertySourcesPlaceholderConfigurer.clreplaced);
    Properties properties = new Properties();
    properties.setProperty("schedules.businessHours", businessHoursCronExpression);
    placeholderDefinition.getPropertyValues().addPropertyValue("properties", properties);
    BeanDefinition targetDefinition = new RootBeanDefinition(PropertyPlaceholderMetaAnnotationTestBean.clreplaced);
    context.registerBeanDefinition("postProcessor", processorDefinition);
    context.registerBeanDefinition("placeholder", placeholderDefinition);
    context.registerBeanDefinition("target", targetDefinition);
    context.refresh();
    ScheduledTaskHolder postProcessor = context.getBean("postProcessor", ScheduledTaskHolder.clreplaced);
    replacedertThat(postProcessor.getScheduledTasks().size()).isEqualTo(1);
    Object target = context.getBean("target");
    ScheduledTaskRegistrar registrar = (ScheduledTaskRegistrar) new DirectFieldAccessor(postProcessor).getPropertyValue("registrar");
    @SuppressWarnings("unchecked")
    List<CronTask> cronTasks = (List<CronTask>) new DirectFieldAccessor(registrar).getPropertyValue("cronTasks");
    replacedertThat(cronTasks.size()).isEqualTo(1);
    CronTask task = cronTasks.get(0);
    ScheduledMethodRunnable runnable = (ScheduledMethodRunnable) task.getRunnable();
    Object targetObject = runnable.getTarget();
    Method targetMethod = runnable.getMethod();
    replacedertThat(targetObject).isEqualTo(target);
    replacedertThat(targetMethod.getName()).isEqualTo("y");
    replacedertThat(task.getExpression()).isEqualTo(businessHoursCronExpression);
}

private void propertyPlaceholderWithFixedDelay(boolean durationFormat) {
    BeanDefinition processorDefinition = new RootBeanDefinition(ScheduledAnnotationBeanPostProcessor.clreplaced);
    BeanDefinition placeholderDefinition = new RootBeanDefinition(PropertySourcesPlaceholderConfigurer.clreplaced);
    Properties properties = new Properties();
    properties.setProperty("fixedDelay", (durationFormat ? "PT5S" : "5000"));
    properties.setProperty("initialDelay", (durationFormat ? "PT1S" : "1000"));
    placeholderDefinition.getPropertyValues().addPropertyValue("properties", properties);
    BeanDefinition targetDefinition = new RootBeanDefinition(PropertyPlaceholderWithFixedDelayTestBean.clreplaced);
    context.registerBeanDefinition("postProcessor", processorDefinition);
    context.registerBeanDefinition("placeholder", placeholderDefinition);
    context.registerBeanDefinition("target", targetDefinition);
    context.refresh();
    ScheduledTaskHolder postProcessor = context.getBean("postProcessor", ScheduledTaskHolder.clreplaced);
    replacedertThat(postProcessor.getScheduledTasks().size()).isEqualTo(1);
    Object target = context.getBean("target");
    ScheduledTaskRegistrar registrar = (ScheduledTaskRegistrar) new DirectFieldAccessor(postProcessor).getPropertyValue("registrar");
    @SuppressWarnings("unchecked")
    List<IntervalTask> fixedDelayTasks = (List<IntervalTask>) new DirectFieldAccessor(registrar).getPropertyValue("fixedDelayTasks");
    replacedertThat(fixedDelayTasks.size()).isEqualTo(1);
    IntervalTask task = fixedDelayTasks.get(0);
    ScheduledMethodRunnable runnable = (ScheduledMethodRunnable) task.getRunnable();
    Object targetObject = runnable.getTarget();
    Method targetMethod = runnable.getMethod();
    replacedertThat(targetObject).isEqualTo(target);
    replacedertThat(targetMethod.getName()).isEqualTo("fixedDelay");
    replacedertThat(task.getInitialDelay()).isEqualTo(1000L);
    replacedertThat(task.getInterval()).isEqualTo(5000L);
}

@Test
public void propertyPlaceholderWithCron() {
    String businessHoursCronExpression = "0 0 9-17 * * MON-FRI";
    BeanDefinition processorDefinition = new RootBeanDefinition(ScheduledAnnotationBeanPostProcessor.clreplaced);
    BeanDefinition placeholderDefinition = new RootBeanDefinition(PropertyPlaceholderConfigurer.clreplaced);
    Properties properties = new Properties();
    properties.setProperty("schedules.businessHours", businessHoursCronExpression);
    placeholderDefinition.getPropertyValues().addPropertyValue("properties", properties);
    BeanDefinition targetDefinition = new RootBeanDefinition(PropertyPlaceholderWithCronTestBean.clreplaced);
    context.registerBeanDefinition("postProcessor", processorDefinition);
    context.registerBeanDefinition("placeholder", placeholderDefinition);
    context.registerBeanDefinition("target", targetDefinition);
    context.refresh();
    ScheduledTaskHolder postProcessor = context.getBean("postProcessor", ScheduledTaskHolder.clreplaced);
    replacedertEquals(1, postProcessor.getScheduledTasks().size());
    Object target = context.getBean("target");
    ScheduledTaskRegistrar registrar = (ScheduledTaskRegistrar) new DirectFieldAccessor(postProcessor).getPropertyValue("registrar");
    @SuppressWarnings("unchecked")
    List<CronTask> cronTasks = (List<CronTask>) new DirectFieldAccessor(registrar).getPropertyValue("cronTasks");
    replacedertEquals(1, cronTasks.size());
    CronTask task = cronTasks.get(0);
    ScheduledMethodRunnable runnable = (ScheduledMethodRunnable) task.getRunnable();
    Object targetObject = runnable.getTarget();
    Method targetMethod = runnable.getMethod();
    replacedertEquals(target, targetObject);
    replacedertEquals("x", targetMethod.getName());
    replacedertEquals(businessHoursCronExpression, task.getExpression());
}

private void propertyPlaceholderWithFixedDelay(boolean durationFormat) {
    BeanDefinition processorDefinition = new RootBeanDefinition(ScheduledAnnotationBeanPostProcessor.clreplaced);
    BeanDefinition placeholderDefinition = new RootBeanDefinition(PropertyPlaceholderConfigurer.clreplaced);
    Properties properties = new Properties();
    properties.setProperty("fixedDelay", (durationFormat ? "PT5S" : "5000"));
    properties.setProperty("initialDelay", (durationFormat ? "PT1S" : "1000"));
    placeholderDefinition.getPropertyValues().addPropertyValue("properties", properties);
    BeanDefinition targetDefinition = new RootBeanDefinition(PropertyPlaceholderWithFixedDelayTestBean.clreplaced);
    context.registerBeanDefinition("postProcessor", processorDefinition);
    context.registerBeanDefinition("placeholder", placeholderDefinition);
    context.registerBeanDefinition("target", targetDefinition);
    context.refresh();
    ScheduledTaskHolder postProcessor = context.getBean("postProcessor", ScheduledTaskHolder.clreplaced);
    replacedertEquals(1, postProcessor.getScheduledTasks().size());
    Object target = context.getBean("target");
    ScheduledTaskRegistrar registrar = (ScheduledTaskRegistrar) new DirectFieldAccessor(postProcessor).getPropertyValue("registrar");
    @SuppressWarnings("unchecked")
    List<IntervalTask> fixedDelayTasks = (List<IntervalTask>) new DirectFieldAccessor(registrar).getPropertyValue("fixedDelayTasks");
    replacedertEquals(1, fixedDelayTasks.size());
    IntervalTask task = fixedDelayTasks.get(0);
    ScheduledMethodRunnable runnable = (ScheduledMethodRunnable) task.getRunnable();
    Object targetObject = runnable.getTarget();
    Method targetMethod = runnable.getMethod();
    replacedertEquals(target, targetObject);
    replacedertEquals("fixedDelay", targetMethod.getName());
    replacedertEquals(1000L, task.getInitialDelay());
    replacedertEquals(5000L, task.getInterval());
}

private void propertyPlaceholderWithFixedRate(boolean durationFormat) {
    BeanDefinition processorDefinition = new RootBeanDefinition(ScheduledAnnotationBeanPostProcessor.clreplaced);
    BeanDefinition placeholderDefinition = new RootBeanDefinition(PropertyPlaceholderConfigurer.clreplaced);
    Properties properties = new Properties();
    properties.setProperty("fixedRate", (durationFormat ? "PT3S" : "3000"));
    properties.setProperty("initialDelay", (durationFormat ? "PT1S" : "1000"));
    placeholderDefinition.getPropertyValues().addPropertyValue("properties", properties);
    BeanDefinition targetDefinition = new RootBeanDefinition(PropertyPlaceholderWithFixedRateTestBean.clreplaced);
    context.registerBeanDefinition("postProcessor", processorDefinition);
    context.registerBeanDefinition("placeholder", placeholderDefinition);
    context.registerBeanDefinition("target", targetDefinition);
    context.refresh();
    ScheduledTaskHolder postProcessor = context.getBean("postProcessor", ScheduledTaskHolder.clreplaced);
    replacedertEquals(1, postProcessor.getScheduledTasks().size());
    Object target = context.getBean("target");
    ScheduledTaskRegistrar registrar = (ScheduledTaskRegistrar) new DirectFieldAccessor(postProcessor).getPropertyValue("registrar");
    @SuppressWarnings("unchecked")
    List<IntervalTask> fixedRateTasks = (List<IntervalTask>) new DirectFieldAccessor(registrar).getPropertyValue("fixedRateTasks");
    replacedertEquals(1, fixedRateTasks.size());
    IntervalTask task = fixedRateTasks.get(0);
    ScheduledMethodRunnable runnable = (ScheduledMethodRunnable) task.getRunnable();
    Object targetObject = runnable.getTarget();
    Method targetMethod = runnable.getMethod();
    replacedertEquals(target, targetObject);
    replacedertEquals("fixedRate", targetMethod.getName());
    replacedertEquals(1000L, task.getInitialDelay());
    replacedertEquals(3000L, task.getInterval());
}

See More Examples