Method m = Baz.class.getMethod("rawMap", Map.class);
        assertThat(MethodUtil.getValueTypeOfMapFromReturnType(m), is(nullValue()));

        m = Baz.class.getMethod("genericMap", Map.class);
        assertThat(MethodUtil.getValueTypeOfMapFromReturnType(m), is(sameClass(Class.class)));
    }

    /**
     *
     */
    public interface Baz {

        /**
         * @param param

                - key: altKeyValue
                  bar:
                    baz: altValue
            `),
			RootOldObject: mustUnstructured(`
                foo:
                - key: altKeyValue
                  bar:
                    baz: altValue
                - key: keyValue
                  bar:
                    baz: value
            `),
			Schema: mustSchema(`

        "top-level property has convention, nested is set" | setId("convention")                | setFooBar("baz")      | """id = convention\nbar = baz"""
        "nested property has convention and is set"        | setFooBar("convention")            | setFooBar("baz")      | """id = <no id>\nbar = baz"""

    static class Bar {
        static void bar() {
            new Baz().baz = 42
        }
    }

    static abstract class SuperBaz {
        void setBaz(int baz) {
            boom
        }

        abstract String getBoom()
    }

    static class Baz extends SuperBaz {
        void setBaz(int baz) {
            super.setBaz(baz)
        }

        String getBoom() {

        when:
        mutate {
            add 'foo'
            add 'bar'
            add 'baz'
        }


        then:
        def list = registry.realize(collectionPath, collectionType)
        list.toArray() == ['foo', 'bar', 'baz'] as String[]
        list.toArray(new String[0]) == ['foo', 'bar', 'baz'] as String[]
    }

    def "can check contents"() {
        when:
        mutate {

        given:
        JavaAppStartScriptGenerationDetails details = createScriptGenerationDetails(['-Dfoo=bar baz', '-Xint'], 'bin')
        Writer destination = new StringWriter()

        when:
        generator.generateScript(details, destination)

        then:
        destination.toString().contains(/DEFAULT_JVM_OPTS='"-Dfoo=bar baz" "-Xint"'/)
    }

    def "defaultJvmOpts is expanded properly in unix script -- double quotes"() {

        group("org")                                                                                                   | groupSet("foo", "baz")                                                                                                | factory.nothing()

                }
            ]
        }
    )


def test_query_query_baz():
    response = client.get("/query?query=baz")
    assert response.status_code == 200
    assert response.json() == "foo bar baz"


def test_query_not_declared_baz():
    response = client.get("/query?not_declared=baz")
    assert response.status_code == 422
    assert response.json() == IsDict(
        {
            "detail": [

    void invoke() {
        foo()
    }

    void foo() {
        new Bar().bar()
    }

    static class Bar {
        void bar() {
            Baz.baz()
        }
    }

    static class Baz {
        static void baz() {}
    }

            add 'baz'
            set(0, 'foorepl')
            delegate[1] = 'barrepl'
        }


        then:
        def list = registry.realize(collectionPath, collectionType)
        list == checkable(['foorepl', 'barrepl', 'baz'])
    }

    def "can query using get(index)"() {
        when:
        mutate {
            add 'foo'
            add 'bar'
            add 'baz'
        }