Function TestMapReduce

reduce_test.go:145–304

(t *testing.T)

}

func TestMapReduce(t *testing.T) {
	for _, nm := range []int{1, 4} {
		for _, nr := range []int{1, 4} {
			t.Run(th.Name("empty", nm, nr), func(t *testing.T) {
				in := FromSlice([]int{}, nil)

				out, err := MapReduce(in,
					nm, func(x int) (string, int, error) {
						s := fmt.Sprint(x)
						return fmt.Sprintf("%d-digit", len(s)), x, nil
					},
					nr, func(x, y int) (int, error) {
						return x + y, nil
					})

				th.ExpectNoError(t, err)
				th.ExpectMap(t, out, map[string]int{})
				th.ExpectDrainedChan(t, in)
			})

			t.Run(th.Name("no errors", nm, nr), func(t *testing.T) {
				in := FromChan(th.FromRange(0, 1000), nil)

				var cntMap, cntReduce atomic.Int64
				out, err := MapReduce(in,
					nm, func(x int) (string, int, error) {
						cntMap.Add(1)
						s := fmt.Sprint(x)
						return fmt.Sprintf("%d-digit", len(s)), x, nil
					},
					nr, func(x, y int) (int, error) {
						cntReduce.Add(1)
						return x + y, nil
					},
				)

				th.ExpectNoError(t, err)
				th.ExpectMap(t, out, map[string]int{
					"1-digit": (0 + 9) * 10 / 2,
					"2-digit": (10 + 99) * 90 / 2,
					"3-digit": (100 + 999) * 900 / 2,
				})
				th.ExpectValue(t, cntMap.Load(), 1000)
				th.ExpectValue(t, cntReduce.Load(), 9+89+899)
				th.ExpectDrainedChan(t, in)
			})

			t.Run(th.Name("error in input", nm, nr), func(t *testing.T) {
				in := FromChan(th.FromRange(0, 1000), nil)
				in = replaceWithError(in, 100, fmt.Errorf("err100"))

				var cntMap, cntReduce atomic.Int64
				_, err := MapReduce(in,
					nm, func(x int) (string, int, error) {
						cntMap.Add(1)
						s := fmt.Sprint(x)
						return fmt.Sprintf("%d-digit", len(s)), x, nil
					},