* @param exception The exception that caused this problem, may be {@code null}.
     */
    // mkleint: does this need to be public?
    public DefaultModelProblem(
            String message,
            Severity severity,
            Version version,
            Model source,
            int lineNumber,
            int columnNumber,
            Exception exception) {
        this(
                message,

  }

  public void testConstructor() throws Exception {
    Invokable<A, A> invokable = A.constructor();
    assertTrue(invokable.isPublic());
    assertFalse(invokable.isPackagePrivate());
    assertFalse(invokable.isAbstract());
    assertFalse(invokable.isStatic());
    assertTrue(invokable.isAnnotationPresent(Tested.class));
  }

  public void testAbstractMethod() throws Exception {

   * RuntimeException runtime exceptions} thrown by the executor.
   */
  @SuppressWarnings("CatchingUnchecked") // sneaky checked exception
  private static void executeListener(Runnable runnable, Executor executor) {
    try {
      executor.execute(runnable);
    } catch (Exception e) { // sneaky checked exception

        }
    }

    @Override
    public CacheRecord put(Key key, PluginResolutionException exception) {
        Objects.requireNonNull(exception, "exception cannot be null");

        assertUniqueKey(key);

        CacheRecord record = new CacheRecord(exception);

        cache.put(key, record);

        return record;
    }

    @Override
    public void flush() {

        org.apache.maven.project.ProjectBuilder projectBuilder =
                getContainer().lookup(org.apache.maven.project.ProjectBuilder.class);

        // single project build entry point
        Exception ex = assertThrows(Exception.class, () -> projectBuilder.build(pomFile, configuration));
        assertTrue(ex.getMessage().contains("Received non-all-whitespace CHARACTERS or CDATA event"));

        // multi projects build entry point

  @Override
  protected void tearDown() {
    stack.runTearDown();
  }

  static final Exception EXCEPTION = new Exception();

  static final class ExampleClassUnderTest {
    static final Logger logger = Logger.getLogger(ExampleClassUnderTest.class.getName());

    static void foo() {
      logger.log(Level.INFO, "message", EXCEPTION);
    }

    private ExampleClassUnderTest() {}
  }

  protected static final int VALID_INPUT_DATA = 1;
  protected static final Exception EXCEPTION = new Exception("Test exception");

  protected SettableFuture<Integer> inputFuture;
  protected ListenableFuture<T> resultFuture;
  protected MockFutureListener listener;

  @Override
  protected void setUp() throws Exception {
    super.setUp();

    inputFuture = SettableFuture.create();

    Exception exception = new RuntimeException("test");
    UncheckedExecutionException e =
        assertThrows(
            UncheckedExecutionException.class,
            () -> timeLimiter.callWithTimeout(callableThrowing(exception), DELAY_MS, MILLISECONDS));
    assertThat(e).hasCauseThat().isEqualTo(exception);
  }

  public void testCallUninterruptiblyWithTimeout_propagatesReturnValue() throws Exception {
    String result =

  }

  public void testEvilFuture_setFuture() throws Exception {
    RuntimeException exception = new RuntimeException("you didn't say the magic word!");
    AbstractFuture<String> evilFuture =
        new AbstractFuture<String>() {
          @Override
          public void addListener(Runnable r, Executor e) {
            throw exception;
          }
        };

          try {
            nextToRun.call(listener);
          } catch (Exception e) { // sneaky checked exception
            // Log it and keep going.
            logger
                .get()
                .log(
                    Level.SEVERE,
                    "Exception while executing callback: " + listener + " " + nextLabel,
                    e);
          }
        }