out.print("<a class=\"sort\" style=\"width: " + maxLen + ";\" href=\"?fmt=detail&sort=name\">Name</a>");
        out.println("<a class=\"sort\" href=\"?fmt=detail&sort=size\">Size</a>");
        out.println("<a class=\"sort\" href=\"?fmt=detail&sort=type\">Type</a>");
        out.println("<a class=\"sort\" style=\"width: 180\" href=\"?fmt=detail&sort=date\">Modified</a><br clear='all'><p>");

	)
	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)

	}

	in := SortableResourceNames{
		api.ResourceName("foo"),
		api.ResourceName("42"),
		api.ResourceName("foobar"),
		api.ResourceName("foo"),
		api.ResourceName("bar"),
		api.ResourceName(""),
	}

	sort.Sort(in)
	if !reflect.DeepEqual(in, want) {
		t.Errorf("got %v, want %v", in, want)
	}

    }

    public boolean isDeleted() {
        return isUpdated() && newInputs.length == 0;
    }

    public void sort() {
        if (inputs != null) {
            Arrays.sort(inputs);
        }
        if (newInputs != null) {
            Arrays.sort(newInputs);
        }
    }

    @Override
    public int hashCode() {
        return Objects.hash(Arrays.hashCode(inputs), output);
    }

// Test generic sort function with two different pointer types in different packages,
// make sure only one instantiation is created.

import (
	"fmt"

	"cmd/compile/internal/test/testdata/mysort"
)

type MyString struct {
	string
}

func (a *MyString) Less(b *MyString) bool {
	return a.string < b.string
}

func main() {
	mysort.F()

	sl1 := []*mysort.MyInt{{7}, {1}, {4}, {6}}
	mysort.Sort(sl1)

// limitations under the License.

package host

import (
	"sort"
	"strings"
)

// Names is a collection of Name; it exists so it's easy to sort hostnames consistently across Istio.
// In a few locations we care about the order hostnames appear in Envoy config: primarily HTTP routes, but also in
// gateways, and for SNI. In those locations, we sort hostnames longest to shortest with wildcards last.
type Names []Name

    if (entry instanceof Map) {
        entry.collectEntries {
            [(it.key), sortDeep(it.value)]
        }.sort()
    } else if (entry instanceof Iterable) {
        entry.collect {
            sortDeep(it)
        }.sort()
    } else {
        entry
    }
}

private sort(String spec) {
    def jsonSlurper = new JsonSlurper()
    def parsed = jsonSlurper.parseText(spec)