return property;
    }
<% propertyCount.times { %>
    private String prop${it};

    public String getProp${it}() {
        return prop${it};
    }

    public void setProp${it}(String value) {
        prop${it} = value;
    }
<% } %>

            package org.gradle.api.plugins;
            class JavaPluginConvention {
                String _prop;
                String getProp() { return _prop; }
                void setProp(String value) { _prop = value; }
                String doSomething(String arg) { return arg; }
            }
        """)
        !GroovyObject.isAssignableFrom(original)

        expect:

                    p.extensions.create("thing", ExtensionImpl)
                }
            }

            class ExtensionImpl {
                String getProp() { return "value" }
                void setProp(String value) {
                    throw new RuntimeException("broken")
                }
            }
        """
        file("buildSrc/src/main/resources/META-INF/gradle-plugins/test.broken.properties") << """

	writeFD = uintptr(open(&writePath[0], 0x1 /* O_WRONLY */, 0))
	if writeFD == 0 {
		// It is hard to do anything here. Write to stderr just
		// in case user has root on device and has run
		//	adb shell setprop log.redirect-stdio true
		msg := []byte("runtime: cannot open /dev/log/main\x00")
		write(2, unsafe.Pointer(&msg[0]), int32(len(msg)))
		exit(2)
	}

	// Prepopulate the invariant header part.

    }

    def "plugin can create instance of interface with mutable properties"() {
        buildFile """
            interface Thing {
                String getProp()
                void setProp(String value)
            }

            def t = objects.newInstance(Thing)
            assert t.prop == null
            t.prop = "value"
            assert t.prop == "value"
"""

        expect:

        def v = isolated.coerce(cl)
        cl.isInstance(v)
        v.name == "value1"
    }

    interface BeanInterface {
        String getProp1()

        void setProp1(String value)
    }

    def "creates isolated managed interface"() {
        def instantiator = instantiatorFactory().inject()
        def original = instantiator.newInstance(BeanInterface)

        when:
        def sb1 = registry.get("beans.sb1", SpecialBean)

        then:
        sb1.other == "other"
    }

    static class SetProp extends RuleSource {
        @Mutate
        void m(@Path("foo") Bean bean) {}
    }

    def "when targeting by type, paths are interpreted relative to item"() {
        given:

        listenerManager.getBroadcaster(BuildListener).buildFinished(Stub(BuildResult))
    }

    interface Params extends BuildServiceParameters {
        String getProp()

        void setProp(String value)
    }

    static abstract class ServiceImpl implements BuildService<Params> {
        static List<ServiceImpl> instances = []

        String getProp() {
            return getParameters().prop

    response.use {
      assertEquals(200, response.code)
      assertEquals(Protocol.HTTP_2, response.protocol)
    }

    // Only logs to the test logger above
    // Will fail if "adb shell setprop log.tag.okhttp.Http2 DEBUG" is called
    assertEquals(setOf(OkHttpTest::class.java.name), testHandler.calls.keys)
  }

  fun testCachedRequest() {
    enableTls()

        snapshotter.snapshot(other) != snapshotter.snapshot(isolated)
    }

    interface BeanInterface {
        String getProp1()

        void setProp1(String value)
    }

    def "creates snapshot for managed interface"() {
        def instantiator = TestUtil.instantiatorFactory().inject()
        def value = instantiator.newInstance(BeanInterface)