@Test
  public void testCreateTask() throws Exception {
    TaskBuilder builder = taskService.createTask();
    builder.creator(user);
    builder.project(project);
    builder.name(name);
    builder.description(desc);
    builder.testSteps(teststeps);
    builder.type(type);
    builder.estimated(8);
    builder.priority(priority);
    Task task = builder.build();

    task.store();

    assertNotNull(task);
    assertTrue(task.getId() > 0);
    assertEquals(name, task.getName());
    assertEquals(desc, task.getDescription());
    assertEquals(teststeps, task.getTestSteps());
    assertEquals(user.getName(), task.getCreator().getName());
    assertEquals(user.getName(), task.getAssignee().getName());
    assertEquals("New", task.getStatus().getName());
    assertEquals(priority, task.getPriority());
    assertEquals(type, task.getType());
  }
 public TaskBuilder newScanTask(File sonarProps) {
   Properties prop = new Properties();
   try (Reader reader =
       new InputStreamReader(new FileInputStream(sonarProps), StandardCharsets.UTF_8)) {
     prop.load(reader);
   } catch (Exception e) {
     throw new IllegalStateException("Unable to read configuration file", e);
   }
   TaskBuilder builder = new TaskBuilder(this);
   builder.property("sonar.projectBaseDir", sonarProps.getParentFile().getAbsolutePath());
   for (Map.Entry<Object, Object> entry : prop.entrySet()) {
     builder.property(entry.getKey().toString(), entry.getValue().toString());
   }
   return builder;
 }
 public boolean reschedule(String taskName, TaskDescription taskDescription) {
   if (!isInitialized()) {
     return false;
   }
   try {
     synchronized (lock) {
       TaskInfo taskInfo = taskManager.getTask(taskName);
       TaskDescription description = TaskBuilder.buildTaskDescription(taskInfo);
       taskInfo = TaskBuilder.buildTaskInfo(description, properties);
       taskManager.registerTask(taskInfo);
       taskManager.rescheduleTask(taskInfo.getName());
     }
   } catch (Exception e) {
     return false;
   }
   return true;
 }
  @Test
  public void sequentialExecutorShouldExecuteTasksAccordingToDependencies() {
    TaskBuilder builder = new TaskBuilder();
    Runnables.TimedRunnable t1 = Runnables.timedRunnable(10);
    Runnables.TimedRunnable t2 = Runnables.timedRunnable(10);
    Runnables.TimedRunnable t3 = Runnables.timedRunnable(10);

    Task a = builder.justRun(t1);
    Task b = builder.run(t2).after(a);
    Task c = builder.run(t3).after(a);
    Task seq = builder.sequence(a, b, c);

    new SequentialTaskExecutor().execute(seq);
    assertTrue(t1.getTime() < t2.getTime());
    assertTrue(t2.getTime() < t3.getTime());
    for (Runnables.TimedRunnable tr : Arrays.asList(t1, t2, t3)) {
      assertEquals(1, tr.callCount());
    }
  }
 public TaskDescription getTask(String taskName) {
   if (!isInitialized()) {
     return null;
   }
   try {
     TaskInfo taskInfo;
     synchronized (lock) {
       taskInfo = taskManager.getTask(taskName);
     }
     return TaskBuilder.buildTaskDescription(taskInfo);
   } catch (Exception e) {
     logger.error("Cannot return task [" + taskName + "]. Error: " + e.getLocalizedMessage(), e);
     return null;
   }
 }
 public boolean schedule(TaskDescription taskDescription) {
   logger.debug("#schedule Scheduling task:" + taskDescription.getName());
   TaskInfo taskInfo;
   try {
     taskInfo = TaskBuilder.buildTaskInfo(taskDescription, properties);
   } catch (Exception e) {
     if (logger.isDebugEnabled()) {
       logger.debug(
           "#schedule Could not build task info object. Error:" + e.getLocalizedMessage(), e);
     }
     return false;
   }
   if (!isInitialized()) {
     // if cannot schedule yet, put in the pending tasks list.
     synchronized (lock) {
       logger.debug("#schedule Added pending task [" + taskInfo.getName() + "]");
       pendingTasks.add(taskInfo);
     }
     return false;
   }
   try {
     synchronized (lock) {
       taskManager.registerTask(taskInfo);
       taskManager.scheduleTask(taskInfo.getName());
     }
     logger.info(
         "Scheduled task ["
             + taskDescription.getName()
             + "::"
             + taskDescription.getTaskGroup()
             + "]");
   } catch (Exception e) {
     logger.error(
         "Scheduling task ["
             + taskDescription.getName()
             + "::"
             + taskDescription.getTaskGroup()
             + "] FAILED. Error: "
             + e.getLocalizedMessage(),
         e);
     return false;
   }
   return true;
 }