}

    def "can read multiple batches of input from client"() {
        def dispatch = Mock(OutputEventListener)
        def stream = new StdInStream(dispatch)
        def text1 = "some text"
        def bytes1 = text1.bytes
        def text2 = "more"
        def bytes2 = text2.bytes

        when:
        async {
            start {
                def buffer = new byte[1024]

    }

    def canSerializeAndDeserializeException() {
        def cause1 = new RuntimeException("cause1")
        def cause2 = new RuntimeException("cause2")
        def failure = new TestMultiCauseException("message", [cause1, cause2])

        when:
        def baos = new ByteArrayOutputStream()
        new ObjectOutputStream(baos).writeObject(failure)

    }

    def "can serialize messages for multiple channels"() {
        def channelId1 = new ChannelIdentifier("channel 1")
        def channelId2 = new ChannelIdentifier("channel 2")
        def message1 = new ChannelMessage(channelId1, "payload 1")
        def message2 = new ChannelMessage(channelId2, "payload 2")
        def message3 = new ChannelMessage(channelId1, "payload 3")

        when:

    }

    def "adds other type to publication"() {
        def artifact = artifact("zip")

        when:
        publication.addCandidate(artifact)

        then:
        publication.defaultArtifactProvider.get() == set(artifact)
    }

    def "prefers war over jar artifact"() {
        def jar = artifact("jar")
        def war = artifact("war")

        when:

def get_str_id(item_id: str):
    return item_id


@app.get("/path/int/{item_id}")
def get_int_id(item_id: int):
    return item_id


@app.get("/path/float/{item_id}")
def get_float_id(item_id: float):
    return item_id


@app.get("/path/bool/{item_id}")
def get_bool_id(item_id: bool):
    return item_id


@app.get("/path/param/{item_id}")
def get_path_param_id(item_id: Optional[str] = Path()):

import spock.lang.Subject

class SnapshotSerializerTest extends Specification {

    def output = new ByteArrayOutputStream()
    def encoder = new OutputStreamBackedEncoder(output)

    @Subject
    def serializer = new SnapshotSerializer(Mock(ClassLoaderHierarchyHasher))

    def "serializes serialized properties"() {
        def original = snapshot("x".bytes)
        write(original)

        expect:

    def "conditional publishing with #dsl dsl"() {
        using m2

        given:
        def sampleDir = sampleProject.dir.file(dsl)
        inDirectory(sampleDir)

        and:
        def artifactId = "maven-conditional-publishing"
        def version = "1.0"
        def externalRepo = maven(sampleDir.file("build/repos/external"))

        def v = multiParser("").parseNotation(sb) as List

        then:
        v.size() == 1
        v[0].name  == 'charsequence'
    }

    def "allows exact type on input"() {
        def module = DefaultModuleIdentifier.newId("org.foo", "bar")
        def id = newSelector(module, "2.0")

        when:
        def v = multiParser("").parseNotation(id) as List

        then:
        v.size() == 1

    }

    def "compile include path includes public and private header dirs"() {
        def defaultPrivate = tmpDir.file("src/main/headers")
        def defaultPublic = tmpDir.file("src/main/public")
        def d1 = tmpDir.file("src/main/d1")
        def d2 = tmpDir.file("src/main/d2")
        def d3 = tmpDir.file("src/main/d3")
        def d4 = tmpDir.file("src/main/d4")

        expect:

    def context = Mock(Consumer)
    def resolver = Mock(PathToFileResolver)
    def patternSetFactory = Mock(Factory)
    def visitor = new UnpackingVisitor(context, resolver, TestFiles.taskDependencyFactory(), patternSetFactory)

    def "resolves null"() {
        when:
        visitor.add(null)

        then:
        0 * context._
    }

    def "resolves String"() {