// exception.
  private void setupCloseable(boolean shouldThrow) throws IOException {
    mockCloseable = mock(Closeable.class);
    if (shouldThrow) {
      doThrow(new IOException("This should only appear in the logs. It should not be rethrown."))
          .when(mockCloseable)
          .close();
    }
  }

  private void doClose(Closeable closeable, boolean swallowException) throws IOException {

    private static final int UTF8_BOM_SIZE = 3;

    public boolean prunedContent = true;

    protected Map<String, String> convertUrlMap = new LinkedHashMap<>();

    protected FessConfig fessConfig;

    protected boolean useGoogleOffOn = true;

    protected Map<String, Boolean> fieldPrunedRuleMap = new HashMap<>();

    private String service = DEFAULT_SERVICE;
    private int userLifetime = GSSCredential.DEFAULT_LIFETIME;
    private int contextLifetime = GSSContext.DEFAULT_LIFETIME;
    private boolean canFallback = false;
    private boolean forceFallback;

    static {
        PREFERRED_MECHS.add(new ASN1ObjectIdentifier("1.2.840.113554.1.2.2"));
        PREFERRED_MECHS.add(new ASN1ObjectIdentifier("1.2.840.48018.1.2.2"));
    }

    JdkMatcher(Matcher matcher) {
      this.matcher = Preconditions.checkNotNull(matcher);
    }

    @Override
    public boolean matches() {
      return matcher.matches();
    }

    @Override
    public boolean find() {
      return matcher.find();
    }

    @Override
    public boolean find(int index) {
      return matcher.find(index);
    }

    @Override
    public String replaceAll(String replacement) {

   */
  @GuardedBy("lock")
  private int runningTasks = 0;

  @GuardedBy("lock")
  private boolean shutdown = false;

  @Override
  public void execute(Runnable command) {
    startTask();
    try {
      command.run();
    } finally {
      endTask();
    }
  }

  @Override
  public boolean isShutdown() {
    synchronized (lock) {
      return shutdown;
    }
  }

  @Override

 */
@Named("property")
@Singleton
@Deprecated(since = "4.0.0")
public class PropertyProfileActivator implements ProfileActivator {

    @Override
    public boolean isActive(Profile profile, ProfileActivationContext context, ModelProblemCollector problems) {
        Activation activation = profile.getActivation();

        if (activation == null) {
            return false;
        }

    }

    def format(Iterable<? extends Node> nodes, boolean prettyPrint = false) {
        StringBuilder builder = new StringBuilder()
        nodes.each { node ->
            format(node, builder, 0, prettyPrint, prettyPrint)
        }
        return builder.toString()
    }

    def format(Node node, Appendable target, int depth, boolean prettyPrint, boolean indentSelf) {
        if (node instanceof Element) {

    ListenableFuture<@Nullable Void> unused = serializer.submit(blockingCallable, executor);
    ListenableFuture<Boolean> future2 =
        serializer.submit(
            new Callable<Boolean>() {
              @Override
              public Boolean call() {
                return blockingCallable.isRunning();
              }
            },
            directExecutor());

  @VisibleForTesting final Object lock = new Object();

  @GuardedBy("lock")
  final LinkedList<TearDown> stack = new LinkedList<>();

  private final boolean suppressThrows;

  public TearDownStack() {
    this.suppressThrows = false;
  }

  public TearDownStack(boolean suppressThrows) {
    this.suppressThrows = suppressThrows;
  }

  @Override
  public final void addTearDown(TearDown tearDown) {

    /**
     * Returns the default classifier used if a different one is not set in pom.xml.
     *
     * @return the classifier
     */
    String getClassifier();

    String getPackaging();

    boolean isIncludesDependencies();

    String getLanguage();

    /**
     * Specifies if the artifact contains java classes and can be added to the classpath.