Exemplo n.º 1
0
  public void doMocking(AbstractInvokable taskMock) throws Exception {

    TaskInfo taskInfoMock = mock(TaskInfo.class);
    when(taskInfoMock.getTaskNameWithSubtasks()).thenReturn("dummyName");

    TaskManagerRuntimeInfo tmRuntimeInfo = mock(TaskManagerRuntimeInfo.class);
    when(tmRuntimeInfo.getConfiguration()).thenReturn(new Configuration());

    task =
        new Task(
            mock(JobInformation.class),
            new TaskInformation(
                new JobVertexID(), "test task name", 1, 1, "foobar", new Configuration()),
            mock(ExecutionAttemptID.class),
            0,
            0,
            Collections.<ResultPartitionDeploymentDescriptor>emptyList(),
            Collections.<InputGateDeploymentDescriptor>emptyList(),
            0,
            mock(TaskStateHandles.class),
            mock(MemoryManager.class),
            mock(IOManager.class),
            mock(NetworkEnvironment.class),
            mock(BroadcastVariableManager.class),
            mock(TaskManagerConnection.class),
            mock(InputSplitProvider.class),
            mock(CheckpointResponder.class),
            mock(LibraryCacheManager.class),
            mock(FileCache.class),
            tmRuntimeInfo,
            mock(TaskMetricGroup.class),
            mock(ResultPartitionConsumableNotifier.class),
            mock(PartitionStateChecker.class),
            mock(Executor.class));
    Field f = task.getClass().getDeclaredField("invokable");
    f.setAccessible(true);
    f.set(task, taskMock);

    Field f2 = task.getClass().getDeclaredField("executionState");
    f2.setAccessible(true);
    f2.set(task, ExecutionState.RUNNING);
  }
Exemplo n.º 2
0
 /**
  * Return as list of tasks which is the specified task class type.
  *
  * @param taskClass task class type
  * @return List<Task> a list of matching tasks
  */
 public List<Task> getTasks(Class<? extends Task> taskClass) {
   List<Task> ts = new ArrayList<Task>();
   synchronized (tasks) {
     for (Task task : tasks) {
       if (task.getClass().equals(taskClass)) {
         ts.add(task);
       }
     }
   }
   return ts;
 }
 @SuppressWarnings("unchecked")
 private static <T> Class<T> typeOf(Task<T> task) {
   Class<?> taskType = task.getClass();
   while (taskType != Object.class) {
     for (Type type : taskType.getGenericInterfaces()) {
       if (type instanceof ParameterizedType) {
         ParameterizedType paramType = (ParameterizedType) type;
         if (paramType.getRawType() == Task.class) {
           Type param = paramType.getActualTypeArguments()[0];
           if (param.getClass() == Class.class) return (Class<T>) param;
         }
       }
     }
     taskType = taskType.getSuperclass();
   }
   return null;
 }