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

package rand_test

import (
	. "math/rand/v2"
	"sync"
	"testing"
)

// TestConcurrent exercises the rand API concurrently, triggering situations
// where the race detector is likely to detect issues.
func TestConcurrent(t *testing.T) {
	const (
		numRoutines = 10
		numCycles   = 10
	)

// Copyright 2014 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.

//go:build unix

package rand

import (
	"bytes"
	"errors"
	prand "math/rand"
	"testing"
)

func TestBatched(t *testing.T) {
	fillBatched := batched(func(p []byte) error {
		for i := range p {
			p[i] = byte(i)
		}
		return nil
	}, 5)

	for i := 0; i < configSize; i++ {
		ids = append(ids, addConfig(l, b))
	}
	b.ResetTimer()
	for n := 0; n < b.N; n++ {
		eg.Go(func() error {
			_, err := l.Put(ids[rand.Int()%configSize], strconv.Itoa(rand.Int()))
			_ = l.RootHash()
			return err
		})
	}
	if err := eg.Wait(); err != nil {
		b.Fatalf("An error occurred putting new data on the ledger: %v", err)
	}
	b.StopTimer()
}

Klaus Post <******@****.***> 1457448890 +0100

Klaus Post <******@****.***> 1457448890 +0100

Klaus Post <******@****.***> 1457448890 +0100

	block, err := aes.NewCipher(commonKey128)
	if err != nil {
		t.Error(err)
		return
	}

	plaintext := []byte("this is the plaintext. this is the plaintext.")
	iv := make([]byte, block.BlockSize())
	rand.Reader.Read(iv)
	cfb := cipher.NewCFBEncrypter(block, iv)
	ciphertext := make([]byte, len(plaintext))
	copy(ciphertext, plaintext)
	cfb.XORKeyStream(ciphertext, ciphertext)

	cfbdec := cipher.NewCFBDecrypter(block, iv)

	// k otherwise, where k is the length in octets of the RSA modulus n."
	key, err := GenerateKey(rand.Reader, 513)
	if err != nil {
		t.Fatal(err)
	}
	digest := sha256.Sum256([]byte("message"))
	signature, err := key.Sign(rand.Reader, digest[:], &PSSOptions{
		SaltLength: PSSSaltLengthAuto,
		Hash:       crypto.SHA256,
	})
	if err != nil {
		t.Fatal(err)
	}

	}
	// Allow for about 1000 years of randomness. Accurate to a tenth of
	// micro second. Leave off nanoseconds because JSON doesn't
	// represent them so they can't round-trip properly.
	t.Time = time.Unix(c.Rand.Int63n(1000*365*24*60*60), 1000*c.Rand.Int63n(1000000))
}

// ensure MicroTime implements fuzz.Interface

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

package typecheck

import (
	"go/constant"

	"cmd/compile/internal/ir"
	"cmd/compile/internal/types"
	"cmd/internal/src"
)

var (
	okfor [ir.OEND][]bool
)

var (
	okforeq    [types.NTYPE]bool
	okforadd   [types.NTYPE]bool
	okforand   [types.NTYPE]bool
	okfornone  [types.NTYPE]bool
	okforbool  [types.NTYPE]bool
	okforcap   [types.NTYPE]bool