setupCount = 0;
        timeout = 5000;
    }

    @Override
    void reset(final int key, final String lastName) {
        super.reset();
        this.lastName = lastName;
    }

    @Override
    int writeSetupWireFormat(final byte[] dst, final int dstIndex) {
        return 0;
    }

    @Override
    int writeParametersWireFormat(final byte[] dst, int dstIndex) {

    private static final NullWriter INSTANCE = new NullWriter();

    @Override
    public void write(int c) {}

    @Override
    public void write(char[] cbuf) {
      checkNotNull(cbuf);
    }

    @Override
    public void write(char[] cbuf, int off, int len) {
      checkPositionIndexes(off, off + len, cbuf.length);
    }

    @Override
    public void write(String str) {
      checkNotNull(str);

      return super.get(timeout, unit);
    }

    @Override
    public final boolean isDone() {
      return super.isDone();
    }

    @Override
    public final boolean isCancelled() {
      return super.isCancelled();
    }

    @Override
    public final void addListener(Runnable listener, Executor executor) {
      super.addListener(listener, executor);
    }

    }

    @Override
    public Set<K> createKeySet() {
      return removeOnlySet(backingSet());
    }

    @Override
    Collection<V> createValues() {
      return Collections2.transform(set, function);
    }

    @Override
    public int size() {
      return backingSet().size();
    }

    @Override
    public boolean containsKey(@Nullable Object key) {

        final CustomSize customAnnotation = new CustomSize() {
            @Override
            public Class<? extends Annotation> annotationType() {
                return CustomSize.class;
            }

            @Override
            public String message() {
                return "Test message";
            }

            @Override
            public Class<?>[] groups() {

    this.forwardOrder = checkNotNull(forwardOrder);
  }

  @Override
  public int compare(@ParametricNullness T a, @ParametricNullness T b) {
    return forwardOrder.compare(b, a);
  }

  @SuppressWarnings("unchecked") // how to explain?
  @Override
  public <S extends T> Ordering<S> reverse() {
    return (Ordering<S>) forwardOrder;
  }

  // Override the min/max methods to "hoist" delegation outside loops

  @Override

    private boolean canResume = false;

    @Override
    public MavenExecutionResult setProject(MavenProject project) {
        this.project = project;

        return this;
    }

    @Override
    public MavenProject getProject() {
        return project;
    }

    @Override

            tagHandlers.add(handler);
        }

        @Override
        void onStartHtmlElement(String name) {
            attributes.clear();
        }

        @Override
        void onHtmlElementAttribute(String name, String value) {
            attributes.put(name, value);
        }

        @Override
        void onStartHtmlElementComplete(String name) {

            @Override
            public String getIndexFieldId() {
                return "id";
            }

            @Override
            public String getIndexFieldDocId() {
                return "doc_id";
            }

            @Override
            public String getIndexFieldLabel() {
                return "label";
            }

            @Override

      object : X509TrustManager {
        override fun checkClientTrusted(
          chain: Array<X509Certificate>,
          authType: String,
        ) {
        }

        override fun checkServerTrusted(
          chain: Array<X509Certificate>,
          authType: String,
        ) {
        }

        override fun getAcceptedIssuers(): Array<X509Certificate> = arrayOf()
      }