"""
    }

    @ToBeFixedForConfigurationCache
    def "ignores target machine not buildable from project configuration dimensions"() {
        assumeFalse(toolChain.meets(WINDOWS_GCC))

        when:
        componentUnderTest.writeToProject(testDirectory)
        makeSingleProject()
        buildFile << """

    }

    /**
     * Locates a tool chain that meets the given criteria, if any.
     *
     * @return null if there is no such tool chain.
     */
    @Nullable
    public static InstalledToolChain getToolChain(ToolChainRequirement requirement) {
        for (ToolChainCandidate toolChainCandidate : getToolChains()) {
            if (toolChainCandidate.meets(requirement)) {

		conditionType        CustomResourceDefinitionConditionType
		expectedcrdCondition []CustomResourceDefinitionCondition
	}{
		{
			name: "test remove CRDCondition when the conditionType meets",
			crdCondition: []CustomResourceDefinitionCondition{
				{
					Type:               Established,
					Status:             ConditionTrue,
					Reason:             "Accepted",

        given:
        buildFile << """
            model {
                binaries {
                    all { ${compilerTool}.args ${toolChain.meets(ToolChainRequirement.VISUALCPP_2013_OR_NEWER) ? "'/Zi', '/FS'" : "'/Zi'"}; linker.args '/DEBUG'; }
                }
            }
        """
        run "mainExecutable"

		conditionType        apiextensionsv1.CustomResourceDefinitionConditionType
		expectedcrdCondition []apiextensionsv1.CustomResourceDefinitionCondition
	}{
		{
			name: "test remove CRDCondition when the conditionType meets",
			crdCondition: []apiextensionsv1.CustomResourceDefinitionCondition{
				{
					Type:               apiextensionsv1.Established,
					Status:             apiextensionsv1.ConditionTrue,

							t.Errorf("Expected validations '%s' error to contain '%v' but got: %v", expr, expectErr, result.Error)
						}
						meets[i] = true
					}
				}
			}
			for i, meet := range meets {
				if !meet && CompilationResults[i].Error != nil {
					t.Errorf("Unexpected err '%v' for expression '%s'", CompilationResults[i].Error, validations[i].GetExpression())
				}
			}
		})

# because B2 is hidden — B1 is the next-highest version that is not hidden.
# However, if we downgrade D, we will also downgrade C to C1.
# And C1 requires B2.hidden, and B2.hidden also meets our requirements:
# it is compatible with D1 and a strict downgrade from B3.
#
# Since neither the initial nor the final build list includes B1,
# and the nothing in the final downgraded build list requires E at all,

	RequireExternalControlPlaneTopology() Suite
	// RequireMinVersion validates the environment meets a minimum version
	RequireMinVersion(minorVersion uint) Suite
	// RequireMaxVersion validates the environment meets a maximum version
	RequireMaxVersion(minorVersion uint) Suite
	// Setup runs enqueues the given setup function to run before test execution.

    }

    @RequiresInstalledToolChain(GCC_COMPATIBLE)
    @ToBeFixedForConfigurationCache
    def "target platforms"() {
        assumeTrue(toolchainUnderTest.meets(SUPPORTS_32))

        given:
        sample targetPlatforms

        and:
        targetPlatforms.dir.file("build.gradle") << """
model {
    toolChains {
        all{
            target("arm"){

type sstring struct {
	s string
}

func (s *sstring) String() string {
	return s.s
}

func stringer(s string) interface{} {
	return &sstring{s}
}

// wellFormed ensures that a red-black tree meets
// all of its invariants and returns a string identifying
// the first problem encountered. If there is no problem
// then the returned string is empty. The size is also
// returned to allow comparison of calculated tree size