if cm.NodeConfig.SystemReserved != nil {
			value.Sub(cm.NodeConfig.SystemReserved[k])
		}
		if cm.NodeConfig.KubeReserved != nil {
			value.Sub(cm.NodeConfig.KubeReserved[k])
		}
		if value.Sign() < 0 {
			// Negative Allocatable resources don't make sense.
			value.Set(0)
		}
		result[k] = value
	}
	return result
}

        signing {
            signTasks = sign publishing.publications
        }

        when:
        publishing.publications.clear()

        then:
        !tasks.findByName('signMavenPublication').enabled

        and:
        signTasks.isEmpty()
    }

    def "sign task has description"() {
        when:
        signing {
            sign publishing.publications
        }

        then:

	{complex(-inf, inf),
		complex(zero, zero)}, // real and imaginary sign unspecified
	{complex(inf, inf),
		complex(inf, nan)}, // real sign unspecified
	{complex(-inf, nan),
		complex(zero, zero)}, // real and imaginary sign unspecified
	{complex(inf, nan),
		complex(inf, nan)}, // real sign unspecified
	{complex(nan, zero),
		complex(nan, zero)},
	{complex(nan, 1.0),
		NaN()},

}

func TestIntGobEncoding(t *testing.T) {
	var medium bytes.Buffer
	enc := gob.NewEncoder(&medium)
	dec := gob.NewDecoder(&medium)
	for _, test := range encodingTests {
		for _, sign := range []string{"", "+", "-"} {
			x := sign + test
			medium.Reset() // empty buffer for each test case (in case of failures)
			var tx Int
			tx.SetString(x, 10)
			if err := enc.Encode(&tx); err != nil {

	)
	// special cases
	switch {
	case IsNaN(x) || IsNaN(y) || IsInf(x, 0) || y == 0:
		return NaN()
	case IsInf(y, 0):
		return x
	}
	sign := false
	if x < 0 {
		x = -x
		sign = true
	}
	if y < 0 {
		y = -y
	}
	if x == y {
		if sign {
			zero := 0.0
			return -zero
		}
		return 0
	}
	if y <= HalfMax {
		x = Mod(x, y+y) // now x < 2y
	}
	if y < Tiny {
		if x+x > y {

extra["signing.password"] = "gradle"
extra["signing.secretKeyRingFile"] = file("secKeyRingFile.gpg").absolutePath

// tag::sign-task[]
tasks.register<Zip>("stuffZip") {
    archiveBaseName = "stuff"
    from("src/stuff")
}

signing {
    sign(tasks["stuffZip"])
}

// truncation itself.
//
// Be aware that calling Sign with an attacker-controlled [PrivateKey] may
// require an arbitrary amount of CPU.
func Sign(rand io.Reader, priv *PrivateKey, hash []byte) (r, s *big.Int, err error) {
	randutil.MaybeReadByte(rand)

	// FIPS 186-3, section 4.6

	n := priv.Q.BitLen()
	if priv.Q.Sign() <= 0 || priv.P.Sign() <= 0 || priv.G.Sign() <= 0 || priv.X.Sign() <= 0 || n%8 != 0 {
		err = ErrInvalidPublicKey

{
    "signing": {
        "default": {
            "usages": [
                "digital signature",
                "cert sign",
                "crl sign",
                "signing",
                "key encipherment",
                "client auth"
            ],
            "expiry": "876000h",
            "ca_constraint": {
                "is_ca": true
            }
        }
    }

{
    "signing": {
        "default": {
            "usages": [
                "digital signature",
                "cert sign",
                "crl sign",
                "signing",
                "key encipherment",
                "client auth"
            ],
            "expiry": "876000h",
            "ca_constraint": {
                "is_ca": true
            }
        }
    }

package internal

import (
	"fmt"

	"k8s.io/apimachinery/pkg/runtime"
	"k8s.io/apimachinery/pkg/runtime/schema"
	"sigs.k8s.io/structured-merge-diff/v4/fieldpath"
	"sigs.k8s.io/structured-merge-diff/v4/merge"
	"sigs.k8s.io/structured-merge-diff/v4/typed"
)

// versionConverter is an implementation of
// sigs.k8s.io/structured-merge-diff/merge.Converter
type versionConverter struct {
	typeConverter   TypeConverter