assertThat(getResponse(methodName).getResult()).isNull();
  }

  /**
   * Asserts that a prior call that had caused this thread to block or wait has since returned the
   * expected boolean value.
   */
  public void assertPriorCallReturns(boolean expected, @Nullable String methodName)
      throws Exception {
    assertEquals(expected, getResponse(methodName).getResult());
  }

  /**

    assertThat(getResponse(methodName).getResult()).isNull();
  }

  /**
   * Asserts that a prior call that had caused this thread to block or wait has since returned the
   * expected boolean value.
   */
  public void assertPriorCallReturns(boolean expected, @Nullable String methodName)
      throws Exception {
    assertEquals(expected, getResponse(methodName).getResult());
  }

  /**

    class ResultHandlingTests {

        @Test
        @DisplayName("getResult should return null when result is 0")
        void testGetResultSuccess() throws Exception {
            // Given
            setResultField(bind, 0);

            // When
            DcerpcException result = bind.getResult();

            // Then

        if (dispatcherResult.isEmpty()) {
            throw new InterruptedException();
        }
        if (NONE.equals(dispatcherResult.get("defaultDispatcher").getResult())) {
            context.terminal
                    .writer()
                    .println(messageBuilderFactory
                            .builder()
                            .warning(

              public boolean processLine(String line) throws IOException {
                list.add(line);
                return true;
              }

              @Override
              public List<String> getResult() {
                return list;
              }
            });

    assertExpectedLines(list);
  }

  public void testReadLines_withProcessor_stopsOnFalse() throws IOException {

    }

    /**
     * Gets the negotiation result code
     * @return the result code
     */
    public int getResult() {
        return this.result;
    }

    /**
     * Sets the negotiation result code
     * @param result the result code to set
     */
    public void setResult(final int result) {
        this.result = result;
    }

    /**

            }
            return true;
          }

          @Override
          public List<String> getResult() {
            return collector;
          }
        };
    Files.readLines(temp, UTF_8, collectNonEmptyLines);
    assertThat(collectNonEmptyLines.getResult()).containsExactly("hello", " world  ").inOrder();

    assertTrue(temp.delete());
  }

              public boolean processLine(String line) throws IOException {
                list.add(line);
                return true;
              }

              @Override
              public List<String> getResult() {
                return list;
              }
            });
    assertEquals(ImmutableList.of("foo", "bar", "baz", "something"), list);
    assertTrue(lines.wasStreamOpened() && lines.wasStreamClosed());
  }

     */
    public ArtifactResolverException(String message, Exception e, ArtifactResolverResult result) {
        super(message, e);
        this.result = result;
    }

    public ArtifactResolverResult getResult() {
        return result;
    }

    assertFalse(future.isCancelled());

    ExecutorService executor = newSingleThreadExecutor();

    try {
      Future<Boolean> getResult = executor.submit(() -> future.get());

      // Release the future value.
      latch.countDown();

      assertTrue(getResult.get(10, SECONDS));
    } finally {
      executor.shutdownNow();
    }

    assertTrue(future.isDone());
    assertFalse(future.isCancelled());