const _RTAX_NETMASK = 2
const _RTAX_IFA = 5
const _RTAX_MAX = 8

func getIfList() ([]byte, error) {
	needed, err := syscall.Getkerninfo(_KINFO_RT_IFLIST, 0, 0, 0)
	if err != nil {
		return nil, err
	}
	tab := make([]byte, needed)
	_, err = syscall.Getkerninfo(_KINFO_RT_IFLIST, uintptr(unsafe.Pointer(&tab[0])), uintptr(unsafe.Pointer(&needed)), 0)
	if err != nil {
		return nil, err
	}
	return tab[:needed], nil

}

/*
 * Socket
 */
//sys	bind(s int, addr unsafe.Pointer, addrlen _Socklen) (err error)
//sys	connect(s int, addr unsafe.Pointer, addrlen _Socklen) (err error)
//sys   Getkerninfo(op int32, where uintptr, size uintptr, arg int64) (i int32, err error)
//sys	getsockopt(s int, level int, name int, val unsafe.Pointer, vallen *_Socklen) (err error)
//sys	Listen(s int, backlog int) (err error)

//go:cgo_import_dynamic libc_fsync_range fsync_range "libc.a/shr_64.o"
//go:cgo_import_dynamic libc_bind bind "libc.a/shr_64.o"
//go:cgo_import_dynamic libc_connect connect "libc.a/shr_64.o"
//go:cgo_import_dynamic libc_Getkerninfo getkerninfo "libc.a/shr_64.o"
//go:cgo_import_dynamic libc_getsockopt getsockopt "libc.a/shr_64.o"
//go:cgo_import_dynamic libc_Listen listen "libc.a/shr_64.o"
//go:cgo_import_dynamic libc_setsockopt setsockopt "libc.a/shr_64.o"

    }

    def "deviant bean properties are considered as such by Java"() {
        expect:
        def propertyNames = Introspector.getBeanInfo(DeviantBean).propertyDescriptors.collect { it.name }
        propertyNames.contains("tingStarted")
        propertyNames.contains("ccCompiler")
        propertyNames.contains("idore")
        propertyNames.contains("tings")

}

var _ credentials.Controller = &AggregateController{}

func (a *AggregateController) GetCertInfo(name, namespace string) (certInfo *credentials.CertInfo, err error) {
	// Search through all clusters, find first non-empty result
	var firstError error
	for _, c := range a.controllers {
		certInfo, err := c.GetCertInfo(name, namespace)
		if err != nil {
			if firstError == nil {
				firstError = err
			}
		} else {

	// The certificate chain
	Cert []byte
	// The private key
	Key []byte
	// The oscp staple
	Staple []byte
	// Certificate Revocation List information
	CRL []byte
}

type Controller interface {
	GetCertInfo(name, namespace string) (certInfo *CertInfo, err error)
	GetCaCert(name, namespace string) (certInfo *CertInfo, err error)
	GetDockerCredential(name, namespace string) (cred []byte, err error)

        where:
        // Check all mutable boolean properties (must manually check for setters as many of them return StartParameter)
        buildOptionName << Introspector.getBeanInfo(StartParameterInternal).propertyDescriptors
            .findAll { it.propertyType == boolean }

                return false;
            }
            if (!Objects.equals(m1.getClass(), m2.getClass())) {
                return false;
            }
            BeanInfo bean = Introspector.getBeanInfo(m1.getClass());
            for (PropertyDescriptor prop : bean.getPropertyDescriptors()) {
                if (("first".equals(prop.getName()) || "last".equals(prop.getName()))

            asProperties(name).collect { k, v ->
                "${addTo}[\"${escapeString(k)}\"] = \"${escapeString(v)}\""
            }.join(System.lineSeparator())
        }
    }

    KeyInfo getKeyInfo(set = "default") {
        new KeyInfo(
            keyId: file(set, "keyId.txt").text.trim(),
            password: file(set, "password.txt").text.trim(),
            keyRingFilePath: file(set, "secring.gpg")

        and:
        file("build", "libs", "changed-1.0-custom.jar.asc").text

    }

    def "sign with subkey"() {
        given:
        buildFile << """
            ${getKeyInfo("subkey").addAsPropertiesScript()}

            signing {
                sign jar
            }
        """

        when:
        run "signJar"

        then: