}

    private Set<String> getChangedFileNames(boolean qualified = false) {
        // Get all of the files that do not have a zero last modified timestamp
        return getFiles(qualified) { it.lastModified() > 0 }
    }

    private Set<String> getFiles(boolean qualified = false, Predicate<File> criteria) {
        // Get all of the files that do not have a zero last modified timestamp
        def changed = new HashSet()

    @Override
    void transform(TransformOutputs outputs) {
        File baselineJarsDirectory = artifact.get().asFile
        if (baselineJarsDirectory.name == 'gradle-jars') {
            baselineJarsDirectory.listFiles().each {
                outputs.file(it)
            }
        }
    }

        when:
        succeeds('test', 'jacocoTestReport')

        then:
        file(REPORTING_BASE).listFiles().collect { it.name } as Set == ["jacoco", "tests"] as Set
        file(REPORT_HTML_DEFAULT_PATH).exists()
        file("${REPORTING_BASE}/jacoco/test").listFiles().collect { it.name } == ["html"]
        file("${REPORTING_BASE}/jacoco/test/html/org.gradle/Class1.java.html").exists()

    /**
     * Returns successfully resolved files. Ignores dependencies or files that cannot be resolved.
     *
     * @return resolved dependencies files
     * @since 3.3
     */
    Set<File> getFiles();

    /**
     * Returns successfully resolved files. Ignores dependencies or files that cannot be resolved.
     *
     * @param dependencySpec dependency spec
     * @return resolved dependencies files
     *

            return new File[0];
        }
        final File libDir = new File(libPath);
        if (!libDir.exists()) {
            return new File[0];
        }
        return libDir.listFiles((file, name) -> name.startsWith(namePrefix));
    }

    public static File[] getPluginJarFiles(final String namePrefix) {
        return getPluginJarFiles((file, name) -> name.startsWith(namePrefix));
    }

import org.junit.Rule

import static org.gradle.test.fixtures.server.http.HttpServer.SupportedHash.*
import static org.gradle.util.internal.GFileUtils.deleteDirectory
import static org.gradle.util.internal.GFileUtils.listFiles

class ConfigurationCacheIvyPublishIntegrationTest extends AbstractConfigurationCacheIntegrationTest {

    @Rule
    public final HttpServer server = new HttpServer().tap {

        final List<File> fileList = new ArrayList<>(
                FileUtils.listFiles(new File(baseDir, "images"), fessConfig.getSupportedUploadedMediaExtentionsAsArray(), true));
        fileList.addAll(FileUtils.listFiles(new File(baseDir, "css"), fessConfig.getSupportedUploadedCssExtentionsAsArray(), true));
        fileList.addAll(FileUtils.listFiles(new File(baseDir, "js"), fessConfig.getSupportedUploadedJsExtentionsAsArray(), true));

                artifactFiles.from {
                    configurations.getByName("compileClasspath").getResolvedConfiguration()
                        .getLenientConfiguration()
                        .getFiles()
                }
            }
        """

        expect:
        succeeds "resolve"
    }

        extension.getClasspath().from(runtimeClasspath);
        extension.getSourceRoots().from(sourcesPath.getIncoming().artifactView(v -> v.lenient(true)).getFiles());
        extension.getDocumentedSource().from(sourcesPath.getIncoming().artifactView(v -> v.lenient(true)).getFiles().getAsFileTree().matching(f -> {
            f.include(PublicApi.INSTANCE.getIncludes());
            // Filter out any non-public APIs

                files.append(pathname)

    files = normalize_files(files)
    outfiles = []
    for pathname in files:
        basename = os.path.basename(pathname)
        extension = file_extension(pathname)
        if extension in extensions or basename in extensions:
            outfiles.append(pathname)
    return outfiles


def get_dates():
    years = datetime.datetime.now().year