*
   * @throws UnsupportedOperationException always
   * @deprecated Unsupported operation.
   */
  @Deprecated
  @Override
  @DoNotCall("Always throws UnsupportedOperationException")
  public final void add(int index, E element) {
    throw new UnsupportedOperationException();
  }

  /**
   * Guaranteed to throw an exception and leave the list unmodified.
   *

     *
     * @throws Exception if any.
     */
    @Test
    public void testDotDot() throws Exception {
        assertNull(ReflectionValueExtractor.evaluate("h..value", new ValueHolder("value")));
    }

    /**
     * <p>testBadIndexedSyntax.</p>
     *
     * @throws Exception if any.
     */
    @Test
    public void testBadIndexedSyntax() throws Exception {
        List<Object> list = new ArrayList<Object>();

    public JavadocOptionFileWriterContext write(String string) throws IOException {
        writer.write(string);
        return this;
    }

    public JavadocOptionFileWriterContext newLine() throws IOException {
        writer.write(SystemProperties.getInstance().getLineSeparator());
        return this;
    }

    public JavadocOptionFileWriterContext writeOptionHeader(String option) throws IOException {
        write("-");

  }

  private static final byte[] bytes = newPreFilledByteArray(10000);

  private TestByteSource source;

  @Override
  protected void setUp() throws Exception {
    source = new TestByteSource(bytes);
  }

  public void testOpenBufferedStream() throws IOException {
    InputStream in = source.openBufferedStream();
    assertTrue(source.wasStreamOpened());
    assertFalse(source.wasStreamClosed());

        jsonWriter.name(name).value(number);
    }

    protected void write(String name, long length) throws IOException {
        jsonWriter.name(name).value(length);
    }

    protected void write(String name, boolean value) throws IOException {
        jsonWriter.name(name).value(value);
    }

    protected void write(String name, String value) throws IOException {

        @CallerClassName String consumer
    ) throws IOException {
        tryReportFileOpened(path, consumer);
        return Files.newBufferedReader(path);
    }

    @InterceptCalls
    @StaticMethod(ofClass = Files.class)
    public static BufferedReader intercept_newBufferedReader(
        Path path,
        Charset charset,
        @CallerClassName String consumer
    ) throws IOException {

            writeArgs(methodDetails, value);
        }

        private void writeArgs(MethodDetails methodDetails, MethodInvocation value) throws Exception {
            methodDetails.argsSerializer.write(encoder, value.getArguments());
        }

        private MethodDetails writeMethod(Method method) throws IOException {
            MethodDetails methodDetails = methods.get(method);
            if (methodDetails == null) {

    @Deprecated
    Wagon getWagon(String protocol) throws UnsupportedProtocolException;

    @Deprecated
    Wagon getWagon(Repository repository) throws UnsupportedProtocolException, WagonConfigurationException;

    //
    // Retriever
    //
    void getArtifact(Artifact artifact, ArtifactRepository repository, TransferListener transferListener, boolean force)
            throws TransferFailedException, ResourceDoesNotExistException;

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

    future = SettableFuture.create();
    tester = new ListenableFutureTester(future);
    tester.setUp();
  }

  public void testDefaultState() throws Exception {
    assertThrows(TimeoutException.class, () -> future.get(5, TimeUnit.MILLISECONDS));
  }

  public void testSetValue() throws Exception {
    assertTrue(future.set("value"));

     * available.
     *
     * @throws InterruptedException if the current thread was interrupted before or during the call
     *     (optional but recommended).
     * @throws CancellationException {@inheritDoc}
     */
    @CanIgnoreReturnValue
    @Override
    public V get(long timeout, TimeUnit unit)
        throws InterruptedException, TimeoutException, ExecutionException {
      return sync.get(unit.toNanos(timeout));
    }