comparing nested slices while ignoring order

Question

In a test function, there is a case where nested slices should be compared. Say I have two varibles like the following:

want := [][]string{{"bat"},{"nat","tan"},{"ate","eat","tea"}}
got := [][]string{{"eat","tea","ate"},{"tan","nat"},{"bat"}}

How can compare them?

First, I used reflect.DeepEqual which was wrong, I also tried go-cmp:

    t.Run(tt.name, func(t *testing.T) {
        opt := cmpopts.SortSlices(func (a, b []int) bool {
            // not sure what to write
        })

        if got := groupAnagrams(tt.args.strs); !cmp.Equal(got, tt.want, opt) {
            t.Errorf("groupAnagrams() = %v, want %v", got, tt.want)
        }
    })

2 Penny Worth · Answer 1 · 2022-11-20T15:32:18.057

1

Sort the inner slices:

for _, s := range want { sort.Strings(s) }
for _, s := range got { sort.Strings(s) }

Sort the outer slices:

sortOuter(want)
sortOuter(got)

where sortOuter is a the function:

func sortOuter(s [][]string) {
    sort.Slice(s, func(a, b int) bool {
        sa := s[a]
        sb := s[b]
        n := len(sa)
        if n > len(sb) {
            n = len(sb)
        }
        for i := 0; i < n; i++ {
            if sa[i] != sb[i] {
                return sa[i] < sb[i]
            }
        }
        return len(sa) < len(sb)
    })
}

Compare:

fmt.Println(reflect.DeepEqual(got, want))

https://go.dev/play/p/SjN8gLmotjd

edited Nov 20 '22 at 15:32

answered Nov 20 '22 at 02:57

2 Penny Worth

26
2

2

You should use `sort.Slice`, not `sort.Sort`. Above is far too complex, you just pass in the the comparison function as argument to `sort.Slice`, not need to create a new type with methods. – Erwin Bolwidt Nov 20 '22 at 09:28

score 1 · Answer 2 · answered Nov 22 '22 at 06:28

You can sort inner slices using sort.Slice as below and check if outer slices are equal using testify assert.ElementsMatch:

func TestXxx(t *testing.T) {
  // Slices
  want := [][]string{{"bat"}, {"nat", "tan"}, {"ate", "eat", "tea"}}
  got := [][]string{{"eat", "tea", "ate"}, {"tan", "nat"}, {"bat"}}

  // Running tests
  t.Run("test", func(t *testing.T) {
    // Sorting got inners
    for _, inner := range got {
      sort.Slice(inner, func(i, j int) bool {
        return inner[i] < inner[j]
      })
    }

    // Sorting want inners
    for _, inner := range want {
      sort.Slice(inner, func(i, j int) bool {
        return inner[i] < inner[j]
      })
    }

    // Match
    assert.ElementsMatch(t, got, want)
  })
}

ElementsMatch:

ElementsMatch asserts that the specified listA(array, slice...) is equal to specified listB(array, slice...) ignoring the order of the elements. If there are duplicate elements, the number of appearances of each of them in both lists should match.

assert.ElementsMatch(t, [1, 3, 2, 3], [1, 3, 3, 2])

comparing nested slices while ignoring order

2 Answers2