var tests = []struct {
		name         string
		args         map[string]string
		expectedArgs []kubeadmapi.Arg
	}{
		{
			name:         "nil map returns nil args",
			args:         nil,
			expectedArgs: nil,
		},
		{
			name: "valid args are parsed (sorted)",
			args: map[string]string{"c": "d", "a": "b"},
			expectedArgs: []kubeadmapi.Arg{
				{Name: "a", Value: "b"},
				{Name: "c", Value: "d"},
			},
		},

		args         []Arg
		name         string
		value        string
		nArgs        int
		expectedArgs []Arg
	}{
		{
			testName:     "update 1 argument",
			args:         []Arg{{Name: "foo", Value: "bar1"}, {Name: "foo", Value: "bar2"}},
			name:         "foo",
			value:        "zz",
			nArgs:        1,
			expectedArgs: []Arg{{Name: "foo", Value: "bar1"}, {Name: "foo", Value: "zz"}},
		},
		{

func notSupportedOutput() exectesting.FakeAction {
	return fakeResultOutput(&DriverStatus{StatusNotSupported, "", "", "", false, nil, 0})
}

func sameArgs(args, expectedArgs []string) bool {
	if len(args) != len(expectedArgs) {
		return false
	}
	for i, v := range args {
		if v != expectedArgs[i] {
			return false
		}
	}
	return true
}

func fakeVolumeSpec() *volume.Spec {
	vol := &v1.Volume{
		Name: "vol1",

    def "ignores install name for all major operating system"() {
        given:
        def testDir = tmpDirProvider.testDirectory
        def outputFile = testDir.file("output/lib")

        final expectedArgs = [
            "-emit-library",
            "-o", outputFile.absolutePath,
            testDir.file("one.o").absolutePath].flatten()

        when:
        NativePlatform platform = Mock(NativePlatform)

        1 * queue.add(invocation)
        1 * queue.setLogLocation(LOG_LOCATION)
        0 * _
    }

    def "ignores install name for windows"() {
        given:
        def testDir = tmpDirProvider.testDirectory
        def outputFile = testDir.file("output/lib")

        final expectedArgs = [
                "-shared",

        ToolType.OBJECTIVECPP_COMPILER | ['-x', 'objective-c++']
        ToolType.ASSEMBLER             | []
    }

    CompilerMetaDataProvider.CompilerExecSpec assertingCompilerExecSpecArguments(Iterable<String> expectedArgs) {
        return new CompilerMetaDataProvider.CompilerExecSpec() {
            @Override
            CompilerMetaDataProvider.CompilerExecSpec environment(String key, String value) {
                return this

        given:
        def compiler = getCompiler()
        def testDir = tmpDirProvider.testDirectory
        def includeDir = testDir.file("includes")
        def systemIncludeDir = testDir.file("system")
        def expectedArgs = getCompilerSpecificArguments(includeDir, systemIncludeDir)

        when:
        NativeCompileSpec compileSpec = Stub(getCompileSpecType()) {
            getMacros() >> [foo: "bar", empty: null]

	}
}

func TestExpandCommandAndArgs(t *testing.T) {
	cases := []struct {
		name            string
		container       *v1.Container
		envs            []EnvVar
		expectedCommand []string
		expectedArgs    []string
	}{
		{
			name:      "none",
			container: &v1.Container{},
		},
		{
			name: "command expanded",
			container: &v1.Container{
				Command: []string{"foo", "$(VAR_TEST)", "$(VAR_TEST2)"},

		ccc          componentbaseconfig.ClientConnectionConfiguration
		expectedErrs field.ErrorList
	}{
		"successful 0 value": {
			ccc:          componentbaseconfig.ClientConnectionConfiguration{Burst: 0},
			expectedErrs: field.ErrorList{},
		},
		"successful 5 value": {
			ccc:          componentbaseconfig.ClientConnectionConfiguration{Burst: 5},
			expectedErrs: field.ErrorList{},
		},
		"burst < 0": {

		NewMessageType(Warning, "B1", "Template: %q"),
		MockResource("B"),
		"B",
	)

	msgs := Messages{fifthMsg, fourthMsg, thirdMsg, secondMsg, firstMsg}
	expectedMsgs := Messages{firstMsg, secondMsg, thirdMsg, fourthMsg, fifthMsg}

	msgs.Sort()

	g.Expect(msgs).To(Equal(expectedMsgs))
}

func TestMessages_SortWithNilOrigin(t *testing.T) {
	g := NewWithT(t)

	firstMsg := NewMessage(
		NewMessageType(Error, "B1", "Template: %q"),