description = "this is task \$name"
}
assert tasks.help.description == "this is task help"
"""

        expect:
        succeeds()
    }

    def "reports read unknown property from configure closure"() {
        buildFile << """
tasks.help {
    println unknown
}
"""

        expect:
        fails()

	configs, err := fileWatcher.ReadConfigFiles()
	g.Expect(err).NotTo(HaveOccurred())
	g.Expect(configs).To(HaveLen(1))
	g.Expect(configs[0].Domain).To(Equal("foo"))

	gateway := configs[0].Spec.(*networking.Gateway)
	g.Expect(gateway.Servers[0].Port.Number).To(Equal(uint32(80)))
	g.Expect(gateway.Servers[0].Port.Protocol).To(Equal("http"))
	g.Expect(gateway.Servers[0].Hosts).To(Equal([]string{"*.example.com"}))
}

		annotation  string
		environment string
		file        string
		expect      *meshconfig.ProxyConfig
	}{
		{
			name: "Defaults",
			expect: func() *meshconfig.ProxyConfig {
				m := mesh.DefaultProxyConfig()
				return m
			}(),
		},
		{
			name:       "Annotation Override",
			annotation: proxyOverride,
			expect:     overridesExpected,
		},
		{
			name:   "File Override",

class OutputFileChangesTest extends Specification implements TestSnapshotFixture {

    def "empties"() {
        expect:
        changes(
            FileSystemSnapshot.EMPTY,
            FileSystemSnapshot.EMPTY
        ) == []
    }

    def "equal hash for #current.type"() {
        expect:
        changes(previous, current) == []

        where:
        previous                        | current

    def "creates snapshot for string"() {
        expect:
        def snapshot = snapshotter.snapshot("abc")
        snapshot instanceof StringValueSnapshot
        snapshot == snapshotter.snapshot("abc")
        snapshot != snapshotter.snapshot("other")
    }

    def "creates snapshot for isolated string"() {
        expect:
        def isolated = isolatableFactory.isolate("abc")

model { thing { println "hi" } }

class Thing { }

return null
""")

        expect:
        scriptData.runDoesSomething
        !scriptData.data.hasImperativeStatements
        scriptData.hasMethods
    }

    def "imports are not considered imperative code"() {
        expect:
        def scriptData = parse("""import java.lang.String
import java.lang.*
import static java.lang.String.*

        String value;
        String expect;

        value = null;
        expect = "";
        assertEquals(expect, ParameterUtil.encrypt(value));

        value = "";
        expect = "";
        assertEquals(expect, ParameterUtil.encrypt(value));

        value = "\n";
        expect = "";
        assertEquals(expect, ParameterUtil.encrypt(value));

        value = "=";

	m := NewMessage(mt, nil, "Feta")

	g.Expect(m.Unstructured(true)).To(Not(HaveKey("origin")))
	g.Expect(m.Unstructured(false)).To(Not(HaveKey("origin")))

	m = NewMessage(mt, &resource.Instance{Origin: testOrigin{name: "toppings/cheese"}}, "Feta")

	g.Expect(m.Unstructured(true)).To((HaveKey("origin")))
	g.Expect(m.Unstructured(false)).To(Not(HaveKey("origin")))
}

        server.expect(server.put(m1.pom.path + ".sha512"))
        def putModule = server.expectAndBlock(server.put(m1.moduleMetadata.path))
        server.expect(server.put(m1.moduleMetadata.path + ".sha1"))
        server.expect(server.put(m1.moduleMetadata.path + ".md5"))
        server.expect(server.put(m1.moduleMetadata.path + ".sha256"))
        server.expect(server.put(m1.moduleMetadata.path + ".sha512"))

		name   string
		given  []v1.EndpointSubset
		expect []v1.EndpointSubset
	}{
		{
			name:   "empty everything",
			given:  []v1.EndpointSubset{{Addresses: []v1.EndpointAddress{}, Ports: []v1.EndpointPort{}}},
			expect: []v1.EndpointSubset{},
		}, {
			name:   "empty addresses",
			given:  []v1.EndpointSubset{{Addresses: []v1.EndpointAddress{}, Ports: []v1.EndpointPort{{Port: 111}}}},
			expect: []v1.EndpointSubset{},
		}, {