}

  public void testFutureGetThrowsWrappedException() throws Exception {
    inputFuture.setException(EXCEPTION);
    listener.assertException(EXCEPTION);
  }

  public void testFutureGetThrowsWrappedError() throws Exception {
    Error error = new Error();
    inputFuture.setException(error);
    // Verify that get throws an ExecutionException, caused by an Error, when
    // the callback is called.

      case NOT_DONE:
        break;
      case FINISHED:
        f.set(null);
        break;
      case CANCELLED:
        f.cancel(false);
        break;
      case FAILED:
        f.setException(new Exception());
        break;
    }
    return f;
  }

     * thread immediately fails with the same exception:
     *
     * Thread1: calls setException(), which returns true, context switch before it can CAS
     * seenExceptionsField to its exception
     *
     * Thread2: calls setException(), which returns false, CASes seenExceptionsField to its
     * exception, and wrongly believes that its exception is new (leading it to logging it when it

          });
      executor.execute(
          new Runnable() {
            @Override
            public void run() {
              future.setException(new IllegalArgumentException("failure"));
              if (!future.isDone()) {
                errorMessage.set("SetException call exited before future was complete.");
              }
            }
          });
      executor.execute(
          new Runnable() {

        RepositoryEvent.Builder event = new RepositoryEvent.Builder(session, EventType.ARTIFACT_DESCRIPTOR_MISSING);
        event.setTrace(trace);
        event.setArtifact(artifact);
        event.setException(exception);

        repositoryEventDispatcher.dispatch(event.build());
    }

    private void invalidDescriptor(

                            problems.add(new ModelProblemCollectorRequest(Severity.ERROR, Version.BASE)
                                    .setMessage(e.getMessage())
                                    .setException(e));
                        }
                        cache.put(value, c);
                    }
                    return c;
                }
                return value;
            }
        };

    public Severity getSeverity() {
        return severity;
    }

    public Version getVersion() {
        return version;
    }

    public Exception getException() {
        return exception;
    }

    public ModelProblemCollectorRequest setException(Exception exception) {
        this.exception = exception;
        return this;
    }

    public String getMessage() {
        return message;
    }

                            + e.getMessage())
                    .setLocation(file.getLocation(missing ? "missing" : "exists"))
                    .setException(e));
            return false;
        }

        if (path == null) {
            return false;
        }

        File f = new File(path);

        if (!f.isAbsolute()) {

       * class with a manual reference back to the "containing" class.)
       *
       * This has the nice-ish side effect of limiting reentrancy: run() calls
       * timeoutFuture.setException() calls run(). That reentrancy would already be harmless, since
       * timeoutFuture can be set (and delegate cancelled) only once. (And "set only once" is

          });
      executor.execute(
          new Runnable() {
            @Override
            public void run() {
              future.setException(new IllegalArgumentException("failure"));
              if (!future.isDone()) {
                errorMessage.set("SetException call exited before future was complete.");
              }
            }
          });
      executor.execute(
          new Runnable() {