matchImages:
    - "registry.io/foobar"
    defaultCacheDuration: 10m
    apiVersion: credentialprovider.kubelet.k8s.io/v1alpha1
    args:
    - --v=5
    env:
    - name: FOO
      value: BAR`,
			config:    nil,
			expectErr: true,
		},
		{
			name: "config with wrong apiversion",
			configData: `---
kind: CredentialProviderConfig
apiVersion: foobar/v1alpha1
providers:
  - name: test

            [fromString(), "Runtime.getRuntime().exec(command, new String[] {'FOOBAR=foobar'})", "", "foobar"],
            [fromGroovyString(), "Runtime.getRuntime().exec(command, new String[] {'FOOBAR=foobar'})", "", "foobar"],
            [fromStringArray(), "Runtime.getRuntime().exec(command, new String[] {'FOOBAR=foobar'})", "", "foobar"],
            // Null argument handling

     // CHECK: TPUCopyWithDynamicShape{{.*}}device = "foobar"
     %4, %5 = "tf.TPUCopyWithDynamicShape"(%0, %1, %2, %3) {operandSegmentSizes = array<i32: 2, 2>} : (tensor<2048xi32>, tensor<2048xi32>, tensor<i32>, tensor<i32>) -> (tensor<2048xi32>, tensor<2048xi32>)
    "tf.TPUExecute"(%4, %arg0) {device = "foobar"} : (tensor<2048xi32>, tensor<!tf_type.string>) -> ()
    return
}

// -----

			actual:    []string{"foo", "bar"},
			cached:    []string{"bar", "foo", "foobar"},
			missing:   []string{},
			redundant: []string{"foobar"},
		},
		{
			name:      "missing cached value",
			actual:    []string{"foo", "bar", "foobar"},
			cached:    []string{"bar", "foo"},
			missing:   []string{"foobar"},
			redundant: []string{},
		},
		{
			name:      "proper cache set",

eclipse {
  project {
    resourceFilter {
      appliesTo = 'FILES_AND_FOLDERS'
      type = 'EXCLUDE_ALL'
      matcher {
        id = 'org.eclipse.some.custom.matcher'
        arguments = 'foobar'
      }
    }
  }
}
        """
        when:
        run("eclipse")
        then:

        def resourceFilterXml = '''
        <filteredResources>
                <filter>

	assert.Equal(t, exp, got)

	got = kubelet.getPodPluginDir("abc123", "foobar")
	exp = filepath.Join(root, "pods/abc123/plugins/foobar")
	assert.Equal(t, exp, got)

	got = kubelet.getVolumeDevicePluginsDir()
	exp = filepath.Join(root, "plugins")
	assert.Equal(t, exp, got)

	got = kubelet.getVolumeDevicePluginDir("foobar")
	exp = filepath.Join(root, "plugins", "foobar", "volumeDevices")
	assert.Equal(t, exp, got)

                }

                @TaskAction
                void useIt() {
                    assert foo.get() == "foobar"
                }
            }
            tasks.register("mytask", MyTask) {
                conventionMapping.map("foo", { providerFactory.provider { "foobar" } })
                other.convention("other")
            }
        """

        expect:
        runAndFail 'mytask'

				{Kind: rbacv1.UserKind, Name: "foobar"},
			},
			user:      &user.DefaultInfo{Name: "foobar"},
			appliesTo: true,
			index:     0,
			testCase:  "single subject that matches username",
		},
		{
			subjects: []rbacv1.Subject{
				{Kind: rbacv1.UserKind, Name: "barfoo"},
				{Kind: rbacv1.UserKind, Name: "foobar"},
			},
			user:      &user.DefaultInfo{Name: "foobar"},
			appliesTo: true,
			index:     1,

    @Test
    fun `#isLegalAccessorName rejects illegal Kotlin extension names`() {

        assert(isLegalAccessorName("foo_bar"))
        assert(isLegalAccessorName("foo-bar"))
        assert(isLegalAccessorName("foo bar"))
        assert(isLegalAccessorName("'foo'bar'"))
        assert(isLegalAccessorName("foo${'$'}${'$'}bar"))

        assertFalse(isLegalAccessorName("foo`bar"))

  }
}

// -----

// CHECK-LABEL: @export_as_self
module @export_as_self attributes {tf_saved_model.semantics} {
  // CHECK: func @foobar
  // CHECK: func @baz
  // CHECK: func private @foobar_internal
  func.func @foobar()
    attributes {tf_saved_model.exported_names = ["foobar", "baz"]}
  {
    func.return
  }