}
			}),
		},
	})

	group(t, "negative integer", []test{
		{
			name:          "int64 max negative value",
			in:            hex("20"), // -1
			want:          int64(-1),
			assertOnError: assertNilError,
		},
		{
			name:          "int64 min negative value",
			in:            hex("3b7fffffffffffffff"), // -9223372036854775808

		"The unix timestamp, in seconds, when Citadel root cert will expire. "+
			"A negative time indicates the cert is expired.",
	)
	rootCertExpirySeconds = monitoring.NewDerivedGauge(
		"citadel_server_root_cert_expiry_seconds",
		"The time remaining, in seconds, before the root certificate will expire. "+
			"A negative value indicates the cert is expired.",
	)
	certChainExpiryTimestamp = monitoring.NewGauge(

// license that can be found in the LICENSE file.

// Ensure that typed non-integer, negative and too large
// values are not accepted as size argument in make for
// channels.

package main

type T chan byte

var sink T

func main() {
	sink = make(T, -1)            // ERROR "negative buffer argument in make.*|must not be negative"
	sink = make(T, uint64(1<<63)) // ERROR "buffer argument too large in make.*|overflows int"

        checkArgument(executedTasksCount >= 0, "executedTasksCount must be non-negative");
        checkArgument(fromCacheTaskCount >= 0, "fromCacheTaskCount must be non-negative");
        checkArgument(upToDateTaskCount >= 0, "upToDateTaskCount must be non-negative");
        this.executedTasksCount = executedTasksCount;
        this.fromCacheTaskCount = fromCacheTaskCount;

// Copyright 2010 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package math

// Signbit reports whether x is negative or negative zero.
func Signbit(x float64) bool {
	return Float64bits(x)&(1<<63) != 0

	var a [10]int
	_ = a[true /* ERROR "cannot convert" */ ]
	_ = a["foo" /* ERROR "cannot convert" */ ]
	_ = a[1.1 /* ERROR "truncated" */ ]
	_ = a[1.0]
	_ = a[- /* ERROR "negative" */ 1]
	_ = a[- /* ERROR "negative" */ 1 :]
	_ = a[: - /* ERROR "negative" */ 1]
	_ = a[: /* ERROR "middle index required" */ : /* ERROR "final index required" */ ]
	_ = a[0: /* ERROR "middle index required" */ : /* ERROR "final index required" */ ]

   * @throws IllegalArgumentException if {@code permitsPerSecond} is negative or zero or {@code
   *     warmupPeriod} is negative
   */
  @SuppressWarnings("GoodTime") // should accept a java.time.Duration
  public static RateLimiter create(double permitsPerSecond, long warmupPeriod, TimeUnit unit) {
    checkArgument(warmupPeriod >= 0, "warmupPeriod must not be negative: %s", warmupPeriod);
    return create(

// read calls the read system call.
// It returns a non-negative number of bytes written or a negative errno value.
func read(fd int32, p unsafe.Pointer, n int32) int32

func closefd(fd int32) int32

func exit(code int32)
func usleep(usec uint32)

//go:nosplit
func usleep_no_g(usec uint32) {
	usleep(usec)
}

// write1 calls the write system call.
// It returns a non-negative number of bytes written or a negative errno value.
//

// Copyright 2018 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Issues 12576 and 12621: Negative untyped floating point constants
// with small magnitude round to 0, not negative zero.

package main

import "math"

var m = -1e-10000

func main() {
	if math.Signbit(m) {
		panic(m)
	}

	{"(1<<63)/0", "divide of value with high bit set"},
	{"3%0", "modulo by zero"},
	{"(1<<63)%0", "modulo of value with high bit set"},
	{"3<<-4", "negative left shift count"},
	{"3<<(1<<63)", "negative left shift count"},
	{"3>>-4", "negative right shift count"},
	{"3>>(1<<63)", "negative right shift count"},
	{"(1<<63)>>2", "right shift of value with high bit set"},
	{"(1<<62)>>2", ""},