}
        """

        file("src/test/java/example2/MyOtherTest.java") << """
            package example2;
            public class MyOtherTest {
                @org.junit.Test public void bar() throws Exception {
                     org.junit.Assert.assertEquals(2, 2);
                }
            }
        """
        file("src/test/java/example2/MyOtherTest2.java") << """
            package example2;

import (
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	"k8s.io/apimachinery/pkg/runtime"
	"k8s.io/apimachinery/pkg/runtime/schema"
)

// GroupName is the group name use in this package
const GroupName = "example2.apiserver.k8s.io"

// SchemeGroupVersion is group version used to register these objects
var SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: "v1"}

http::b@www.example.com  s:http pass:b h:www.example.com p:/
http:/:b@www.example.com  s:http pass:b h:www.example.com p:/
http://:b@www.example.com  s:http pass:b h:www.example.com p:/
http:/:@/www.example.com
http://user@/www.example.com
http:@/www.example.com
http:/@/www.example.com
http://@/www.example.com
https:@/www.example.com
http:a:b@/www.example.com
http:/a:b@/www.example.com
http://a:b@/www.example.com
http::@/www.example.com

	"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"
	example2v1 "k8s.io/apiserver/pkg/apis/example2/v1"
	"k8s.io/apiserver/pkg/storage"
	"k8s.io/apiserver/pkg/storage/etcd3"
	etcd3testing "k8s.io/apiserver/pkg/storage/etcd3/testing"

	defer server.Terminate(t)
	versioner := storage.APIObjectVersioner{}

	makePod := func(name string) *example.Pod {
		return &example.Pod{
			ObjectMeta: metav1.ObjectMeta{Namespace: "ns", Name: name},
		}
	}
	createPod := func(obj *example.Pod) *example.Pod {
		key := "pods/" + obj.Namespace + "/" + obj.Name
		out := &example.Pod{}
		err := etcdStorage.Create(context.TODO(), key, obj, out, 0)
		require.NoError(t, err)

        def consoleOutput = """> Task :example1
toast
bacon
eggs
toast
ham
eggs
> Task :example2
toast
ham
eggs
toast
eggs
"""
        GroupedOutputFixture groupedOutput = new GroupedOutputFixture(LogContent.of(consoleOutput))

        when:
        groupedOutput.task(':example1').assertOutputContains("waffles")

        then:

	}
}

func TestDeviceRunContainerOptions(t *testing.T) {
	const (
		podUID        = "pod"
		containerName = "container"
		resource1     = "example1.com/resource1"
		resource2     = "example2.com/resource2"
	)
	testCases := []struct {
		description          string
		gate                 bool
		responsesPerResource map[string]*pluginapi.ContainerAllocateResponse

        data = "<img src=\"http://example/foo.jpg\">" //
                + "<img src=\"http://example/bar.jpg\">";
        expected = "http://example/foo.jpg";
        assertGetThumbnailUrl(data, expected);

        data = "<img src=\"http://example/foo.jpg\">" //
                + "<img src=\"http://example/bar.jpg\" width=\"100\" height=\"100\">";
        expected = "http://example/bar.jpg";
        assertGetThumbnailUrl(data, expected);

//     or Foo (with a "bar" suffix).
//
// Examples with malformed names are not associated with anything.
func classifyExamples(p *Package, examples []*Example) {
	if len(examples) == 0 {
		return
	}
	// Mapping of names for funcs, types, and methods to the example listing.
	ids := make(map[string]*[]*Example)
	ids[""] = &p.Examples // package-level examples have an empty name
	for _, f := range p.Funcs {

}

// Examples returns an object that can list and get Examples.
func (s *exampleLister) Examples(namespace string) ExampleNamespaceLister {
	return exampleNamespaceLister{listers.NewNamespaced[*v1.Example](s.ResourceIndexer, namespace)}
}

// ExampleNamespaceLister helps list and get Examples.
// All objects returned here must be treated as read-only.