description = "Ensures the accepted api changes file is kept alphabetically ordered to make merging changes to it easier"
    apiChangesDirectory = acceptedApiChangesDirectory
}

val sortAcceptedApiChanges = tasks.register<gradlebuild.binarycompatibility.SortAcceptedApiChangesTask>("sortAcceptedApiChanges") {
    group = "verification"
    description = "Sort the accepted api changes file alphabetically"
    apiChangesDirectory = acceptedApiChangesDirectory
}

                        group = "verification"
                        description = "Ensures the accepted api changes file is kept alphabetically ordered to make merging changes to it easier"
                        apiChangesDirectory = layout.projectDirectory.dir("${ TextUtil.normaliseFileSeparators(firstAcceptedApiChangesFile.parentFile.absolutePath) }")

		{"v1beta10", "v1beta2", true},
		{"foo", "v1beta2", false},
		{"bar", "foo", true},
		{"version1", "version2", true},  // Non kube-like versions are sorted alphabetically
		{"version1", "version10", true}, // Non kube-like versions are sorted alphabetically
	}

	for _, tc := range tests {
		if e, a := tc.expectedGreater, CompareKubeAwareVersionStrings(tc.v1, tc.v2) > 0; e != a {
			if e {

class InstrumentedPropertiesResourceGeneratorTest extends InstrumentationCodeGenTest {

    private static final ObjectMapper MAPPER = new ObjectMapper()

    def "should generate a resource with upgraded properties sorted alphabetically"() {
        given:
        def givenSource = source """
            package org.gradle.test;

            import org.gradle.api.provider.Property;

    }

    def "tasks are executed when they are ready and not necessarily alphabetically"() {
        buildFile << """
            tasks.getByPath(':b:pingA').dependsOn(':a:pingA')
            tasks.getByPath(':b:pingC').dependsOn([':b:pingA', ':b:pingB'])
        """

        expect:
        //project a and b are both executed even though alphabetically more important task is blocked

        doesNotHaveIncubatingLegend()
        doesNotPromptForRerunToFindMoreConfigurations()
    }

    def "If multiple resolvable configurations present with attributes, task reports them all, sorted alphabetically"() {
        given:
        buildFile << """
            configurations.create("someConf") {
                description = "My first custom configuration"
                assert canBeResolved

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package rand_test

import (
	. "math/rand"
	"testing"
)

// This test is first, in its own file with an alphabetically early name,
// to try to make sure that it runs early. It has the best chance of
// detecting deterministic seeding if it's the first test that runs.

func TestAuto(t *testing.T) {

func (s FlowSchemaSequence) Less(i, j int) bool {
	// the flow-schema w/ lower matching-precedence is prior
	if ip, jp := s[i].Spec.MatchingPrecedence, s[j].Spec.MatchingPrecedence; ip != jp {
		return ip < jp
	}
	// sort alphabetically
	return s[i].Name < s[j].Name
}

func (s FlowSchemaSequence) Swap(i, j int) {
	s[i], s[j] = s[j], s[i]

func MoreSpecific(a, b Name) bool {
	if len(a) == 0 && len(b) == 0 {
		return true // doesn't matter, they're both the empty string
	}

	// we sort longest to shortest, alphabetically, with wildcards last
	ai, aj := string(a[0]) == "*", string(b[0]) == "*"
	if ai && !aj {
		// h[i] is a wildcard, but h[j] isn't; therefore h[j] < h[i]
		return false
	} else if !ai && aj {

     */
    abstract long getElapsedTime();

    abstract String getDescription();

    /**
     * @return comparator that compares operations, slowest first, then alphabetically
     */
    public static Comparator<? super Operation> slowestFirst() {
        return new Comparator<Operation>() {
            @Override
            public int compare(Operation o1, Operation o2) {