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

package rand

func GetNormalDistributionParameters() (float64, [128]uint32, [128]float32, [128]float32) {
	return rn, kn, wn, fn
}

func GetExponentialDistributionParameters() (float64, [256]uint32, [256]float32, [256]float32) {
	return re, ke, we, fe

		if match {
			wn, err = sw.WriteString(s[last:i])
			n += wn
			if err != nil {
				return
			}
			wn, err = sw.WriteString(val)
			n += wn
			if err != nil {
				return
			}
			i += keylen
			last = i
			continue
		}
		i++
	}
	if last != len(s) {
		wn, err = sw.WriteString(s[last:])
		n += wn
	}
	return
}

	if i := compareUint32Slices(kn[0:], testKn); i >= 0 {
		t.Errorf("kn disagrees at index %v; %v != %v", i, kn[i], testKn[i])
	}
	if i := compareFloat32Slices(wn[0:], testWn); i >= 0 {
		t.Errorf("wn disagrees at index %v; %v != %v", i, wn[i], testWn[i])
	}
	if i := compareFloat32Slices(fn[0:], testFn); i >= 0 {
		t.Errorf("fn disagrees at index %v; %v != %v", i, fn[i], testFn[i])
	}
}

//
//	sample = NormFloat64() * desiredStdDev + desiredMean
func (r *Rand) NormFloat64() float64 {
	for {
		u := r.Uint64()
		j := int32(u) // Possibly negative
		i := u >> 32 & 0x7F
		x := float64(j) * float64(wn[i])
		if absInt32(j) < kn[i] {
			// This case should be hit better than 99% of the time.
			return x
		}

		if i == 0 {
			// This extra work is only required for the base strip.
			for {

// adjust the output using:
//
//	sample = NormFloat64() * desiredStdDev + desiredMean
func (r *Rand) NormFloat64() float64 {
	for {
		j := int32(r.Uint32()) // Possibly negative
		i := j & 0x7F
		x := float64(j) * float64(wn[i])
		if absInt32(j) < kn[i] {
			// This case should be hit better than 99% of the time.
			return x
		}

		if i == 0 {
			// This extra work is only required for the base strip.
			for {

	if i := compareUint32Slices(kn[0:], testKn); i >= 0 {
		t.Errorf("kn disagrees at index %v; %v != %v", i, kn[i], testKn[i])
	}
	if i := compareFloat32Slices(wn[0:], testWn); i >= 0 {
		t.Errorf("wn disagrees at index %v; %v != %v", i, wn[i], testWn[i])
	}
	if i := compareFloat32Slices(fn[0:], testFn); i >= 0 {
		t.Errorf("fn disagrees at index %v; %v != %v", i, fn[i], testFn[i])
	}
}

00000030  16 03 03 00 40 82 78 f0  1e e6 03 20 67 66 4e d6  |....@.x.... gfN.|
00000040  93 25 69 9e 38 c6 dd 17  92 02 18 7f 5f 9c 9c f0  |.%i.8......._...|
00000050  a3 f7 45 d3 ba 82 e3 01  38 e5 4f cf 8b 0e 77 6e  |..E.....8.O...wn|
00000060  91 99 83 e0 f1 3d e8 a1  39 d4 ea b3 2e 1c 67 59  |.....=..9.....gY|
00000070  c5 5d 83 30 dc                                    |.].0.|
>>> Flow 4 (server to client)

00000010  42 c7 73 06 75 ef 28 ff  87 46 49 af 3a 3b cb bb  |B.s.u.(..FI.:;..|
00000020  ff 6e e3 60 11 40 2c b8  40 87 5c 20 86 3d de c2  |.n.`.@,.@.\ .=..|
00000030  18 41 ff 1a dc 00 77 4e  17 0b 36 f3 69 92 d7 04  |.A....wN..6.i...|
00000040  c4 c6 39 ad ed f7 06 23  8c 52 50 da cc a8 00 00  |..9....#.RP.....|
00000050  11 ff 01 00 01 00 00 0b  00 04 03 00 01 02 00 17  |................|

				}
				unique := sets.SortedList(sets.New(hostnames...))
				want := dst.WorkloadsOrFail(t)
				wn := []string{}
				for _, w := range want {
					wn = append(wn, w.PodName())
				}
				if len(unique) != len(wn) {
					return fmt.Errorf("excepted all destinations (%v), got: %v", wn, unique)
				}
				return nil
			}

			shouldBalance := dst.Config().HasServiceAddressedWaypointProxy()

		}
	}
}

type errorWriterToTest struct {
	rn, wn     int
	rerr, werr error
	expected   error
}

func (r errorWriterToTest) Read(p []byte) (int, error) {
	return len(p) * r.rn, r.rerr
}

func (w errorWriterToTest) Write(p []byte) (int, error) {
	return len(p) * w.wn, w.werr
}

var errorWriterToTests = []errorWriterToTest{