private final ImmutableSet<TestOption> options;
  private boolean closed;

  public TestOutputStream(OutputStream out, TestOption... options) throws IOException {
    this(out, Arrays.asList(options));
  }

  public TestOutputStream(OutputStream out, Iterable<TestOption> options) throws IOException {
    super(checkNotNull(out));
    this.options = ImmutableSet.copyOf(options);
    throwIf(OPEN_THROWS);
  }

    private Map<String, ?> options;


    /**
     * Initialize a static JAAS configuration with default settings
     */
    public StaticJAASConfiguration () {
        this.options = new HashMap<>();
    }


    /**
     * Initialize a static JAAS configuration with custom settings
     * 
     * @param options
     */

    local heatmap = g.panel.heatmap,
    local options = heatmap.options,

    base(title, targets, desc=''):
      heatmap.new(title)
      + heatmap.queryOptions.withTargets(targets)
      + heatmap.queryOptions.withInterval('1m')
      + options.calculation.xBuckets.withMode('size')
      + options.calculation.xBuckets.withValue('1min')
      + options.withCellGap(0)
      + options.color.withMode('scheme')

                     "options": "lds"
                  },
                  "properties": [
                     {
                        "id": "displayName",
                        "value": "Listeners"
                     }
                  ]
               },
               {
                  "matcher": {
                     "id": "byName",
                     "options": "rds"
                  },

import org.apache.maven.api.cli.Options;
import org.apache.maven.api.cli.ParserRequest;

/**
 * Options that are "layered" by precedence order.
 *
 * @param <O> The type of options.
 */
public abstract class LayeredOptions<O extends Options> implements Options {
    protected final List<O> options;

    protected LayeredOptions(List<O> options) {
        this.options = new ArrayList<>(options);
    }

    public static final String YJP = "yjp";

    protected Options options;
    protected final Set<Option> usedDeprecatedOptions = new LinkedHashSet<>();

    @SuppressWarnings("checkstyle:MethodLength")
    public CLIManager() {
        options = new Options();
        options.addOption(Option.builder(Character.toString(HELP))
                .longOpt("help")

    public PersistedToolchains read(Reader input, Map<String, ?> options) throws IOException {
        Objects.requireNonNull(input, "input cannot be null");

        try (Reader in = input) {
            InputSource source = (InputSource) options.get(InputSource.class.getName());
            return new PersistedToolchains(new MavenToolchainsStaxReader().read(in, isStrict(options), source));
        } catch (XMLStreamException e) {

                in,
                out,
                err,
                coreExtensions);
        this.options = (EncryptOptions) requireNonNull(options);
    }

    /**
     * The mandatory Encrypt options.
     */
    @Nonnull
    public EncryptOptions options() {
        return options;
    }

            super.prepareOptions(options);
            options.addOption(Option.builder(ALTERNATE_POM_FILE)
                    .longOpt("file")
                    .hasArg()
                    .desc("Force the use of an alternate POM file (or directory with pom.xml)")
                    .build());
            options.addOption(Option.builder(OFFLINE)

        final Options options = new Options();

        final CmdLineParser parser = new CmdLineParser(options);
        try {
            parser.parseArgument(args);
        } catch (final CmdLineException e) {
            System.err.println(e.getMessage());
            System.err.println("java " + Crawler.class.getCanonicalName() + " [options...] arguments...");