analysis.constants == ['X|1'.hashCode()] as Set

        when:
        analysis = analyze(HasPrivateConstants)

        then:
        analysis.accessibleClassDependencies == [] as Set
        analysis.privateClassDependencies == [HasNonPrivateConstants.name] as Set
        !analysis.dependencyToAllReason
        analysis.constants == [] as Set
    }

        annotation("Helper"),
        annotation("Service")
    ] as Set

    RoundEnvironment roundEnvironment = Stub(RoundEnvironment) {
        getRootElements() >> ([type("A"), type("B"), type("C")] as Set)
        getElementsAnnotatedWith(_ as TypeElement) >> { TypeElement annotationType ->
            if (annotationType.is(annotationTypes[0])) {
                [type("A")] as Set
            } else if (annotationType.is(annotationTypes[1])) {

    def "fails when trying to include buildSrc as project"() {
        buildFile << """
            task t
        """
        settingsFile << """
            include 'buildSrc'
        """

        when:
        fails "t"

        then:
        failure.assertHasDescription("'buildSrc' cannot be used as a project name as it is a reserved name")
    }

        def arraySerializer = serializer.forTypes([] as Class[])
        serialize([] as Object[], arraySerializer).length == 0
        toBytes([] as Object[], arraySerializer).length == 0
    }

    def "serializes single args"() {
        expect:
        def arraySerializer = serializer.forTypes([String,] as Class[])
        serialize(["a"] as Object[], arraySerializer) == ["a"] as Object[]
    }

    def "serializes multiple args"() {

         */
        String getRuntimeVersion();

        /**
         * Returns Java VM name such as {@code OpenJDK 64-Bit Server VM}.
         */
        String getJvmName();

        /**
         * Returns Java VM version such as {@code 17.0.3.1+2-LTS}.
         * <p>
         * This value is identical to {@link #getRuntimeVersion()} for most of the vendors,

                </mxCell>
                <mxCell id="14" style="edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;strokeWidth=3;exitX=0.092;exitY=1.01;exitDx=0;exitDy=0;dashed=1;exitPerimeter=0;" parent="1" source="11" target="12" edge="1">
                    <mxGeometry relative="1" as="geometry">
                        <Array as="points">

        expect:
        converter.convert(12 as Byte, Long.class, false) == 12L
        converter.convert(123 as Short, Long.class, false) == 123L
        converter.convert(123 as Integer, Long.class, false) == 123L
        converter.convert(123 as Long, Long.class, false) == 123L
        converter.convert(123 as Double, Long.class, false) == 123L
        converter.convert(123 as BigInteger, Long.class, false) == 123L

                ASN1Sequence encSequence = ASN1Util.as(ASN1Sequence.class, tagged);
                ASN1Integer encType = ASN1Util.as(ASN1Integer.class, ASN1Util.as(ASN1TaggedObject.class, encSequence, 0));
                DEROctetString encOctets = ASN1Util.as(DEROctetString.class, ASN1Util.as(ASN1TaggedObject.class, encSequence, 2));
                byte[] crypt = encOctets.getOctets();

                if ( keys == null ) {

        expect:
        !matcher.matches(["a"] as String[], 0)
        !matcher.matches(["a", "c", "d", "b"] as String[], 0)

        matcher.matches(["c"] as String[], 0)
        matcher.matches(["prefix", "c"] as String[], 1)
        matcher.matches(["a", "c"] as String[], 0)
        matcher.matches(["a", "c", "d"] as String[], 0)
        matcher.matches(["a", "b", "c", "d"] as String[], 0)

            e.exec("some string")
            e.exec("some string", ["array"] as String[])
            e.exec("some string", ["array"] as String[], file("test"))
            e.exec(["some", "string"] as String[])
            e.exec(["some", "string"] as String[], ["array"] as String[])
            e.exec(["some", "string"] as String[], ["array"] as String[], file("test"))


            def s = new ProcessBuilderStart()
            s.start()