* limitations under the License.
 */

package org.gradle.internal.instantiation.generator;

import java.util.Comparator;

/**
 * Sorts GeneratedConstructors based on the number of parameters.
 *
 * When two constructors have the same number of parameters, we settle on a stable sort by looking at the names of the
 * types of the parameters.
 *
 */

        // However, the File.list spec leaves the order undefined, so no reasonable implementation should depend on it.
        // Making the hash order-independent by sorting the entries maximizes CC hits, even if the OS-returned order changes.
        Arrays.sort(entries)
        entries.forEach(hasher::putString)
        hasher.hash()
    } ?: NON_DIRECTORY_CHILDREN_NAMES_HASH

        def tree1 = new TestFileTree([fileVisitDetails1])
        def tree2 = new TestFileTree([fileVisitDetails2])

        when:
        FileTree sum = tree1.plus(tree2)

        then:
        sum.files.sort() == [file1, file2]
    }

    def "can add file trees together using + operator"() {
        File file1 = new File("f1")
        File file2 = new File("f2")

              }

              tasks {
                create("printPeople") {
                  doLast {
                    def people = $.people
                    def names = people*.name.sort().join(", ")
                    println "names: $names"
                  }
                }
              }
            }
        '''

        then:
        succeeds "printPeople"

            .memberFunctions
            .asSequence()
            .mapNotNull { it.javaMethod }
            .filterNot { objectMethods.contains(it) }
            .map { it.toGroovyScriptString() }
            .sorted()
            .joinToString(separator = "\n")
    }

    private
    fun Method.toGroovyScriptString(): String {
        val cleanedTypeParameters =
            if (typeParameters.isNotEmpty()) {

    }

    private List<String> filterChangesToReport(CtClass c, Set<CtMethod> methods) {
        return methods.findAll { isFirstPublicClassInHierarchy(it, c) }*.longName.sort()
    }

    private boolean isFirstPublicClassInHierarchy(CtMethod method, CtClass c) {
        List<CtClass> classesContainingMethod = []

        CtClass current = c
        while (current != null) {

                    val sortAcceptedApiChanges = tasks.register<gradlebuild.binarycompatibility.SortAcceptedApiChangesTask>("sortAcceptedApiChanges") {
                        group = "verification"
                        description = "Sort the accepted api changes file alphabetically"
                        apiChangesDirectory = layout.projectDirectory.dir("${ TextUtil.normaliseFileSeparators(firstAcceptedApiChangesFile.parentFile.absolutePath) }")
                    }

    private static String toListOfAnnotations(ImmutableSet<Class<? extends Annotation>> classes) {
        return classes.stream()
            .map(Class::getSimpleName)
            .map(s -> "@" + s)
            .sorted()
            .collect(forDisplay());
    }

    private static class DefaultTypeMetadata implements TypeMetadata {
        private final Class<?> type;

    }

    private
    fun getMergedContributorPullRequests(pageNumber: Int): List<GitHubPullRequest> {
        val uri = "https://api.github.com/search/issues?q=is:pr+is:merged+repo:gradle/gradle+label:%22from:contributor%22&sort=updated&order=desc&per_page=$pageSize&page=$pageNumber"
        return invokeGitHubApi(uri, GitHubPullRequestSearchResult::class.java).items
    }

            sb.append("<").append(onlyType).append(">");
        } else {
            sb.append("<T>; where T is one of [");
            Joiner.on(", ").appendTo(sb, CollectionUtils.sort(Iterables.transform(creatableTypes, new Function<Class<?>, String>() {
                @Override
                public String apply(Class<?> input) {
                    return input.getName();
                }