t.Run(fmt.Sprintf("%d", idx), func(t *testing.T) {
			// Save a copy to report errors with
			tmp := make(host.Names, len(tt.in))
			copy(tmp, tt.in)

			sort.Sort(tt.in)
			if !reflect.DeepEqual(tt.in, tt.want) {
				t.Fatalf("sort.Sort(%v) = %v, want %v", tmp, tt.in, tt.want)
			}
		})
	}
}

func BenchmarkNamesSort(b *testing.B) {

	}
	return p[i].Msg < p[j].Msg
}

// Sort sorts an [ErrorList]. *[Error] entries are sorted by position,
// other errors are sorted by error message, and before any *[Error]
// entry.
func (p ErrorList) Sort() {
	sort.Sort(p)
}

// RemoveMultiples sorts an [ErrorList] and removes all but the first error per line.
func (p *ErrorList) RemoveMultiples() {
	sort.Sort(p)

// slices package to implement some `sort` functions faster. However, until
// the bootstrap compiler uses Go 1.21 or later, we keep a fallback version
// in sort_impl_120.go that retains the old implementation.

package sort

import "slices"

func intsImpl(x []int)         { slices.Sort(x) }
func float64sImpl(x []float64) { slices.Sort(x) }
func stringsImpl(x []string)   { slices.Sort(x) }

    void writeTo(File file) {
        sort()
        new ObjectMapper().writerWithDefaultPrettyPrinter().writeValue(file, this)
        file.append('\n')
    }

    PerformanceTestScenarioDefinition sort() {
        // Sort all fields before writing to get a deterministic result
        Collections.sort(performanceTests, { a, b -> a.testId <=> b.testId })

            sort = fessConfig.getQueryFacetFieldsSort();
        }
        if (StringUtil.isNotBlank(fessConfig.getQueryFacetFieldsMissing())) {
            missing = fessConfig.getQueryFacetFieldsMissing();
        }
    }

    public BucketOrder getBucketOrder() {
        if (StringUtil.isNotBlank(sort)) {
            final String[] values = sort.split("\\.");
            final boolean asc;

        given:
        def metadata = [
            jvmMetadata("6.0"),
            jvmMetadata("8.0"),
            jvmMetadata("11.0"),
            jvmMetadata("5.1")
        ]

        when:
        metadata.sort(new JvmInstallationMetadataComparator(getJavaHome()))

        then:
        assertOrder(metadata, "11.0", "8.0", "6.0", "5.1")
    }

    def "deterministically matches vendor over vendor-specific tool version"() {

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

//go:build !go1.21

package sort

func intsImpl(x []int)         { Sort(IntSlice(x)) }
func float64sImpl(x []float64) { Sort(Float64Slice(x)) }
func stringsImpl(x []string)   { Sort(StringSlice(x)) }

func intsAreSortedImpl(x []int) bool         { return IsSorted(IntSlice(x)) }

        expect:
        sort([prefer30, prefer10, prefer20]) == [prefer30, prefer20, prefer10]

        and:
        sort([prefer30, prefer10, prefer20, require20]) == [require20, prefer30, prefer20, prefer10]

        and:
        sort([prefer30, prefer10, prefer20, require20, require30]) == [require30, require20, prefer30, prefer20, prefer10]

        and:

	// Test that our comparison function is consistent with
	// sort.Float64s.
	input := []float64{1.0, 0.0, negzero, math.Inf(1), math.Inf(-1), math.NaN()}
	sort.Float64s(input)
	for i := 0; i < len(input)-1; i++ {
		if cmp.Less(input[i+1], input[i]) {
			t.Errorf("Less sort mismatch at %d in %v", i, input)
		}
		if cmp.Compare(input[i], input[i+1]) > 0 {
			t.Errorf("Compare sort mismatch at %d in %v", i, input)
		}
	}
}

		if len(user.Pets) != len(expect.Pets) {
			t.Fatalf("pets should equal, expect: %v, got %v", len(expect.Pets), len(user.Pets))
		}

		sort.Slice(user.Pets, func(i, j int) bool {
			return user.Pets[i].ID > user.Pets[j].ID
		})

		sort.Slice(expect.Pets, func(i, j int) bool {
			return expect.Pets[i].ID > expect.Pets[j].ID
		})

		for idx, pet := range user.Pets {