/**
   * @param c the number of compression rounds (must be positive)
   * @param d the number of finalization rounds (must be positive)
   * @param k0 the first half of the key
   * @param k1 the second half of the key
   */
  SipHashFunction(int c, int d, long k0, long k1) {
    checkArgument(
        c > 0, "The number of SipRound iterations (c=%s) during Compression must be positive.", c);
    checkArgument(

		expectedErr      error
		opts             PolicyOptions
	}{
		{
			name: "positive test 1 node",
			topology: []cadvisorapi.Node{
				{
					Id: 0,
				},
			},
			expectedNUMAInfo: &NUMAInfo{
				Nodes: []int{0},
				NUMADistances: NUMADistances{
					0: nil,
				},
			},
			opts: PolicyOptions{},
		},
		{
			name: "positive test 1 node, with PreferClosestNUMA",
			topology: []cadvisorapi.Node{
				{

   * @param expectedInsertions the number of expected insertions to the constructed {@code
   *     BloomFilter}; must be positive
   * @param fpp the desired false positive probability (must be positive and less than 1.0)
   * @return a {@code BloomFilter}
   */
  public static <T extends @Nullable Object> BloomFilter<T> create(

     */
    void writeLong(long value) throws IOException;

    /**
     * Writes a signed 64 bit long value whose value is likely to be small and positive but may not be. The implementation may encode the value in a way that is more efficient for small positive
     * values.
     */
    void writeSmallLong(long value) throws IOException;

    /**

type SafeWaitGroup struct {
	wg sync.WaitGroup
	mu sync.RWMutex
	// wait indicate whether Wait is called, if true,
	// then any Add with positive delta will return error.
	wait bool
}

// Add adds delta, which may be negative, similar to sync.WaitGroup.
// If Add with a positive delta happens after Wait, it will return error,
// which prevent unsafe Add.
func (wg *SafeWaitGroup) Add(delta int) error {
	wg.mu.RLock()

    }

    def "can handle invalid value for command line option with concrete hint"() {
        when:
        Origin.forCommandLine(OPTION).handleInvalidValue(VALUE, HINT)

        then:
        Throwable t = thrown(CommandLineArgumentException)
        t.message == "Argument value '0' given for --option option is invalid (must be positive)"
    }

			want:          int64(10),
			assertOnError: assertNilError,
		},
		{
			name:          "int64 minimum positive value",
			in:            hex("00"), // 0
			want:          int64(0),
			assertOnError: assertNilError,
		},
		{
			name:          "int64 max positive value",
			in:            hex("1b7fffffffffffffff"), // 9223372036854775807
			want:          int64(9223372036854775807),

		}
		if limit.Burst <= 0 {
			allErrs = append(allErrs, field.Invalid(idxPath.Child("burst"), limit.Burst, "must be positive"))
		}
		if limit.QPS <= 0 {
			allErrs = append(allErrs, field.Invalid(idxPath.Child("qps"), limit.QPS, "must be positive"))
		}
		if limit.Type != eventratelimitapi.ServerLimitType {
			if limit.CacheSize < 0 {

var _ = x / 1e-1000 // GC_ERROR "division by zero"
var _ = x / 1e-20i
var _ = x / 1e-50i   // GC_ERROR "division by zero"
var _ = x / 1e-1000i // GC_ERROR "division by zero"

var _ = x / 1e-45 // smallest positive float32

var _ = x / (1e-20 + 1e-20i)
var _ = x / (1e-50 + 1e-20i)
var _ = x / (1e-20 + 1e-50i)
var _ = x / (1e-50 + 1e-50i)     // GC_ERROR "division by zero"

    // - Class/Member Variables -/
    // --------------------------/

    /**
     * The one-based line number. The value will be non-positive if
     * unknown.
     */
    private int lineNumber = -1;

    /**
     * The one-based column number. The value will be non-positive
     * if unknown.
     */
    private int columnNumber = -1;

    /**
     * Field source.
     */
    private InputSource source;