Function TestMap

transform_test.go:18–84

(t *testing.T)

}

func TestMap(t *testing.T) {
	th.TestBothOrderings(t, func(t *testing.T, ord bool) {
		for _, n := range []int{1, 5} {

			t.Run(th.Name("nil", n), func(t *testing.T) {
				out := universalMap(ord, nil, n, func(x int) (int, error) { return x, nil })
				th.ExpectValue(t, out, nil)
			})

			t.Run(th.Name("correctness", n), func(t *testing.T) {
				in := FromChan(th.FromRange(0, 20), nil)
				in = replaceWithError(in, 15, fmt.Errorf("err15"))

				out := universalMap(ord, in, n, func(x int) (string, error) {
					if x == 5 {
						return "", fmt.Errorf("err05")
					}
					if x == 6 {
						return "", fmt.Errorf("err06")
					}

					return fmt.Sprintf("%03d", x), nil
				})

				outSlice, errSlice := toSliceAndErrors(out)

				expectedSlice := make([]string, 0, 20)
				for i := 0; i < 20; i++ {
					if i == 5 || i == 6 || i == 15 {
						continue
					}
					expectedSlice = append(expectedSlice, fmt.Sprintf("%03d", i))
				}

				sort.Strings(outSlice)
				sort.Strings(errSlice)

				th.ExpectSlice(t, outSlice, expectedSlice)
				th.ExpectSlice(t, errSlice, []string{"err05", "err06", "err15"})
			})

			t.Run(th.Name("ordering", n), func(t *testing.T) {
				in := FromChan(th.FromRange(0, 20000), nil)

				out := universalMap(ord, in, n, func(x int) (int, error) {
					if x%2 == 0 {
						return x, fmt.Errorf("err%06d", x)
					}

					return x, nil
				})

				outSlice, errSlice := toSliceAndErrors(out)

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