buildScript '''
            enum Gender {
                FEMALE, MALE, OTHER
            }

            @Managed
            interface Person {
              String getName()
              void setName(String string)

              Gender getGender()
              void setGender(Gender gender)
            }

            class Rules extends RuleSource {
              @Model
              void p1(Person p1) {}

            addRegularDependency(
                buildKtSdkModule {
                    this.platform = platform
                    addBinaryRootsFromJdkHome(jdkHome.toPath(), isJre = false)
                    sdkName = "JDK for $moduleName"
                }
            )
        }
    }

    val configLanguageVersionSettings = compilerConfig[CommonConfigurationKeys.LANGUAGE_VERSION_SETTINGS]

    @Test
    void testToStringNullSafe() {
        assertNotNull(new MailingList().toString());
    }

    public void testToStringNotNonsense() {
        MailingList list = new MailingList();
        list.setName("modello-dev");

        String s = list.toString();

        assertEquals("MailingList {name=modello-dev, archive=null}", s);
    }

    @Override
    protected void setUp() throws Exception {
        super.setUp();
        {
            xpathTransformer = new XpathTransformer();
            xpathTransformer.setName("xpathTransformer");
            Map<String, String> featureMap = newHashMap();
            featureMap.put("http://xml.org/sax/features/namespaces", "false");
            xpathTransformer.setFeatureMap(featureMap);

        then:
        registry.realize("bar", NamedThingInterface).name == "bar"
    }


    @Managed
    static abstract class NonNamedThing {
        abstract String getName()

        abstract void setName(String name)
    }

    def "named struct does not have name populated if does not implement named"() {
        when:
        registry.registerWithInitializer("foo", NonNamedThing, nodeInitializerRegistry)

		SetType:  HashIPPort,
	}
	setName := "NOT"
	fcmd := fakeexec.FakeCmd{
		CombinedOutputScript: []fakeexec.FakeAction{
			// Success
			func() ([]byte, []byte, error) {
				return []byte("10.120.7.100,tcp:8080 is in set " + setName + "."), nil, nil
			},
			// Failure
			func() ([]byte, []byte, error) {
				return []byte("192.168.1.3,tcp:8080 is NOT in set " + setName + "."), nil, &fakeexec.FakeExitError{Status: 1}

        when:
        wrapper.setScriptFile("build/$inName")

        then:
        getProject().file("build/$outName") == wrapper.getBatchScript()

        where:
        inName           | outName
        "gradle.sh"      | "gradle.bat"
        "gradle-wrapper" | "gradle-wrapper.bat"
    }

    def "determines properties file path from jar path"() {
        given:

                    conf(baseMethod("base:name:1.0"))
                    conf(subMethod("sub:name:1.0"))
                }
            }
        """
        file("settings.gradle") << defineSettings(typeSafeProjectAccessors)

        expect:
        succeeds("build")
        outputContains("base:name:1.0")
        outputContains("sub:name:1.0")

        where:
        typeSafeProjectAccessors << [true, false]
    }

                @Test
                public void checkThreadName() {
                    assertEquals("Test worker", Thread.currentThread().getName());
                    Thread.currentThread().setName(getClass().getSimpleName());
                }
            }
        """.stripIndent()
    }

        } catch (Throwable t) {
            throw t
        }
    }

    void intercept(Action<Void> action) {
        MethodInfo methodInfo = new MethodInfo()
        methodInfo.setName('MockMethod')
        intercept(new MethodInvocation(null, null, null, null, null, methodInfo, null) {
            void proceed() throws Throwable {
                action.execute(null)
            }
        })
    }