Function TestLoop

internal/core/loops_test.go:24–85

(t *testing.T)

}

func TestLoop(t *testing.T) {
	th.TestBothOrderings(t, func(t *testing.T, ord bool) {
		for _, n := range []int{1, 5} {
			t.Run(th.Name("correctness", n), func(t *testing.T) {
				in := th.FromRange(0, 20)
				done := make(chan struct{})

				var sum atomic.Int64

				universalLoop(ord, in, done, n, func(x int, canWrite <-chan struct{}) {
					<-canWrite
					sum.Add(int64(x))
				})

				<-done
				th.ExpectValue(t, sum.Load(), 19*20/2)
			})

			t.Run(th.Name("concurrency", n), func(t *testing.T) {
				in := th.FromRange(0, 100)
				out := make(chan int)

				monitor := th.NewConcurrencyMonitor(1 * time.Second)

				universalLoop(ord, in, out, n, func(x int, canWrite <-chan struct{}) {
					monitor.Inc()
					defer monitor.Dec()

					<-canWrite

					out <- x
				})

				Drain(out)

				th.ExpectValue(t, monitor.Max(), n)
			})

			t.Run(th.Name("ordering", n), func(t *testing.T) {
				in := th.FromRange(0, 20000)
				out := make(chan int)

				universalLoop(ord, in, out, n, func(x int, canWrite <-chan struct{}) {

					<-canWrite

					out <- x
				})

				outSlice := th.ToSlice(out)

				if ord || n == 1 {
					th.ExpectSorted(t, outSlice)
				} else {
					th.ExpectUnsorted(t, outSlice)
				}

			})