From aa2e7fe688f82205a91f9d859365a870f2590e24 Mon Sep 17 00:00:00 2001
From: Yifan Gu <yifan.gu@coreos.com>
Date: Thu, 26 Mar 2015 15:06:27 -0700
Subject: [PATCH 1/2] kubelet_test: Add verifyUnorderedCalls().

This fixes TestSyncPodsDeletesWithNoPodInfraContainer.
Since we need to sync two pods in parallel, we should not verify
the docker calls in strict order.
---
 pkg/kubelet/dockertools/fake_docker_client.go | 18 ++++++++++++++++++
 pkg/kubelet/kubelet_test.go                   |  9 ++++++++-
 2 files changed, 26 insertions(+), 1 deletion(-)

diff --git a/pkg/kubelet/dockertools/fake_docker_client.go b/pkg/kubelet/dockertools/fake_docker_client.go
index ceb851ca4a1..ea6df4b1560 100644
--- a/pkg/kubelet/dockertools/fake_docker_client.go
+++ b/pkg/kubelet/dockertools/fake_docker_client.go
@@ -19,6 +19,7 @@ package dockertools
 import (
 	"fmt"
 	"reflect"
+	"sort"
 	"sync"
 	"time"
 
@@ -66,6 +67,23 @@ func (f *FakeDockerClient) AssertCalls(calls []string) (err error) {
 	return
 }
 
+func (f *FakeDockerClient) AssertUnorderedCalls(calls []string) (err error) {
+	f.Lock()
+	defer f.Unlock()
+
+	var actual, expected []string
+	copy(actual, calls)
+	copy(expected, f.called)
+
+	sort.StringSlice(actual).Sort()
+	sort.StringSlice(expected).Sort()
+
+	if !reflect.DeepEqual(actual, expected) {
+		err = fmt.Errorf("expected(sorted) %#v, got(sorted) %#v", expected, actual)
+	}
+	return
+}
+
 // ListContainers is a test-spy implementation of DockerInterface.ListContainers.
 // It adds an entry "list" to the internal method call record.
 func (f *FakeDockerClient) ListContainers(options docker.ListContainersOptions) ([]docker.APIContainers, error) {
diff --git a/pkg/kubelet/kubelet_test.go b/pkg/kubelet/kubelet_test.go
index 9892f2fe323..533f1553abd 100644
--- a/pkg/kubelet/kubelet_test.go
+++ b/pkg/kubelet/kubelet_test.go
@@ -121,6 +121,13 @@ func verifyCalls(t *testing.T, fakeDocker *dockertools.FakeDockerClient, calls [
 	}
 }
 
+func verifyUnorderedCalls(t *testing.T, fakeDocker *dockertools.FakeDockerClient, calls []string) {
+	err := fakeDocker.AssertUnorderedCalls(calls)
+	if err != nil {
+		t.Error(err)
+	}
+}
+
 func verifyStringArrayEquals(t *testing.T, actual, expected []string) {
 	invalid := len(actual) != len(expected)
 	if !invalid {
@@ -819,7 +826,7 @@ func TestSyncPodsDeletesWithNoPodInfraContainer(t *testing.T) {
 	}
 	waitGroup.Wait()
 
-	verifyCalls(t, fakeDocker, []string{
+	verifyUnorderedCalls(t, fakeDocker, []string{
 		"list", "list", "list", "list", "inspect_container", "inspect_container", "list", "inspect_container", "inspect_container", "stop", "create", "start", "inspect_container", "create", "start", "list", "inspect_container", "inspect_container"})
 
 	// A map iteration is used to delete containers, so must not depend on

From e6820bd0ca6869654f35b231618bd3ca33478388 Mon Sep 17 00:00:00 2001
From: Yifan Gu <yifan.gu@coreos.com>
Date: Thu, 26 Mar 2015 15:14:02 -0700
Subject: [PATCH 2/2] kubelet_test: Fix verifyStringArrayEqualsAnyOrder().

Old implementation can not tell cases where strings are
repetitive. e.g. {"a", "b", "b"} and {"a", "a", "b"} will
be treated as correct.
---
 pkg/kubelet/kubelet_test.go | 27 ++++++++++-----------------
 1 file changed, 10 insertions(+), 17 deletions(-)

diff --git a/pkg/kubelet/kubelet_test.go b/pkg/kubelet/kubelet_test.go
index 533f1553abd..5bec9dc9155 100644
--- a/pkg/kubelet/kubelet_test.go
+++ b/pkg/kubelet/kubelet_test.go
@@ -27,6 +27,7 @@ import (
 	"path"
 	"reflect"
 	"regexp"
+	"sort"
 	"strconv"
 	"strings"
 	"sync"
@@ -143,23 +144,15 @@ func verifyStringArrayEquals(t *testing.T, actual, expected []string) {
 }
 
 func verifyStringArrayEqualsAnyOrder(t *testing.T, actual, expected []string) {
-	invalid := len(actual) != len(expected)
-	if !invalid {
-		for _, exp := range expected {
-			found := false
-			for _, act := range actual {
-				if exp == act {
-					found = true
-					break
-				}
-			}
-			if !found {
-				t.Errorf("Expected element %q not found in %#v", exp, actual)
-			}
-		}
-	}
-	if invalid {
-		t.Errorf("Expected: %#v, Actual: %#v", expected, actual)
+	var act, exp []string
+	copy(act, actual)
+	copy(exp, expected)
+
+	sort.StringSlice(act).Sort()
+	sort.StringSlice(exp).Sort()
+
+	if !reflect.DeepEqual(exp, act) {
+		t.Errorf("Expected(sorted): %#v, Actual(sorted): %#v", exp, act)
 	}
 }