}

  @Test
  fun multipleSources() {
    val upstream = Buffer()
    upstream.writeUtf8("abcdefghijklm")
    val relay = edit(file, upstream, metadata, 1024)
    val source1 = relay.newSource()!!.buffer()
    val source2 = relay.newSource()!!.buffer()
    assertThat(source1.readUtf8()).isEqualTo("abcdefghijklm")
    assertThat(source2.readUtf8()).isEqualTo("abcdefghijklm")
    source1.close()
    source2.close()

    def "updates spec for incremental compilation"() {
        def spec = Mock(NativeCompileSpec)
        def newSource = temporaryFolder.file("new")
        def removedSource = temporaryFolder.file("removed")

        def compilation = Mock(IncrementalCompilation)

        when:
        compilation.getRecompile() >> [newSource]
        compilation.getRemoved() >> [removedSource]

        and:

        ImmutableSet.Builder<FileCollectionInternal> newSource = ImmutableSet.builderWithExpectedSize(source.size());
        boolean hasChanges = false;
        for (FileCollectionInternal candidate : source) {
            FileCollectionInternal newCollection = candidate.replace(original, supplier);
            hasChanges |= newCollection != candidate;
            newSource.add(newCollection);
        }
        if (hasChanges) {

package trace

import (
	"math"
	"math/rand"
	"testing"
)

func TestMUD(t *testing.T) {
	// Insert random uniforms and check histogram mass and
	// cumulative sum approximations.
	rnd := rand.New(rand.NewSource(42))
	mass := 0.0
	var mud mud
	for i := 0; i < 100; i++ {
		area, l, r := rnd.Float64(), rnd.Float64(), rnd.Float64()
		if rnd.Intn(10) == 0 {
			r = l
		}
		t.Log(l, r, area)
		mud.add(l, r, area)

	for i := 0; i < *roundtrip.FuzzIters; i++ {
		for _, version := range []schema.GroupVersion{{Group: "", Version: runtime.APIVersionInternal}, {Group: "", Version: "v1"}} {
			f := fuzzer.FuzzerFor(FuzzerFuncs, rand.NewSource(rand.Int63()), legacyscheme.Codecs)
			for kind := range legacyscheme.Scheme.KnownTypes(version) {
				doDeepCopyTest(t, version.WithKind(kind), f)
			}
		}
	}
}

	"time"

	"github.com/minio/pkg/v3/sync/errgroup"
)

func (er erasureObjects) getOnlineDisks() (newDisks []StorageAPI) {
	disks := er.getDisks()
	var wg sync.WaitGroup
	var mu sync.Mutex
	r := rand.New(rand.NewSource(time.Now().UnixNano()))
	for _, i := range r.Perm(len(disks)) {
		i := i
		wg.Add(1)
		go func() {
			defer wg.Done()
			if disks[i] == nil {
				return
			}

	bo := image.Rect(0, 0, 640, 480)
	imgRGBA := image.NewRGBA(bo)
	// Must use 444 subsampling to avoid lossy RGBA to YCbCr conversion.
	imgYCbCr := image.NewYCbCr(bo, image.YCbCrSubsampleRatio444)
	rnd := rand.New(rand.NewSource(123))
	// Create identical rgba and ycbcr images.
	for y := bo.Min.Y; y < bo.Max.Y; y++ {
		for x := bo.Min.X; x < bo.Max.X; x++ {
			col := color.RGBA{
				uint8(rnd.Intn(256)),
				uint8(rnd.Intn(256)),

	// Since this is a randomized algorithm we use a defined random source to ensure
	// consistency between test runs. In practice, results will not differ greatly
	// between runs with different PRNG seeds.
	src := rand.NewSource(1)

	// Create dumbell graph:
	//
	//  0       4
	//  |\     /|
	//  | 2 - 3 |
	//  |/     \|
	//  1       5
	//
	g := simple.NewUndirectedGraph()
	for u, e := range smallDumbell {

	if p, err := rand.Prime(rand.Reader, 1); p != nil || err == nil {
		t.Errorf("Prime should return nil, error when called with bits < 2")
	}
}

func TestPrimeNondeterministic(t *testing.T) {
	r := mathrand.New(mathrand.NewSource(42))
	p0, err := rand.Prime(r, 32)
	if err != nil {
		t.Fatal(err)
	}
	for i := 0; i < 128; i++ {
		r.Seed(42)
		p, err := rand.Prime(r, 32)
		if err != nil {
			t.Fatal(err)
		}
		if p.Cmp(p0) != 0 {

	"github.com/google/go-cmp/cmp"
	fuzz "github.com/google/gofuzz"
)

func TestAsPartialObjectMetadata(t *testing.T) {
	f := fuzz.New().NilChance(.5).NumElements(0, 1).RandSource(rand.NewSource(1))

	for i := 0; i < 100; i++ {
		m := &metav1.ObjectMeta{}
		f.Fuzz(m)
		partial := AsPartialObjectMetadata(m)
		if !reflect.DeepEqual(&partial.ObjectMeta, m) {