String expectedOutput = main.expectedOutput

    SwiftAppWithLibrariesAndXCTest() {
        super('app')
    }

    SourceElement getGreeter() {
        return app.greeter
    }

    SourceElement getLogger() {
        return app.logger
    }

    @Override
    List<SourceFile> getFiles() {
        return Lists.newArrayList(Iterables.concat(super.getFiles(), app.greeter.files, app.logger.files, sum.files, multiply.files))

import org.gradle.api.logging.Logger;
import org.gradle.api.logging.Logging;

import java.io.File;
import java.util.Collection;

public class UnresolvedIdeDependencyHandler {

    private final Logger logger = Logging.getLogger(UnresolvedIdeDependencyHandler.class);

    public void log(Collection<UnresolvedDependencyResult> deps) {
        for (UnresolvedDependencyResult dep : deps) {
            log(dep);
        }
    }

import org.codelibs.fess.dict.DictionaryFile;
import org.codelibs.fess.dict.DictionaryItem;

public class StopwordsCreator extends DictionaryCreator {
    private static final Logger logger = LogManager.getLogger(StopwordsCreator.class);

    public StopwordsCreator() {
        super("stopwords.*\\.txt");
    }

    @PostConstruct
    public void register() {
        if (logger.isInfoEnabled()) {

import org.gradle.internal.dispatch.Dispatch;
import org.gradle.launcher.daemon.protocol.Cancel;

public class DaemonCancelForwarder implements Stoppable {
    private static final Logger LOGGER = Logging.getLogger(DaemonCancelForwarder.class);

    private final Runnable cancellationCallback;
    private final BuildCancellationToken cancellationToken;

import org.gradle.api.logging.Logger;
import org.gradle.api.logging.Logging;

import java.util.function.Supplier;

class SbtLoggerAdapter implements xsbti.Logger {
    private static final Logger LOGGER = Logging.getLogger(ZincScalaCompilerFactory.class);

    @Override
    public void error(Supplier<String> msg) {
        LOGGER.error(msg.get());
    }

    @Override
    public void warn(Supplier<String> msg) {

    }

    @Input
    public OutputType getOutputType() {
        return outputType;
    }

    @TaskAction
    public void process() {
        getLogger().quiet("Writing out the URL response from '{}' to '{}'", url, outputType);

        // retrieve content from URL and write to output
    }

    private static enum OutputType {
        CONSOLE, FILE
    }
}

import org.codelibs.fess.es.config.exentity.DuplicateHost;
import org.codelibs.fess.util.ComponentUtil;

public class DuplicateHostHelper {
    private static final Logger logger = LogManager.getLogger(DuplicateHostHelper.class);

    protected List<DuplicateHost> duplicateHostList;

    @PostConstruct
    public void init() {
        if (logger.isDebugEnabled()) {

import org.codelibs.fess.util.ComponentUtil;
import org.dbflute.util.DfTypeUtil;

/**
 * @author FreeGen
 */
public class FavoriteLogBhv extends BsFavoriteLogBhv {
    private static final Logger logger = LogManager.getLogger(FavoriteLogBhv.class);

    private String indexName = null;

    @Override
    protected String asEsIndex() {
        if (indexName == null) {

import org.codelibs.fess.util.ComponentUtil;
import org.dbflute.util.DfTypeUtil;

/**
 * @author FreeGen
 */
public class UserInfoBhv extends BsUserInfoBhv {
    private static final Logger logger = LogManager.getLogger(UserInfoBhv.class);

    private String indexName = null;

    @Override
    protected String asEsIndex() {
        if (indexName == null) {

import org.gradle.launcher.daemon.protocol.Status;
import org.gradle.launcher.daemon.protocol.Success;

public class ReportStatusDispatcher {
    private static final Logger LOGGER = Logging.getLogger(ReportStatusDispatcher.class);

    public Status dispatch(Connection<Message> connection, Command statusCommand) {
        Status returnedStatus = null;
        Throwable failure = null;
        try {