if err != nil {
		t.Errorf("%v", err)
	}

	expectedOrder := []string{"a", "b", "c", "aa", "bb", "cc"}
	var resultStruct struct {
		Strings []string `asn1:"set"`
	}
	rest, err := Unmarshal(output, &resultStruct)
	if err != nil {
		t.Errorf("%v", err)
	}
	if len(rest) != 0 {
		t.Error("Unmarshal returned extra garbage")
	}
	if !reflect.DeepEqual(expectedOrder, resultStruct.Strings) {

        then:
        assertOrder(metadata, "8.0", "8.3", "8.2", "8.1", "8.8", "8.7", "8.4")
    }

    static void assertOrder(List<JvmInstallationMetadata> list, String[] expectedOrder) {
        assert list*.javaVersion as String[] == expectedOrder
    }

    JvmInstallationMetadata jvmMetadata(String implementationVersion, boolean isJdk = false, KnownJvmVendor jvmVendor = ADOPTOPENJDK, String installPath = null) {

        }
        this
    }

    def hasDescendantsInOrder(String... relativePaths) {
        def expectedOrder = CollectionUtils.toList(relativePaths)
        def actualOrder = CollectionUtils.toList(filesByRelativePath.keySet())
        assertEquals(actualOrder, expectedOrder)
        this
    }

    def containsDescendants(String... relativePaths) {
        for (String path : relativePaths) {

		name          string
		options       RunnerOptions
		expectedOrder []string
	}{
		{
			name:          "Run respect runCondition",
			expectedOrder: []string{"foo", "bar", "qux"},
		},
		{
			name:          "Run takes options into account",
			options:       RunnerOptions{FilterPhases: []string{"foo"}, SkipPhases: []string{"foo/baz"}},
			expectedOrder: []string{"foo", "bar"},
		},
	}

            search.addAll(operation.children)
            operation = search.poll()
        }
    }

    void orderedSerialSiblings(BuildOperationRecord... expectedOrder) {
        def expectedOrderList = expectedOrder.toList()
        assert expectedOrder*.parentId.unique().size() == 1
        def startTimeOrdered = expectedOrderList.sort(false) { it.startTime }
        assert expectedOrderList == startTimeOrdered

        executer.withTasks("cleanEclipse").run()
    }

    @Test
    @ToBeFixedForConfigurationCache
    void sourceEntriesInClasspathFileAreSortedAsPerUsualConvention() {
        def expectedOrder = [
            "src/main/java",
            "src/main/groovy",
            "src/main/resources",
            "src/test/java",
            "src/test/groovy",
            "src/test/resources",

	defer testKubelet.Cleanup()
	kubelet := testKubelet.kubelet
	numContainers := 10
	expectedOrder := []string{}
	cStatuses := []*kubecontainer.Status{}
	specContainerList := []v1.Container{}
	for i := 0; i < numContainers; i++ {
		id := fmt.Sprintf("%v", i)
		containerName := fmt.Sprintf("%vcontainer", id)
		expectedOrder = append(expectedOrder, containerName)
		cStatus := &kubecontainer.Status{