return withParameters(attribute, ImmutableSet.of(value));
  }

  /**
   * Returns a new instance with the same type and subtype as this instance, with the {@code
   * charset} parameter set to the {@link Charset#name name} of the given charset. Only one {@code
   * charset} parameter will be present on the new instance regardless of the number set on this
   * one.
   *

       * under j2objc -- but it is not detected by our j2objc cycle test. The cycle:
       *
       * - CustomScheduler.service contains an instance of ServiceDelegate. (It needs it so that it
       *   can call notifyFailed.)
       *
       * - ServiceDelegate.runningTask contains an instance of ReschedulableCallable (at least in
       *   the case that the service is using CustomScheduler). (It needs it so that it can cancel

            }
        };
    }

    /**
     * Creates new instance of problem collector with configuration from the provided session.
     *
     * @param <P> the type of problem
     * @param protoSession the session containing configuration for the problem collector
     * @return a new problem collector instance
     */
    @Nonnull

     */
    public static void setInstance(final PrintStream stream) {
        inst = new LogStream(stream);
    }

    /**
     * Returns the singleton LogStream instance.
     *
     * @return the LogStream instance
     */
    public static LogStream getInstance() {
        if (inst == null) {
            setInstance(System.err);
        }
        return inst;
    }

      return (other instanceof ClassWhichIsAlwaysEqualButHasDifferentHashcodes);
    }
  }

  private static class ObjectWhichIsEqualButChangesClass implements Serializable {
    private static final long serialVersionUID = 1L;

    @Override
    public boolean equals(@Nullable Object other) {
      return (other instanceof ObjectWhichIsEqualButChangesClass || other instanceof OtherForm);
    }

    @Override

    }

    /**
     * Constructs an instance.
     *
     * @param reader
     *            The {@link Reader} to read strings from. Must not be {@literal null}.
     */
    public LineIterator(final Reader reader) {
        assertArgumentNotNull("reader", reader);
        this.reader = new BufferedReader(reader);
    }

    /**
     * Constructs an instance.
     *
     * @param reader

            }
        }
        return event;
    }

    /**
     * Factory method to create an ErrorToWarnRewritePolicy instance.
     *
     * @param loggerNamePrefix comma-separated list of logger name prefixes
     * @return a new ErrorToWarnRewritePolicy instance
     */
    @PluginFactory
    public static ErrorToWarnRewritePolicy createPolicy(@PluginAttribute("loggers") final String loggerNamePrefix) {

     * @return this Ansi instance
     */
    public Ansi cursorToColumn(final int x) {
        return appendEscapeSequence('G', Math.max(1, x));
    }

    /**
     * Moves the cursor up. If the parameter y is negative it moves the cursor down.
     *
     * @param y the number of lines to move up
     * @return this Ansi instance
     */
    public Ansi cursorUp(final int y) {

          .put(SomeError.class, e -> e instanceof SomeError)
          .put(SomeOtherCheckedException.class, e -> e instanceof SomeOtherCheckedException)
          .put(SomeUncheckedException.class, e -> e instanceof SomeUncheckedException)
          .put(TimeoutException.class, e -> e instanceof TimeoutException)
          .put(UnsupportedCharsetException.class, e -> e instanceof UnsupportedCharsetException)

            }

            element.childNodes.findAll { it instanceof Text }.each {
                assert it.textContent != null : "Found null text element in <$element.tagName>"
            }

            List<Node> trimmedContent = element.childNodes.collect { it };
            boolean inlineContent = trimmedContent.find { it instanceof Text && it.textContent.trim() }

            if (prettyPrint && !inlineContent) {