def "cannot have read only property of scalar type #someType.simpleName"() {

        when:
        def clazz = classLoader.parseClass """
            import org.gradle.api.artifacts.Configuration.State
            import org.gradle.model.Managed

            @Managed
            interface ManagedType {
                $someType.canonicalName getManagedProperty()
            }

        """

    String getContainerStringRepresentation() {
        return "SomeType container"
    }

    String makeContainer() {
        return "project.container(SomeType)"
    }

    static String getContainerType() {
        return "NamedDomainObjectContainer"
    }

    def setup() {
        settingsFile << """
            class SomeType implements Named {
                final String name

        given:
        _ * provider1.getType() >> SomeType.class
        _ * provider2.getType() >> SomeOtherType.class
        _ * provider3.getType() >> SomeType.class

        when:
        source.addPending(provider1)
        source.addPending(provider2)
        source.addPending(provider3)
        source.realizePending(SomeType.class)

        then:

    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'