setup:
        def testFile = folder.createFile("test1")
        when:
        def object = parse(testFile)
        then:
        object instanceof File
        testFile == object
    }

    def "with Path returns the File it represents"() {
        setup:
        def testPath = folder.createFile("test1").toPath()
        when:
        def object = parse(testPath)
        then:

```

Verify that expected image eg: `user1/examples-bookinfo-*:test1.0` is updated in `platform/kube/bookinfo*.yaml` files.

## Tests

Test that the bookinfo samples work with the latest image eg: `user1/examples-bookinfo-*:test1.0` that you pushed.

```bash
$ cd ../../

							"fake",
						},
					},
					{
						Namespaces: []string{
							"test",
						},
					},
				},
			},
			true,
		},
		{
			"tested include difference namespace not skip",
			&v1.Pod{
				ObjectMeta: metav1.ObjectMeta{
					Name:      "in-test1",
					Namespace: "test",
					Labels: map[string]string{
						"l3": "lv3",
						"l4": "lv4",
					},

        binary1.name >> "test1"

        expect:
        container.add(binary1)
        container.realizeNow()
        def p = container.getByName("test1")

        p.present
        p.get() == binary1
    }

    def "querying the result of get by name fails when not realized"() {
        def binary1 = Stub(SwiftBinary)
        binary1.name >> "test1"

        given:

	// Do the simple thing to start with.
	for _, pkg := range test.packages() {
		test1 := *test
		test1.pkg, test1.pkgs = pkg, nil
		register1(&test1)
	}
}

// dirCmd constructs a Cmd intended to be run in the foreground.
// The command will be run in dir, and Stdout and Stderr will go to os.Stdout
// and os.Stderr.
func (t *tester) dirCmd(dir string, cmdline ...interface{}) *exec.Cmd {

# then it will try to load sleepybad, which does not compile,
# and the test command will fail.
! go list m/sleepy...
go test -c -n -coverprofile=$TMPDIR/cover.out -coverpkg=m/sleepy... -run=^$ m/sleepy1

-- go.mod --
module m

go 1.16
-- sleepy1/p_test.go --
package p

import (
	"testing"
	"time"
)

func Test1(t *testing.T) {
	time.Sleep(200 * time.Millisecond)
}
-- sleepy2/p_test.go --

// license that can be found in the LICENSE file.

package main

func main() {
	test1()
	test2()
}

type I interface {
	f()
	g()
	h()
}

//go:noinline
func ld[T any]() {
	var x I
	if _, ok := x.(T); ok {
	}
}

func isI(x any) {
	_ = x.(I)
}

func test1() {
	defer func() { recover() }()
	ld[bool]() // add <bool,I> itab to binary
	_ = any(false).(I)
}

        when:
        grammar("Test1", "Test2")
        then:
        succeeds("generateGrammarSource")

        test1TokenFile.exists()
        test1LexerFile.exists()
        test1ParserFile.exists()

        test2TokenFile.exists()
        test2LexerFile.exists()
        test2ParserFile.exists()

        when:
        removedGrammar("Test1")

        then:

			*(createTestStatus("test1", api.ConditionUnknown, "", "fizzbuzz error"))},
	}
	if e, a := expect, got; !reflect.DeepEqual(e, a) {
		t.Errorf("Got unexpected object. Diff: %s", cmp.Diff(e, a))
	}
}

func TestGet_NoError(t *testing.T) {
	r := NewTestREST(testResponse{result: probe.Success, data: "ok"})
	got, err := r.Get(genericapirequest.NewContext(), "test1", &metav1.GetOptions{})
	if err != nil {

}{
	// 127.0.0.1
	{"test", "test"},
	// 127.0.0.2
	{"test2.example.com", "test2.example.com"},
	{"2.test", "test2.example.com"},
	// 127.0.0.3
	{"test3.example.com", "3.test"},
	{"3.test", "3.test"},
	// 127.0.0.4
	{"example.com", "example.com"},
	// 127.0.0.5
	{"test5.example.com", "test4.example.com"},
	{"5.test", "test4.example.com"},
	{"4.test", "test4.example.com"},