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"() {

            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;

func TestSortOrderedInts() bool {
	return testOrdered("ints", ints, sort.Ints)
}

func TestSortOrderedFloat64s() bool {
	return testOrdered("float64s", float64s, sort.Float64s)
}

func TestSortOrderedStrings() bool {
	return testOrdered("strings", strings, sort.Strings)
}

func testOrdered[Elem Ordered](name string, s []Elem, sorter func([]Elem)) bool {

					}
				}
			}

			leases, err := fakeReconciler.ListLeases()
			if err != nil {
				t.Errorf("unexpected error: %v", err)
			}
			// sort for comparison
			sort.Strings(leases)
			sort.Strings(test.expectLeases)
			if !reflect.DeepEqual(leases, test.expectLeases) {
				t.Errorf("expected %v got: %v", test.expectLeases, leases)
			}

			for _, server := range test.servers {

        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 err != nil {
		log.Fatal(err)
	}

	// Print out each step with communities ordered.
	for _, d := range p {
		comm := d.Communities()
		for _, c := range comm {
			sort.Sort(ordered.ByID(c))
		}
		sort.Sort(ordered.BySliceIDs(comm))
		fmt.Printf("Low:%.2v High:%.2v Score:%v Communities:%v Q=%.3v\n",
			d.Low, d.High, d.Score, comm, community.Q(g, comm, d.Low))
	}

	// Output:

		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 {

        expect:
        def l = [1, 2, 3]
        !sort(l, naturalComparator).is(l)

        and:
        sort([2, 1, 3], naturalComparator) == [1, 2, 3]
        sort([2, 1, 3] as Set, naturalComparator) == [1, 2, 3]
        sort([], naturalComparator) == []
        sort([] as Set, naturalComparator) == []
    }

    def "sorting"() {
        expect:

		spc.setPodRunning(set, 5)
		originalPods, _ := spc.setPodReady(set, 4)
		sort.Sort(ascendingOrdinal(originalPods))
		if _, err := ssc.UpdateStatefulSet(context.TODO(), set, originalPods); err != nil {
			t.Fatal(err)
		}
		pods, err := spc.podsLister.Pods(set.Namespace).List(selector)
		if err != nil {
			t.Fatal(err)
		}
		sort.Sort(ascendingOrdinal(pods))
		// pods 0, 1,2, 4,5 should be present(note 3 is missing)