import org.objectweb.asm.Type;

import javax.lang.model.element.Element;
import javax.lang.model.element.PackageElement;
import javax.lang.model.type.ArrayType;
import javax.lang.model.type.DeclaredType;
import javax.lang.model.type.ErrorType;
import javax.lang.model.type.ExecutableType;
import javax.lang.model.type.IntersectionType;
import javax.lang.model.type.NoType;
import javax.lang.model.type.NullType;

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

//go:build js || wasip1

package net

import "syscall"

func setDefaultSockopts(s, family, sotype int, ipv6only bool) error {
	return nil
}

func setDefaultListenerSockopts(s int) error {
	return nil
}

func setDefaultMulticastSockopts(s int) error {
	return nil
}

        expect:
        spec.isSatisfiedBy("foo")
        !spec.isSatisfiedBy("FOO")
        !spec.isSatisfiedBy("bar")
    }

    def parse(def value) {
        return NotationParserBuilder.toType(Spec).fromType(Closure, converter).toComposite().parseNotation(value)
    }

import spock.lang.Specification

public class TypedNotationConverterTest extends Specification {

    def parser = NotationParserBuilder.toType(Integer).converter(new DummyConverter()).toComposite()

    def "parses object of source type"(){
        expect:
        parser.parseNotation("100") == 100
    }

    def "throws meaningful exception on parse attempt"(){
        when:

// type and protocol number.
type Cookie uint64

// Family returns an address family.
func (c Cookie) Family() int { return int(c >> 48) }

// Type returns a socket type.
func (c Cookie) Type() int { return int(c << 16 >> 32) }

// Protocol returns a protocol number.
func (c Cookie) Protocol() int { return int(c & 0xff) }

func cookie(family, sotype, proto int) Cookie {

    }

    public static NotationParser<Object, Spec<DependencyResult>> parser() {
        return NotationParserBuilder
                .toType(new TypeInfo<Spec<DependencyResult>>(Spec.class))
                .invalidNotationMessage("Please check the input for the DependencyInsight.dependency element.")

        this.stringInterner = stringInterner;
    }

    @Nonnull
    @Override
    public NotationParser<Object, org.gradle.api.artifacts.ClientModule> create() {
        return NotationParserBuilder.toType(org.gradle.api.artifacts.ClientModule.class)
                .fromCharSequence(new DependencyStringNotationConverter<>(instantiator, DefaultClientModule.class, stringInterner))

import org.gradle.plugins.signing.signatory.SignatoryProvider;
import org.gradle.security.internal.BaseSignatoryProvider;
import org.gradle.util.internal.ConfigureUtil;

import static org.codehaus.groovy.runtime.DefaultGroovyMethods.asType;

public interface ConfigurableSignatoryProvider<T extends Signatory> extends BaseSignatoryProvider<T>, SignatoryProvider<T> {
    @Override
    default void configure(SigningExtension settings, Closure closure) {

import javax.annotation.Nullable;

class NativeDependencyNotationParser {
    public static NotationParser<Object, NativeLibraryRequirement> parser() {
        return NotationParserBuilder
                .toType(NativeLibraryRequirement.class)
                .converter(new LibraryConverter())
                .converter(new NativeLibraryRequirementMapNotationConverter())
                .toComposite();
    }

    /**
     * Returns the dependency type id.
     * The id uniquely identifies this <i>dependency type</i>.
     *
     * @return the id of this type, never {@code null}.
     */
    @Nonnull
    String id();

    /**
     * Returns the dependency type language.
     *
     * @return the language of this type, never {@code null}.
     */
    @Nonnull
    Language getLanguage();

    /**