def "tests output of missingValueMessage"() {
        when:
        render(missingValueMessage {
            type('SomeType')
            property('someProperty')
        })

        then:
        outputEquals """
Type 'SomeType' property 'someProperty' doesn't have a configured value.

Reason: This property isn't marked as optional and no value has been configured.

Possible solutions:

    def "formats signature"() {
        MethodMetaData method = Mock()
        def parameter = new ParameterMetaData('param')
        def type = new TypeMetaData('org.gradle.SomeType')
        parameter.type = type

        expect:
        parameter.signature == 'org.gradle.SomeType param'
    }

    def store = new DefaultModelSchemaStore(DefaultModelSchemaExtractor.withDefaultStrategies())

    def "assembles schema for unmanaged type"() {
        expect:
        def schema = store.getSchema(ModelType.of(SomeType))
        schema instanceof UnmanagedImplStructSchema
        !(schema instanceof ManagedImplSchema)
        !(schema instanceof CompositeSchema)
        schema instanceof StructSchema
        !schema.annotated

    def store = new DefaultModelSchemaStore(DefaultModelSchemaExtractor.withDefaultStrategies())

    def "assembles schema for @Managed type"() {
        expect:
        def schema = store.getSchema(ModelType.of(SomeType))
        schema instanceof ManagedImplStructSchema
        schema instanceof ManagedImplSchema
        schema instanceof CompositeSchema
        schema instanceof StructSchema

    </buildSpec>
    <natures>
        <nature>org.eclipse.jdt.core.scalanature</nature>
    </natures>
    <linkedResources>
        <link>
            <name>somename</name>
            <type>sometype</type>
            <location>somelocation</location>
        </link>
    </linkedResources>
    <filteredResources>
        <filter>
            <id>1</id>
            <type>30</type>
            <name/>

*/

package fuzzer

import (
	"math/rand"

	"github.com/google/gofuzz"

	runtimeserializer "k8s.io/apimachinery/pkg/runtime/serializer"
)

// FuzzerFuncs returns a list of func(*SomeType, c fuzz.Continue) functions.
type FuzzerFuncs func(codecs runtimeserializer.CodecFactory) []interface{}

// FuzzerFor can randomly populate api objects that are destined for version.

        when:
        def publishArtifact = publishArtifactNotationParser.parseNotation(file: file, type: 'someType', builtBy: task)

        then:
        publishArtifact instanceof DefaultPublishArtifact
        publishArtifact.file == file
        publishArtifact.type == 'someType'
        publishArtifact.name == 'some-file'
        publishArtifact.extension == 'zip'

    }

    def "can serialize/deserialize isolated Attribute values"() {
        Attribute attr1 = Attribute.of("foo", String.class)
        Attribute attr2 = Attribute.of("bar", SomeType.class)
        Isolatable<?>[] isolatables = [isolatableFactory.isolate(attr1), isolatableFactory.isolate(attr2)]

        when:
        serialize(isolatables)

        and:

    def static final CUSTOM_NATURES = ['org.eclipse.jdt.core.scalanature']
    def static final CUSTOM_LINKED_RESOURCES = [new Link('somename', 'sometype', 'somelocation', '')] as Set
    def static final CUSTOM_RESOURCE_FILTERS = [

    def "renders sensible value for node whose toString() method returns null"() {
        given:
        buildFile << """
            @Managed abstract class SomeType {
                String toString() { null }
            }
            model {
                something(SomeType)
            }
        """.stripIndent()

        when:
        succeeds 'model'

        then: