type ExamplesGetter interface {
	Examples(namespace string) ExampleInterface
}

// ExampleInterface has methods to work with Example resources.
type ExampleInterface interface {
	Create(ctx context.Context, example *v1.Example, opts metav1.CreateOptions) (*v1.Example, error)
	Update(ctx context.Context, example *v1.Example, opts metav1.UpdateOptions) (*v1.Example, error)

	barSecond := &example.Pod{ObjectMeta: metav1.ObjectMeta{Namespace: "second", Name: "bar"}}
	fooSecond := &example.Pod{ObjectMeta: metav1.ObjectMeta{Namespace: "second", Name: "foo"}}
	bazSecond := &example.Pod{ObjectMeta: metav1.ObjectMeta{Namespace: "second", Name: "baz"}}
	barfooThird := &example.Pod{ObjectMeta: metav1.ObjectMeta{Namespace: "third", Name: "barfoo"}}

		},
		"normalFiltered": {
			in:  &example.PodList{Items: []example.Pod{*podA, *podB}},
			m:   matchPodName("foo"),
			out: &example.PodList{Items: []example.Pod{*podB}},
		},
		"normalFilteredNoNamespace": {
			in:      &example.PodList{Items: []example.Pod{*podA, *podB}},
			m:       matchPodName("foo"),
			out:     &example.PodList{Items: []example.Pod{*podB}},
			context: noNamespaceContext,
		},

        }

        file("src/test/java/org/example/PublishedApiTestPluginTest.java") << pluginTestJava()
    }

    def "can compile Java code against public API"() {
        buildFile << configureApiWithPlugin('id("java-library")')

        file("src/main/java/org/example/PublishedApiTestPlugin.java") << """
            package org.example;

            import org.gradle.api.Plugin;

					Dest:      "not-default.example.com",
					Time:      TimeNewer,
				},
			},
			proxy:     proxy("not-default"),
			routeName: "80",
			expected: map[string][]string{
				// Oldest wins
				"known.default.svc.cluster.local": {"outbound|80||arbitrary.example.com"},
			},
			expectedGateway: map[string][]string{
				"known.default.svc.cluster.local": {"outbound|80||not-default.example.com"},
			},
		},

	// settings specified at the destination level
	g.Expect(getTLSContext(t, xdstest.ExtractCluster("outbound|8080|foobar|foo.example.org", clusters))).To(BeNil())

	expected := []string{
		"outbound|8080||foo.example.org",
		"outbound|9090||foo.example.org",
		"outbound|9090|foobar|foo.example.org",
	}
	for _, e := range expected {
		c := xdstest.ExtractCluster(e, clusters)
		tlsContext := getTLSContext(t, c)

                .value("task ':dependencyTask'")
                .cannotBeConvertedTo(targetType)
                .candidates(
                    "a String or CharSequence path, for example 'src/main/java' or '/usr/include'",
                    "a String or CharSequence URI, for example 'file:/usr/include'",
                    "a File instance",
                    "a Path instance",
                    "a Directory instance",

	badName := "!@#$%^"
	badValue := "spaces not allowed"
	badAPIGroup := "example.com/v1"
	goodAPIGroup := "example.com"

	scenarios := map[string]struct {
		class        *resource.ResourceClass
		wantFailures field.ErrorList
	}{
		"good-class": {
			class: testClass(goodName, goodName),
		},
		"good-long-driver-name": {
			class: testClass(goodName, "acme.example.com"),
		},
		"missing-name": {

	"k8s.io/apimachinery/pkg/runtime"
	"k8s.io/apimachinery/pkg/runtime/schema"
	"k8s.io/apimachinery/pkg/runtime/serializer"
	utilruntime "k8s.io/apimachinery/pkg/util/runtime"
	"k8s.io/apiserver/pkg/apis/example"
	examplev1 "k8s.io/apiserver/pkg/apis/example/v1"
	"k8s.io/apiserver/pkg/storage/etcd3/testing/testingcert"
	"k8s.io/apiserver/pkg/storage/etcd3/testserver"
	"k8s.io/apiserver/pkg/storage/storagebackend"
)

var scheme = runtime.NewScheme()

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

plugins {
    id("gradlebuild.internal.java")
    id("application")
}

description = "Example client application using the build-cache library"

dependencies {
    implementation(projects.buildCache)
    implementation(projects.buildCacheBase)
    implementation(projects.buildCacheLocal)