setRead(isRead(unixNumeric));
        setWrite(isWrite(unixNumeric));
        setExecute(isExecute(unixNumeric));
    }

    @Override
    public void unix(String unixSymbolic) {
        setRead(isRead(unixSymbolic));
        setWrite(isWrite(unixSymbolic));
        setExecute(isExecute(unixSymbolic));
    }

    @Override
    public void unix(int unixNumeric) {
        setRead(isRead(unixNumeric));

        }
    }

    protected static boolean isExecute(int unixNumeric) {
        return (unixNumeric & 1) == 1;
    }

    protected static boolean isExecute(String unixSymbolic) {
        char symbol = unixSymbolic.charAt(2);
        if (symbol == 'x') {
            return true;
        } else if (symbol == '-') {

    private final boolean execute;

    public DefaultUserClassFilePermissions(int unixNumeric) {
        read = isRead(unixNumeric);
        write = isWrite(unixNumeric);
        execute = isExecute(unixNumeric);
    }

    @Override
    public boolean getRead() {
        return read;
    }

    @Override
    public boolean getWrite() {
        return write;
    }

    @Override

    }

    private static boolean isRead(int unixNumeric) {
        return (unixNumeric & 4) >> 2 == 1;
    }

    private static boolean isWrite(int unixNumeric) {
        return (unixNumeric & 2) >> 1 == 1;
    }

    private static boolean isExecute(int unixNumeric) {
        return (unixNumeric & 1) == 1;
    }

            }

            final int exitValue = p.exitValue();
            if (exitValue != 0) {
                logger.warn("{} is failed (exit code:{}, timeout:{}): {}", getName(), exitValue, task.isExecuted(), commandList);
            }

            if (logger.isDebugEnabled()) {
                logger.debug("{} is finished with exit code {}.", getName(), exitValue);
            }

    assertThat(dispatcher.queuedCalls()).isEmpty()
    assertThat(a1.isExecuted()).isTrue()
    assertThat(a1.isCanceled()).isFalse()
    assertThat(a2.isExecuted()).isTrue()
    assertThat(a2.isCanceled()).isTrue()
    assertThat(a3.isExecuted()).isFalse()
    assertThat(a3.isCanceled()).isTrue()
    assertThat(a4.isExecuted()).isFalse()
    assertThat(a4.isCanceled()).isFalse()
  }

  @Test

  override fun execute(): Response = error("unexpected")

  override fun enqueue(responseCallback: Callback): Unit = error("unexpected")

  override fun cancel(): Unit = error("unexpected")

  override fun isExecuted(): Boolean = error("unexpected")

  override fun isCanceled(): Boolean = error("unexpected")

  override fun timeout(): Timeout = error("unexpected")

  override fun clone(): Call = error("unexpected")

                    }
                    taskNode = taskNodeFactory.getOrCreateNode(task);
                }
                if (taskNode.isExecuted() && taskNode.isSuccessful()) {
                    return IncludedBuildTaskResource.State.Success;
                } else if (taskNode.isExecuted()) {
                    return IncludedBuildTaskResource.State.Failed;
                } else if (taskNode.isComplete()) {

  fun cancel()

  /**
   * Returns true if this call has been either [executed][execute] or [enqueued][enqueue]. It is an
   * error to execute a call more than once.
   */
  fun isExecuted(): Boolean

  fun isCanceled(): Boolean

  /**
   * Returns a timeout that spans the entire call: resolving DNS, connecting, writing the request

            for (Node node : nodes) {
                if (!node.isComplete()) {
                    return Node.DependenciesState.NOT_COMPLETE;
                }
                isAnyExecuted |= node.isExecuted();
            }
            // All relevant finalized nodes have completed
            if (isAnyExecuted) {
                return Node.DependenciesState.COMPLETE_AND_SUCCESSFUL;
            }