github.com/sandwich-go/boost@v1.3.29/xmap/walk_test.go

// Code generated by tools. DO NOT EDIT.
package xmap

import (
	. "github.com/smartystreets/goconvey/convey"
	"sort"
	"strconv"
	"testing"
)

func TestWalkMapDeterministic(t *testing.T) {
	var n = 100
	Convey("WalkFloat32Float32MapDeterministic", t, func() {
		var keys = make([]float32, 0, n)
		var value float32
		var tm = make(map[float32]float32)
		for i := 0; i < n; i++ {
			var key float32
			key = float32(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]float32, 0, n)
		WalkFloat32Float32MapDeterministic(tm, func(k float32, v float32) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkFloat32Float64MapDeterministic", t, func() {
		var keys = make([]float32, 0, n)
		var value float64
		var tm = make(map[float32]float64)
		for i := 0; i < n; i++ {
			var key float32
			key = float32(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]float32, 0, n)
		WalkFloat32Float64MapDeterministic(tm, func(k float32, v float64) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkFloat32IntMapDeterministic", t, func() {
		var keys = make([]float32, 0, n)
		var value int
		var tm = make(map[float32]int)
		for i := 0; i < n; i++ {
			var key float32
			key = float32(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]float32, 0, n)
		WalkFloat32IntMapDeterministic(tm, func(k float32, v int) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkFloat32Int16MapDeterministic", t, func() {
		var keys = make([]float32, 0, n)
		var value int16
		var tm = make(map[float32]int16)
		for i := 0; i < n; i++ {
			var key float32
			key = float32(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]float32, 0, n)
		WalkFloat32Int16MapDeterministic(tm, func(k float32, v int16) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkFloat32Int32MapDeterministic", t, func() {
		var keys = make([]float32, 0, n)
		var value int32
		var tm = make(map[float32]int32)
		for i := 0; i < n; i++ {
			var key float32
			key = float32(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]float32, 0, n)
		WalkFloat32Int32MapDeterministic(tm, func(k float32, v int32) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkFloat32Int64MapDeterministic", t, func() {
		var keys = make([]float32, 0, n)
		var value int64
		var tm = make(map[float32]int64)
		for i := 0; i < n; i++ {
			var key float32
			key = float32(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]float32, 0, n)
		WalkFloat32Int64MapDeterministic(tm, func(k float32, v int64) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkFloat32Int8MapDeterministic", t, func() {
		var keys = make([]float32, 0, n)
		var value int8
		var tm = make(map[float32]int8)
		for i := 0; i < n; i++ {
			var key float32
			key = float32(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]float32, 0, n)
		WalkFloat32Int8MapDeterministic(tm, func(k float32, v int8) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkFloat32InterfaceMapDeterministic", t, func() {
		var keys = make([]float32, 0, n)
		var value interface{}
		var tm = make(map[float32]interface{})
		for i := 0; i < n; i++ {
			var key float32
			key = float32(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]float32, 0, n)
		WalkFloat32InterfaceMapDeterministic(tm, func(k float32, v interface{}) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkFloat32StringMapDeterministic", t, func() {
		var keys = make([]float32, 0, n)
		var value string
		var tm = make(map[float32]string)
		for i := 0; i < n; i++ {
			var key float32
			key = float32(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]float32, 0, n)
		WalkFloat32StringMapDeterministic(tm, func(k float32, v string) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkFloat32UintMapDeterministic", t, func() {
		var keys = make([]float32, 0, n)
		var value uint
		var tm = make(map[float32]uint)
		for i := 0; i < n; i++ {
			var key float32
			key = float32(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]float32, 0, n)
		WalkFloat32UintMapDeterministic(tm, func(k float32, v uint) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkFloat32Uint16MapDeterministic", t, func() {
		var keys = make([]float32, 0, n)
		var value uint16
		var tm = make(map[float32]uint16)
		for i := 0; i < n; i++ {
			var key float32
			key = float32(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]float32, 0, n)
		WalkFloat32Uint16MapDeterministic(tm, func(k float32, v uint16) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkFloat32Uint32MapDeterministic", t, func() {
		var keys = make([]float32, 0, n)
		var value uint32
		var tm = make(map[float32]uint32)
		for i := 0; i < n; i++ {
			var key float32
			key = float32(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]float32, 0, n)
		WalkFloat32Uint32MapDeterministic(tm, func(k float32, v uint32) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkFloat32Uint64MapDeterministic", t, func() {
		var keys = make([]float32, 0, n)
		var value uint64
		var tm = make(map[float32]uint64)
		for i := 0; i < n; i++ {
			var key float32
			key = float32(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]float32, 0, n)
		WalkFloat32Uint64MapDeterministic(tm, func(k float32, v uint64) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkFloat32Uint8MapDeterministic", t, func() {
		var keys = make([]float32, 0, n)
		var value uint8
		var tm = make(map[float32]uint8)
		for i := 0; i < n; i++ {
			var key float32
			key = float32(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]float32, 0, n)
		WalkFloat32Uint8MapDeterministic(tm, func(k float32, v uint8) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkFloat64Float32MapDeterministic", t, func() {
		var keys = make([]float64, 0, n)
		var value float32
		var tm = make(map[float64]float32)
		for i := 0; i < n; i++ {
			var key float64
			key = float64(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]float64, 0, n)
		WalkFloat64Float32MapDeterministic(tm, func(k float64, v float32) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkFloat64Float64MapDeterministic", t, func() {
		var keys = make([]float64, 0, n)
		var value float64
		var tm = make(map[float64]float64)
		for i := 0; i < n; i++ {
			var key float64
			key = float64(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]float64, 0, n)
		WalkFloat64Float64MapDeterministic(tm, func(k float64, v float64) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkFloat64IntMapDeterministic", t, func() {
		var keys = make([]float64, 0, n)
		var value int
		var tm = make(map[float64]int)
		for i := 0; i < n; i++ {
			var key float64
			key = float64(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]float64, 0, n)
		WalkFloat64IntMapDeterministic(tm, func(k float64, v int) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkFloat64Int16MapDeterministic", t, func() {
		var keys = make([]float64, 0, n)
		var value int16
		var tm = make(map[float64]int16)
		for i := 0; i < n; i++ {
			var key float64
			key = float64(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]float64, 0, n)
		WalkFloat64Int16MapDeterministic(tm, func(k float64, v int16) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkFloat64Int32MapDeterministic", t, func() {
		var keys = make([]float64, 0, n)
		var value int32
		var tm = make(map[float64]int32)
		for i := 0; i < n; i++ {
			var key float64
			key = float64(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]float64, 0, n)
		WalkFloat64Int32MapDeterministic(tm, func(k float64, v int32) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkFloat64Int64MapDeterministic", t, func() {
		var keys = make([]float64, 0, n)
		var value int64
		var tm = make(map[float64]int64)
		for i := 0; i < n; i++ {
			var key float64
			key = float64(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]float64, 0, n)
		WalkFloat64Int64MapDeterministic(tm, func(k float64, v int64) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkFloat64Int8MapDeterministic", t, func() {
		var keys = make([]float64, 0, n)
		var value int8
		var tm = make(map[float64]int8)
		for i := 0; i < n; i++ {
			var key float64
			key = float64(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]float64, 0, n)
		WalkFloat64Int8MapDeterministic(tm, func(k float64, v int8) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkFloat64InterfaceMapDeterministic", t, func() {
		var keys = make([]float64, 0, n)
		var value interface{}
		var tm = make(map[float64]interface{})
		for i := 0; i < n; i++ {
			var key float64
			key = float64(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]float64, 0, n)
		WalkFloat64InterfaceMapDeterministic(tm, func(k float64, v interface{}) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkFloat64StringMapDeterministic", t, func() {
		var keys = make([]float64, 0, n)
		var value string
		var tm = make(map[float64]string)
		for i := 0; i < n; i++ {
			var key float64
			key = float64(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]float64, 0, n)
		WalkFloat64StringMapDeterministic(tm, func(k float64, v string) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkFloat64UintMapDeterministic", t, func() {
		var keys = make([]float64, 0, n)
		var value uint
		var tm = make(map[float64]uint)
		for i := 0; i < n; i++ {
			var key float64
			key = float64(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]float64, 0, n)
		WalkFloat64UintMapDeterministic(tm, func(k float64, v uint) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkFloat64Uint16MapDeterministic", t, func() {
		var keys = make([]float64, 0, n)
		var value uint16
		var tm = make(map[float64]uint16)
		for i := 0; i < n; i++ {
			var key float64
			key = float64(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]float64, 0, n)
		WalkFloat64Uint16MapDeterministic(tm, func(k float64, v uint16) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkFloat64Uint32MapDeterministic", t, func() {
		var keys = make([]float64, 0, n)
		var value uint32
		var tm = make(map[float64]uint32)
		for i := 0; i < n; i++ {
			var key float64
			key = float64(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]float64, 0, n)
		WalkFloat64Uint32MapDeterministic(tm, func(k float64, v uint32) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkFloat64Uint64MapDeterministic", t, func() {
		var keys = make([]float64, 0, n)
		var value uint64
		var tm = make(map[float64]uint64)
		for i := 0; i < n; i++ {
			var key float64
			key = float64(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]float64, 0, n)
		WalkFloat64Uint64MapDeterministic(tm, func(k float64, v uint64) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkFloat64Uint8MapDeterministic", t, func() {
		var keys = make([]float64, 0, n)
		var value uint8
		var tm = make(map[float64]uint8)
		for i := 0; i < n; i++ {
			var key float64
			key = float64(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]float64, 0, n)
		WalkFloat64Uint8MapDeterministic(tm, func(k float64, v uint8) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkIntFloat32MapDeterministic", t, func() {
		var keys = make([]int, 0, n)
		var value float32
		var tm = make(map[int]float32)
		for i := 0; i < n; i++ {
			var key int
			key = i
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Ints(keys)

		var dest = make([]int, 0, n)
		WalkIntFloat32MapDeterministic(tm, func(k int, v float32) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkIntFloat64MapDeterministic", t, func() {
		var keys = make([]int, 0, n)
		var value float64
		var tm = make(map[int]float64)
		for i := 0; i < n; i++ {
			var key int
			key = i
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Ints(keys)

		var dest = make([]int, 0, n)
		WalkIntFloat64MapDeterministic(tm, func(k int, v float64) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkIntIntMapDeterministic", t, func() {
		var keys = make([]int, 0, n)
		var value int
		var tm = make(map[int]int)
		for i := 0; i < n; i++ {
			var key int
			key = i
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Ints(keys)

		var dest = make([]int, 0, n)
		WalkIntIntMapDeterministic(tm, func(k int, v int) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkIntInt16MapDeterministic", t, func() {
		var keys = make([]int, 0, n)
		var value int16
		var tm = make(map[int]int16)
		for i := 0; i < n; i++ {
			var key int
			key = i
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Ints(keys)

		var dest = make([]int, 0, n)
		WalkIntInt16MapDeterministic(tm, func(k int, v int16) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkIntInt32MapDeterministic", t, func() {
		var keys = make([]int, 0, n)
		var value int32
		var tm = make(map[int]int32)
		for i := 0; i < n; i++ {
			var key int
			key = i
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Ints(keys)

		var dest = make([]int, 0, n)
		WalkIntInt32MapDeterministic(tm, func(k int, v int32) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkIntInt64MapDeterministic", t, func() {
		var keys = make([]int, 0, n)
		var value int64
		var tm = make(map[int]int64)
		for i := 0; i < n; i++ {
			var key int
			key = i
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Ints(keys)

		var dest = make([]int, 0, n)
		WalkIntInt64MapDeterministic(tm, func(k int, v int64) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkIntInt8MapDeterministic", t, func() {
		var keys = make([]int, 0, n)
		var value int8
		var tm = make(map[int]int8)
		for i := 0; i < n; i++ {
			var key int
			key = i
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Ints(keys)

		var dest = make([]int, 0, n)
		WalkIntInt8MapDeterministic(tm, func(k int, v int8) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkIntInterfaceMapDeterministic", t, func() {
		var keys = make([]int, 0, n)
		var value interface{}
		var tm = make(map[int]interface{})
		for i := 0; i < n; i++ {
			var key int
			key = i
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Ints(keys)

		var dest = make([]int, 0, n)
		WalkIntInterfaceMapDeterministic(tm, func(k int, v interface{}) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkIntStringMapDeterministic", t, func() {
		var keys = make([]int, 0, n)
		var value string
		var tm = make(map[int]string)
		for i := 0; i < n; i++ {
			var key int
			key = i
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Ints(keys)

		var dest = make([]int, 0, n)
		WalkIntStringMapDeterministic(tm, func(k int, v string) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkIntUintMapDeterministic", t, func() {
		var keys = make([]int, 0, n)
		var value uint
		var tm = make(map[int]uint)
		for i := 0; i < n; i++ {
			var key int
			key = i
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Ints(keys)

		var dest = make([]int, 0, n)
		WalkIntUintMapDeterministic(tm, func(k int, v uint) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkIntUint16MapDeterministic", t, func() {
		var keys = make([]int, 0, n)
		var value uint16
		var tm = make(map[int]uint16)
		for i := 0; i < n; i++ {
			var key int
			key = i
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Ints(keys)

		var dest = make([]int, 0, n)
		WalkIntUint16MapDeterministic(tm, func(k int, v uint16) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkIntUint32MapDeterministic", t, func() {
		var keys = make([]int, 0, n)
		var value uint32
		var tm = make(map[int]uint32)
		for i := 0; i < n; i++ {
			var key int
			key = i
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Ints(keys)

		var dest = make([]int, 0, n)
		WalkIntUint32MapDeterministic(tm, func(k int, v uint32) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkIntUint64MapDeterministic", t, func() {
		var keys = make([]int, 0, n)
		var value uint64
		var tm = make(map[int]uint64)
		for i := 0; i < n; i++ {
			var key int
			key = i
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Ints(keys)

		var dest = make([]int, 0, n)
		WalkIntUint64MapDeterministic(tm, func(k int, v uint64) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkIntUint8MapDeterministic", t, func() {
		var keys = make([]int, 0, n)
		var value uint8
		var tm = make(map[int]uint8)
		for i := 0; i < n; i++ {
			var key int
			key = i
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Ints(keys)

		var dest = make([]int, 0, n)
		WalkIntUint8MapDeterministic(tm, func(k int, v uint8) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkInt16Float32MapDeterministic", t, func() {
		var keys = make([]int16, 0, n)
		var value float32
		var tm = make(map[int16]float32)
		for i := 0; i < n; i++ {
			var key int16
			key = int16(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]int16, 0, n)
		WalkInt16Float32MapDeterministic(tm, func(k int16, v float32) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkInt16Float64MapDeterministic", t, func() {
		var keys = make([]int16, 0, n)
		var value float64
		var tm = make(map[int16]float64)
		for i := 0; i < n; i++ {
			var key int16
			key = int16(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]int16, 0, n)
		WalkInt16Float64MapDeterministic(tm, func(k int16, v float64) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkInt16IntMapDeterministic", t, func() {
		var keys = make([]int16, 0, n)
		var value int
		var tm = make(map[int16]int)
		for i := 0; i < n; i++ {
			var key int16
			key = int16(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]int16, 0, n)
		WalkInt16IntMapDeterministic(tm, func(k int16, v int) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkInt16Int16MapDeterministic", t, func() {
		var keys = make([]int16, 0, n)
		var value int16
		var tm = make(map[int16]int16)
		for i := 0; i < n; i++ {
			var key int16
			key = int16(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]int16, 0, n)
		WalkInt16Int16MapDeterministic(tm, func(k int16, v int16) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkInt16Int32MapDeterministic", t, func() {
		var keys = make([]int16, 0, n)
		var value int32
		var tm = make(map[int16]int32)
		for i := 0; i < n; i++ {
			var key int16
			key = int16(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]int16, 0, n)
		WalkInt16Int32MapDeterministic(tm, func(k int16, v int32) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkInt16Int64MapDeterministic", t, func() {
		var keys = make([]int16, 0, n)
		var value int64
		var tm = make(map[int16]int64)
		for i := 0; i < n; i++ {
			var key int16
			key = int16(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]int16, 0, n)
		WalkInt16Int64MapDeterministic(tm, func(k int16, v int64) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkInt16Int8MapDeterministic", t, func() {
		var keys = make([]int16, 0, n)
		var value int8
		var tm = make(map[int16]int8)
		for i := 0; i < n; i++ {
			var key int16
			key = int16(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]int16, 0, n)
		WalkInt16Int8MapDeterministic(tm, func(k int16, v int8) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkInt16InterfaceMapDeterministic", t, func() {
		var keys = make([]int16, 0, n)
		var value interface{}
		var tm = make(map[int16]interface{})
		for i := 0; i < n; i++ {
			var key int16
			key = int16(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]int16, 0, n)
		WalkInt16InterfaceMapDeterministic(tm, func(k int16, v interface{}) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkInt16StringMapDeterministic", t, func() {
		var keys = make([]int16, 0, n)
		var value string
		var tm = make(map[int16]string)
		for i := 0; i < n; i++ {
			var key int16
			key = int16(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]int16, 0, n)
		WalkInt16StringMapDeterministic(tm, func(k int16, v string) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkInt16UintMapDeterministic", t, func() {
		var keys = make([]int16, 0, n)
		var value uint
		var tm = make(map[int16]uint)
		for i := 0; i < n; i++ {
			var key int16
			key = int16(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]int16, 0, n)
		WalkInt16UintMapDeterministic(tm, func(k int16, v uint) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkInt16Uint16MapDeterministic", t, func() {
		var keys = make([]int16, 0, n)
		var value uint16
		var tm = make(map[int16]uint16)
		for i := 0; i < n; i++ {
			var key int16
			key = int16(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]int16, 0, n)
		WalkInt16Uint16MapDeterministic(tm, func(k int16, v uint16) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkInt16Uint32MapDeterministic", t, func() {
		var keys = make([]int16, 0, n)
		var value uint32
		var tm = make(map[int16]uint32)
		for i := 0; i < n; i++ {
			var key int16
			key = int16(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]int16, 0, n)
		WalkInt16Uint32MapDeterministic(tm, func(k int16, v uint32) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkInt16Uint64MapDeterministic", t, func() {
		var keys = make([]int16, 0, n)
		var value uint64
		var tm = make(map[int16]uint64)
		for i := 0; i < n; i++ {
			var key int16
			key = int16(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]int16, 0, n)
		WalkInt16Uint64MapDeterministic(tm, func(k int16, v uint64) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkInt16Uint8MapDeterministic", t, func() {
		var keys = make([]int16, 0, n)
		var value uint8
		var tm = make(map[int16]uint8)
		for i := 0; i < n; i++ {
			var key int16
			key = int16(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]int16, 0, n)
		WalkInt16Uint8MapDeterministic(tm, func(k int16, v uint8) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkInt32Float32MapDeterministic", t, func() {
		var keys = make([]int32, 0, n)
		var value float32
		var tm = make(map[int32]float32)
		for i := 0; i < n; i++ {
			var key int32
			key = int32(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]int32, 0, n)
		WalkInt32Float32MapDeterministic(tm, func(k int32, v float32) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkInt32Float64MapDeterministic", t, func() {
		var keys = make([]int32, 0, n)
		var value float64
		var tm = make(map[int32]float64)
		for i := 0; i < n; i++ {
			var key int32
			key = int32(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]int32, 0, n)
		WalkInt32Float64MapDeterministic(tm, func(k int32, v float64) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkInt32IntMapDeterministic", t, func() {
		var keys = make([]int32, 0, n)
		var value int
		var tm = make(map[int32]int)
		for i := 0; i < n; i++ {
			var key int32
			key = int32(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]int32, 0, n)
		WalkInt32IntMapDeterministic(tm, func(k int32, v int) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkInt32Int16MapDeterministic", t, func() {
		var keys = make([]int32, 0, n)
		var value int16
		var tm = make(map[int32]int16)
		for i := 0; i < n; i++ {
			var key int32
			key = int32(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]int32, 0, n)
		WalkInt32Int16MapDeterministic(tm, func(k int32, v int16) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkInt32Int32MapDeterministic", t, func() {
		var keys = make([]int32, 0, n)
		var value int32
		var tm = make(map[int32]int32)
		for i := 0; i < n; i++ {
			var key int32
			key = int32(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]int32, 0, n)
		WalkInt32Int32MapDeterministic(tm, func(k int32, v int32) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkInt32Int64MapDeterministic", t, func() {
		var keys = make([]int32, 0, n)
		var value int64
		var tm = make(map[int32]int64)
		for i := 0; i < n; i++ {
			var key int32
			key = int32(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]int32, 0, n)
		WalkInt32Int64MapDeterministic(tm, func(k int32, v int64) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkInt32Int8MapDeterministic", t, func() {
		var keys = make([]int32, 0, n)
		var value int8
		var tm = make(map[int32]int8)
		for i := 0; i < n; i++ {
			var key int32
			key = int32(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]int32, 0, n)
		WalkInt32Int8MapDeterministic(tm, func(k int32, v int8) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkInt32InterfaceMapDeterministic", t, func() {
		var keys = make([]int32, 0, n)
		var value interface{}
		var tm = make(map[int32]interface{})
		for i := 0; i < n; i++ {
			var key int32
			key = int32(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]int32, 0, n)
		WalkInt32InterfaceMapDeterministic(tm, func(k int32, v interface{}) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkInt32StringMapDeterministic", t, func() {
		var keys = make([]int32, 0, n)
		var value string
		var tm = make(map[int32]string)
		for i := 0; i < n; i++ {
			var key int32
			key = int32(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]int32, 0, n)
		WalkInt32StringMapDeterministic(tm, func(k int32, v string) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkInt32UintMapDeterministic", t, func() {
		var keys = make([]int32, 0, n)
		var value uint
		var tm = make(map[int32]uint)
		for i := 0; i < n; i++ {
			var key int32
			key = int32(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]int32, 0, n)
		WalkInt32UintMapDeterministic(tm, func(k int32, v uint) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkInt32Uint16MapDeterministic", t, func() {
		var keys = make([]int32, 0, n)
		var value uint16
		var tm = make(map[int32]uint16)
		for i := 0; i < n; i++ {
			var key int32
			key = int32(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]int32, 0, n)
		WalkInt32Uint16MapDeterministic(tm, func(k int32, v uint16) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkInt32Uint32MapDeterministic", t, func() {
		var keys = make([]int32, 0, n)
		var value uint32
		var tm = make(map[int32]uint32)
		for i := 0; i < n; i++ {
			var key int32
			key = int32(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]int32, 0, n)
		WalkInt32Uint32MapDeterministic(tm, func(k int32, v uint32) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkInt32Uint64MapDeterministic", t, func() {
		var keys = make([]int32, 0, n)
		var value uint64
		var tm = make(map[int32]uint64)
		for i := 0; i < n; i++ {
			var key int32
			key = int32(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]int32, 0, n)
		WalkInt32Uint64MapDeterministic(tm, func(k int32, v uint64) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkInt32Uint8MapDeterministic", t, func() {
		var keys = make([]int32, 0, n)
		var value uint8
		var tm = make(map[int32]uint8)
		for i := 0; i < n; i++ {
			var key int32
			key = int32(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]int32, 0, n)
		WalkInt32Uint8MapDeterministic(tm, func(k int32, v uint8) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkInt64Float32MapDeterministic", t, func() {
		var keys = make([]int64, 0, n)
		var value float32
		var tm = make(map[int64]float32)
		for i := 0; i < n; i++ {
			var key int64
			key = int64(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]int64, 0, n)
		WalkInt64Float32MapDeterministic(tm, func(k int64, v float32) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkInt64Float64MapDeterministic", t, func() {
		var keys = make([]int64, 0, n)
		var value float64
		var tm = make(map[int64]float64)
		for i := 0; i < n; i++ {
			var key int64
			key = int64(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]int64, 0, n)
		WalkInt64Float64MapDeterministic(tm, func(k int64, v float64) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkInt64IntMapDeterministic", t, func() {
		var keys = make([]int64, 0, n)
		var value int
		var tm = make(map[int64]int)
		for i := 0; i < n; i++ {
			var key int64
			key = int64(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]int64, 0, n)
		WalkInt64IntMapDeterministic(tm, func(k int64, v int) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkInt64Int16MapDeterministic", t, func() {
		var keys = make([]int64, 0, n)
		var value int16
		var tm = make(map[int64]int16)
		for i := 0; i < n; i++ {
			var key int64
			key = int64(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]int64, 0, n)
		WalkInt64Int16MapDeterministic(tm, func(k int64, v int16) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkInt64Int32MapDeterministic", t, func() {
		var keys = make([]int64, 0, n)
		var value int32
		var tm = make(map[int64]int32)
		for i := 0; i < n; i++ {
			var key int64
			key = int64(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]int64, 0, n)
		WalkInt64Int32MapDeterministic(tm, func(k int64, v int32) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkInt64Int64MapDeterministic", t, func() {
		var keys = make([]int64, 0, n)
		var value int64
		var tm = make(map[int64]int64)
		for i := 0; i < n; i++ {
			var key int64
			key = int64(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]int64, 0, n)
		WalkInt64Int64MapDeterministic(tm, func(k int64, v int64) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkInt64Int8MapDeterministic", t, func() {
		var keys = make([]int64, 0, n)
		var value int8
		var tm = make(map[int64]int8)
		for i := 0; i < n; i++ {
			var key int64
			key = int64(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]int64, 0, n)
		WalkInt64Int8MapDeterministic(tm, func(k int64, v int8) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkInt64InterfaceMapDeterministic", t, func() {
		var keys = make([]int64, 0, n)
		var value interface{}
		var tm = make(map[int64]interface{})
		for i := 0; i < n; i++ {
			var key int64
			key = int64(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]int64, 0, n)
		WalkInt64InterfaceMapDeterministic(tm, func(k int64, v interface{}) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkInt64StringMapDeterministic", t, func() {
		var keys = make([]int64, 0, n)
		var value string
		var tm = make(map[int64]string)
		for i := 0; i < n; i++ {
			var key int64
			key = int64(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]int64, 0, n)
		WalkInt64StringMapDeterministic(tm, func(k int64, v string) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkInt64UintMapDeterministic", t, func() {
		var keys = make([]int64, 0, n)
		var value uint
		var tm = make(map[int64]uint)
		for i := 0; i < n; i++ {
			var key int64
			key = int64(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]int64, 0, n)
		WalkInt64UintMapDeterministic(tm, func(k int64, v uint) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkInt64Uint16MapDeterministic", t, func() {
		var keys = make([]int64, 0, n)
		var value uint16
		var tm = make(map[int64]uint16)
		for i := 0; i < n; i++ {
			var key int64
			key = int64(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]int64, 0, n)
		WalkInt64Uint16MapDeterministic(tm, func(k int64, v uint16) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkInt64Uint32MapDeterministic", t, func() {
		var keys = make([]int64, 0, n)
		var value uint32
		var tm = make(map[int64]uint32)
		for i := 0; i < n; i++ {
			var key int64
			key = int64(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]int64, 0, n)
		WalkInt64Uint32MapDeterministic(tm, func(k int64, v uint32) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkInt64Uint64MapDeterministic", t, func() {
		var keys = make([]int64, 0, n)
		var value uint64
		var tm = make(map[int64]uint64)
		for i := 0; i < n; i++ {
			var key int64
			key = int64(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]int64, 0, n)
		WalkInt64Uint64MapDeterministic(tm, func(k int64, v uint64) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkInt64Uint8MapDeterministic", t, func() {
		var keys = make([]int64, 0, n)
		var value uint8
		var tm = make(map[int64]uint8)
		for i := 0; i < n; i++ {
			var key int64
			key = int64(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]int64, 0, n)
		WalkInt64Uint8MapDeterministic(tm, func(k int64, v uint8) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkInt8Float32MapDeterministic", t, func() {
		var keys = make([]int8, 0, n)
		var value float32
		var tm = make(map[int8]float32)
		for i := 0; i < n; i++ {
			var key int8
			key = int8(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]int8, 0, n)
		WalkInt8Float32MapDeterministic(tm, func(k int8, v float32) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkInt8Float64MapDeterministic", t, func() {
		var keys = make([]int8, 0, n)
		var value float64
		var tm = make(map[int8]float64)
		for i := 0; i < n; i++ {
			var key int8
			key = int8(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]int8, 0, n)
		WalkInt8Float64MapDeterministic(tm, func(k int8, v float64) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkInt8IntMapDeterministic", t, func() {
		var keys = make([]int8, 0, n)
		var value int
		var tm = make(map[int8]int)
		for i := 0; i < n; i++ {
			var key int8
			key = int8(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]int8, 0, n)
		WalkInt8IntMapDeterministic(tm, func(k int8, v int) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkInt8Int16MapDeterministic", t, func() {
		var keys = make([]int8, 0, n)
		var value int16
		var tm = make(map[int8]int16)
		for i := 0; i < n; i++ {
			var key int8
			key = int8(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]int8, 0, n)
		WalkInt8Int16MapDeterministic(tm, func(k int8, v int16) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkInt8Int32MapDeterministic", t, func() {
		var keys = make([]int8, 0, n)
		var value int32
		var tm = make(map[int8]int32)
		for i := 0; i < n; i++ {
			var key int8
			key = int8(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]int8, 0, n)
		WalkInt8Int32MapDeterministic(tm, func(k int8, v int32) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkInt8Int64MapDeterministic", t, func() {
		var keys = make([]int8, 0, n)
		var value int64
		var tm = make(map[int8]int64)
		for i := 0; i < n; i++ {
			var key int8
			key = int8(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]int8, 0, n)
		WalkInt8Int64MapDeterministic(tm, func(k int8, v int64) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkInt8Int8MapDeterministic", t, func() {
		var keys = make([]int8, 0, n)
		var value int8
		var tm = make(map[int8]int8)
		for i := 0; i < n; i++ {
			var key int8
			key = int8(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]int8, 0, n)
		WalkInt8Int8MapDeterministic(tm, func(k int8, v int8) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkInt8InterfaceMapDeterministic", t, func() {
		var keys = make([]int8, 0, n)
		var value interface{}
		var tm = make(map[int8]interface{})
		for i := 0; i < n; i++ {
			var key int8
			key = int8(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]int8, 0, n)
		WalkInt8InterfaceMapDeterministic(tm, func(k int8, v interface{}) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkInt8StringMapDeterministic", t, func() {
		var keys = make([]int8, 0, n)
		var value string
		var tm = make(map[int8]string)
		for i := 0; i < n; i++ {
			var key int8
			key = int8(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]int8, 0, n)
		WalkInt8StringMapDeterministic(tm, func(k int8, v string) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkInt8UintMapDeterministic", t, func() {
		var keys = make([]int8, 0, n)
		var value uint
		var tm = make(map[int8]uint)
		for i := 0; i < n; i++ {
			var key int8
			key = int8(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]int8, 0, n)
		WalkInt8UintMapDeterministic(tm, func(k int8, v uint) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkInt8Uint16MapDeterministic", t, func() {
		var keys = make([]int8, 0, n)
		var value uint16
		var tm = make(map[int8]uint16)
		for i := 0; i < n; i++ {
			var key int8
			key = int8(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]int8, 0, n)
		WalkInt8Uint16MapDeterministic(tm, func(k int8, v uint16) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkInt8Uint32MapDeterministic", t, func() {
		var keys = make([]int8, 0, n)
		var value uint32
		var tm = make(map[int8]uint32)
		for i := 0; i < n; i++ {
			var key int8
			key = int8(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]int8, 0, n)
		WalkInt8Uint32MapDeterministic(tm, func(k int8, v uint32) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkInt8Uint64MapDeterministic", t, func() {
		var keys = make([]int8, 0, n)
		var value uint64
		var tm = make(map[int8]uint64)
		for i := 0; i < n; i++ {
			var key int8
			key = int8(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]int8, 0, n)
		WalkInt8Uint64MapDeterministic(tm, func(k int8, v uint64) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkInt8Uint8MapDeterministic", t, func() {
		var keys = make([]int8, 0, n)
		var value uint8
		var tm = make(map[int8]uint8)
		for i := 0; i < n; i++ {
			var key int8
			key = int8(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]int8, 0, n)
		WalkInt8Uint8MapDeterministic(tm, func(k int8, v uint8) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkStringFloat32MapDeterministic", t, func() {
		var keys = make([]string, 0, n)
		var value float32
		var tm = make(map[string]float32)
		for i := 0; i < n; i++ {
			var key string
			key = strconv.FormatInt(int64(i), 10)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Strings(keys)

		var dest = make([]string, 0, n)
		WalkStringFloat32MapDeterministic(tm, func(k string, v float32) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkStringFloat64MapDeterministic", t, func() {
		var keys = make([]string, 0, n)
		var value float64
		var tm = make(map[string]float64)
		for i := 0; i < n; i++ {
			var key string
			key = strconv.FormatInt(int64(i), 10)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Strings(keys)

		var dest = make([]string, 0, n)
		WalkStringFloat64MapDeterministic(tm, func(k string, v float64) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkStringIntMapDeterministic", t, func() {
		var keys = make([]string, 0, n)
		var value int
		var tm = make(map[string]int)
		for i := 0; i < n; i++ {
			var key string
			key = strconv.FormatInt(int64(i), 10)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Strings(keys)

		var dest = make([]string, 0, n)
		WalkStringIntMapDeterministic(tm, func(k string, v int) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkStringInt16MapDeterministic", t, func() {
		var keys = make([]string, 0, n)
		var value int16
		var tm = make(map[string]int16)
		for i := 0; i < n; i++ {
			var key string
			key = strconv.FormatInt(int64(i), 10)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Strings(keys)

		var dest = make([]string, 0, n)
		WalkStringInt16MapDeterministic(tm, func(k string, v int16) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkStringInt32MapDeterministic", t, func() {
		var keys = make([]string, 0, n)
		var value int32
		var tm = make(map[string]int32)
		for i := 0; i < n; i++ {
			var key string
			key = strconv.FormatInt(int64(i), 10)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Strings(keys)

		var dest = make([]string, 0, n)
		WalkStringInt32MapDeterministic(tm, func(k string, v int32) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkStringInt64MapDeterministic", t, func() {
		var keys = make([]string, 0, n)
		var value int64
		var tm = make(map[string]int64)
		for i := 0; i < n; i++ {
			var key string
			key = strconv.FormatInt(int64(i), 10)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Strings(keys)

		var dest = make([]string, 0, n)
		WalkStringInt64MapDeterministic(tm, func(k string, v int64) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkStringInt8MapDeterministic", t, func() {
		var keys = make([]string, 0, n)
		var value int8
		var tm = make(map[string]int8)
		for i := 0; i < n; i++ {
			var key string
			key = strconv.FormatInt(int64(i), 10)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Strings(keys)

		var dest = make([]string, 0, n)
		WalkStringInt8MapDeterministic(tm, func(k string, v int8) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkStringInterfaceMapDeterministic", t, func() {
		var keys = make([]string, 0, n)
		var value interface{}
		var tm = make(map[string]interface{})
		for i := 0; i < n; i++ {
			var key string
			key = strconv.FormatInt(int64(i), 10)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Strings(keys)

		var dest = make([]string, 0, n)
		WalkStringInterfaceMapDeterministic(tm, func(k string, v interface{}) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkStringStringMapDeterministic", t, func() {
		var keys = make([]string, 0, n)
		var value string
		var tm = make(map[string]string)
		for i := 0; i < n; i++ {
			var key string
			key = strconv.FormatInt(int64(i), 10)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Strings(keys)

		var dest = make([]string, 0, n)
		WalkStringStringMapDeterministic(tm, func(k string, v string) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkStringUintMapDeterministic", t, func() {
		var keys = make([]string, 0, n)
		var value uint
		var tm = make(map[string]uint)
		for i := 0; i < n; i++ {
			var key string
			key = strconv.FormatInt(int64(i), 10)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Strings(keys)

		var dest = make([]string, 0, n)
		WalkStringUintMapDeterministic(tm, func(k string, v uint) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkStringUint16MapDeterministic", t, func() {
		var keys = make([]string, 0, n)
		var value uint16
		var tm = make(map[string]uint16)
		for i := 0; i < n; i++ {
			var key string
			key = strconv.FormatInt(int64(i), 10)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Strings(keys)

		var dest = make([]string, 0, n)
		WalkStringUint16MapDeterministic(tm, func(k string, v uint16) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkStringUint32MapDeterministic", t, func() {
		var keys = make([]string, 0, n)
		var value uint32
		var tm = make(map[string]uint32)
		for i := 0; i < n; i++ {
			var key string
			key = strconv.FormatInt(int64(i), 10)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Strings(keys)

		var dest = make([]string, 0, n)
		WalkStringUint32MapDeterministic(tm, func(k string, v uint32) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkStringUint64MapDeterministic", t, func() {
		var keys = make([]string, 0, n)
		var value uint64
		var tm = make(map[string]uint64)
		for i := 0; i < n; i++ {
			var key string
			key = strconv.FormatInt(int64(i), 10)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Strings(keys)

		var dest = make([]string, 0, n)
		WalkStringUint64MapDeterministic(tm, func(k string, v uint64) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkStringUint8MapDeterministic", t, func() {
		var keys = make([]string, 0, n)
		var value uint8
		var tm = make(map[string]uint8)
		for i := 0; i < n; i++ {
			var key string
			key = strconv.FormatInt(int64(i), 10)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Strings(keys)

		var dest = make([]string, 0, n)
		WalkStringUint8MapDeterministic(tm, func(k string, v uint8) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkUintFloat32MapDeterministic", t, func() {
		var keys = make([]uint, 0, n)
		var value float32
		var tm = make(map[uint]float32)
		for i := 0; i < n; i++ {
			var key uint
			key = uint(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]uint, 0, n)
		WalkUintFloat32MapDeterministic(tm, func(k uint, v float32) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkUintFloat64MapDeterministic", t, func() {
		var keys = make([]uint, 0, n)
		var value float64
		var tm = make(map[uint]float64)
		for i := 0; i < n; i++ {
			var key uint
			key = uint(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]uint, 0, n)
		WalkUintFloat64MapDeterministic(tm, func(k uint, v float64) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkUintIntMapDeterministic", t, func() {
		var keys = make([]uint, 0, n)
		var value int
		var tm = make(map[uint]int)
		for i := 0; i < n; i++ {
			var key uint
			key = uint(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]uint, 0, n)
		WalkUintIntMapDeterministic(tm, func(k uint, v int) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkUintInt16MapDeterministic", t, func() {
		var keys = make([]uint, 0, n)
		var value int16
		var tm = make(map[uint]int16)
		for i := 0; i < n; i++ {
			var key uint
			key = uint(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]uint, 0, n)
		WalkUintInt16MapDeterministic(tm, func(k uint, v int16) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkUintInt32MapDeterministic", t, func() {
		var keys = make([]uint, 0, n)
		var value int32
		var tm = make(map[uint]int32)
		for i := 0; i < n; i++ {
			var key uint
			key = uint(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]uint, 0, n)
		WalkUintInt32MapDeterministic(tm, func(k uint, v int32) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkUintInt64MapDeterministic", t, func() {
		var keys = make([]uint, 0, n)
		var value int64
		var tm = make(map[uint]int64)
		for i := 0; i < n; i++ {
			var key uint
			key = uint(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]uint, 0, n)
		WalkUintInt64MapDeterministic(tm, func(k uint, v int64) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkUintInt8MapDeterministic", t, func() {
		var keys = make([]uint, 0, n)
		var value int8
		var tm = make(map[uint]int8)
		for i := 0; i < n; i++ {
			var key uint
			key = uint(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]uint, 0, n)
		WalkUintInt8MapDeterministic(tm, func(k uint, v int8) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkUintInterfaceMapDeterministic", t, func() {
		var keys = make([]uint, 0, n)
		var value interface{}
		var tm = make(map[uint]interface{})
		for i := 0; i < n; i++ {
			var key uint
			key = uint(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]uint, 0, n)
		WalkUintInterfaceMapDeterministic(tm, func(k uint, v interface{}) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkUintStringMapDeterministic", t, func() {
		var keys = make([]uint, 0, n)
		var value string
		var tm = make(map[uint]string)
		for i := 0; i < n; i++ {
			var key uint
			key = uint(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]uint, 0, n)
		WalkUintStringMapDeterministic(tm, func(k uint, v string) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkUintUintMapDeterministic", t, func() {
		var keys = make([]uint, 0, n)
		var value uint
		var tm = make(map[uint]uint)
		for i := 0; i < n; i++ {
			var key uint
			key = uint(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]uint, 0, n)
		WalkUintUintMapDeterministic(tm, func(k uint, v uint) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkUintUint16MapDeterministic", t, func() {
		var keys = make([]uint, 0, n)
		var value uint16
		var tm = make(map[uint]uint16)
		for i := 0; i < n; i++ {
			var key uint
			key = uint(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]uint, 0, n)
		WalkUintUint16MapDeterministic(tm, func(k uint, v uint16) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkUintUint32MapDeterministic", t, func() {
		var keys = make([]uint, 0, n)
		var value uint32
		var tm = make(map[uint]uint32)
		for i := 0; i < n; i++ {
			var key uint
			key = uint(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]uint, 0, n)
		WalkUintUint32MapDeterministic(tm, func(k uint, v uint32) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkUintUint64MapDeterministic", t, func() {
		var keys = make([]uint, 0, n)
		var value uint64
		var tm = make(map[uint]uint64)
		for i := 0; i < n; i++ {
			var key uint
			key = uint(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]uint, 0, n)
		WalkUintUint64MapDeterministic(tm, func(k uint, v uint64) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkUintUint8MapDeterministic", t, func() {
		var keys = make([]uint, 0, n)
		var value uint8
		var tm = make(map[uint]uint8)
		for i := 0; i < n; i++ {
			var key uint
			key = uint(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]uint, 0, n)
		WalkUintUint8MapDeterministic(tm, func(k uint, v uint8) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkUint16Float32MapDeterministic", t, func() {
		var keys = make([]uint16, 0, n)
		var value float32
		var tm = make(map[uint16]float32)
		for i := 0; i < n; i++ {
			var key uint16
			key = uint16(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]uint16, 0, n)
		WalkUint16Float32MapDeterministic(tm, func(k uint16, v float32) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkUint16Float64MapDeterministic", t, func() {
		var keys = make([]uint16, 0, n)
		var value float64
		var tm = make(map[uint16]float64)
		for i := 0; i < n; i++ {
			var key uint16
			key = uint16(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]uint16, 0, n)
		WalkUint16Float64MapDeterministic(tm, func(k uint16, v float64) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkUint16IntMapDeterministic", t, func() {
		var keys = make([]uint16, 0, n)
		var value int
		var tm = make(map[uint16]int)
		for i := 0; i < n; i++ {
			var key uint16
			key = uint16(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]uint16, 0, n)
		WalkUint16IntMapDeterministic(tm, func(k uint16, v int) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkUint16Int16MapDeterministic", t, func() {
		var keys = make([]uint16, 0, n)
		var value int16
		var tm = make(map[uint16]int16)
		for i := 0; i < n; i++ {
			var key uint16
			key = uint16(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]uint16, 0, n)
		WalkUint16Int16MapDeterministic(tm, func(k uint16, v int16) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkUint16Int32MapDeterministic", t, func() {
		var keys = make([]uint16, 0, n)
		var value int32
		var tm = make(map[uint16]int32)
		for i := 0; i < n; i++ {
			var key uint16
			key = uint16(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]uint16, 0, n)
		WalkUint16Int32MapDeterministic(tm, func(k uint16, v int32) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkUint16Int64MapDeterministic", t, func() {
		var keys = make([]uint16, 0, n)
		var value int64
		var tm = make(map[uint16]int64)
		for i := 0; i < n; i++ {
			var key uint16
			key = uint16(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]uint16, 0, n)
		WalkUint16Int64MapDeterministic(tm, func(k uint16, v int64) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkUint16Int8MapDeterministic", t, func() {
		var keys = make([]uint16, 0, n)
		var value int8
		var tm = make(map[uint16]int8)
		for i := 0; i < n; i++ {
			var key uint16
			key = uint16(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]uint16, 0, n)
		WalkUint16Int8MapDeterministic(tm, func(k uint16, v int8) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkUint16InterfaceMapDeterministic", t, func() {
		var keys = make([]uint16, 0, n)
		var value interface{}
		var tm = make(map[uint16]interface{})
		for i := 0; i < n; i++ {
			var key uint16
			key = uint16(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]uint16, 0, n)
		WalkUint16InterfaceMapDeterministic(tm, func(k uint16, v interface{}) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkUint16StringMapDeterministic", t, func() {
		var keys = make([]uint16, 0, n)
		var value string
		var tm = make(map[uint16]string)
		for i := 0; i < n; i++ {
			var key uint16
			key = uint16(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]uint16, 0, n)
		WalkUint16StringMapDeterministic(tm, func(k uint16, v string) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkUint16UintMapDeterministic", t, func() {
		var keys = make([]uint16, 0, n)
		var value uint
		var tm = make(map[uint16]uint)
		for i := 0; i < n; i++ {
			var key uint16
			key = uint16(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]uint16, 0, n)
		WalkUint16UintMapDeterministic(tm, func(k uint16, v uint) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkUint16Uint16MapDeterministic", t, func() {
		var keys = make([]uint16, 0, n)
		var value uint16
		var tm = make(map[uint16]uint16)
		for i := 0; i < n; i++ {
			var key uint16
			key = uint16(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]uint16, 0, n)
		WalkUint16Uint16MapDeterministic(tm, func(k uint16, v uint16) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkUint16Uint32MapDeterministic", t, func() {
		var keys = make([]uint16, 0, n)
		var value uint32
		var tm = make(map[uint16]uint32)
		for i := 0; i < n; i++ {
			var key uint16
			key = uint16(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]uint16, 0, n)
		WalkUint16Uint32MapDeterministic(tm, func(k uint16, v uint32) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkUint16Uint64MapDeterministic", t, func() {
		var keys = make([]uint16, 0, n)
		var value uint64
		var tm = make(map[uint16]uint64)
		for i := 0; i < n; i++ {
			var key uint16
			key = uint16(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]uint16, 0, n)
		WalkUint16Uint64MapDeterministic(tm, func(k uint16, v uint64) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkUint16Uint8MapDeterministic", t, func() {
		var keys = make([]uint16, 0, n)
		var value uint8
		var tm = make(map[uint16]uint8)
		for i := 0; i < n; i++ {
			var key uint16
			key = uint16(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]uint16, 0, n)
		WalkUint16Uint8MapDeterministic(tm, func(k uint16, v uint8) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkUint32Float32MapDeterministic", t, func() {
		var keys = make([]uint32, 0, n)
		var value float32
		var tm = make(map[uint32]float32)
		for i := 0; i < n; i++ {
			var key uint32
			key = uint32(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]uint32, 0, n)
		WalkUint32Float32MapDeterministic(tm, func(k uint32, v float32) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkUint32Float64MapDeterministic", t, func() {
		var keys = make([]uint32, 0, n)
		var value float64
		var tm = make(map[uint32]float64)
		for i := 0; i < n; i++ {
			var key uint32
			key = uint32(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]uint32, 0, n)
		WalkUint32Float64MapDeterministic(tm, func(k uint32, v float64) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkUint32IntMapDeterministic", t, func() {
		var keys = make([]uint32, 0, n)
		var value int
		var tm = make(map[uint32]int)
		for i := 0; i < n; i++ {
			var key uint32
			key = uint32(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]uint32, 0, n)
		WalkUint32IntMapDeterministic(tm, func(k uint32, v int) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkUint32Int16MapDeterministic", t, func() {
		var keys = make([]uint32, 0, n)
		var value int16
		var tm = make(map[uint32]int16)
		for i := 0; i < n; i++ {
			var key uint32
			key = uint32(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]uint32, 0, n)
		WalkUint32Int16MapDeterministic(tm, func(k uint32, v int16) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkUint32Int32MapDeterministic", t, func() {
		var keys = make([]uint32, 0, n)
		var value int32
		var tm = make(map[uint32]int32)
		for i := 0; i < n; i++ {
			var key uint32
			key = uint32(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]uint32, 0, n)
		WalkUint32Int32MapDeterministic(tm, func(k uint32, v int32) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkUint32Int64MapDeterministic", t, func() {
		var keys = make([]uint32, 0, n)
		var value int64
		var tm = make(map[uint32]int64)
		for i := 0; i < n; i++ {
			var key uint32
			key = uint32(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]uint32, 0, n)
		WalkUint32Int64MapDeterministic(tm, func(k uint32, v int64) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkUint32Int8MapDeterministic", t, func() {
		var keys = make([]uint32, 0, n)
		var value int8
		var tm = make(map[uint32]int8)
		for i := 0; i < n; i++ {
			var key uint32
			key = uint32(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]uint32, 0, n)
		WalkUint32Int8MapDeterministic(tm, func(k uint32, v int8) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkUint32InterfaceMapDeterministic", t, func() {
		var keys = make([]uint32, 0, n)
		var value interface{}
		var tm = make(map[uint32]interface{})
		for i := 0; i < n; i++ {
			var key uint32
			key = uint32(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]uint32, 0, n)
		WalkUint32InterfaceMapDeterministic(tm, func(k uint32, v interface{}) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkUint32StringMapDeterministic", t, func() {
		var keys = make([]uint32, 0, n)
		var value string
		var tm = make(map[uint32]string)
		for i := 0; i < n; i++ {
			var key uint32
			key = uint32(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]uint32, 0, n)
		WalkUint32StringMapDeterministic(tm, func(k uint32, v string) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkUint32UintMapDeterministic", t, func() {
		var keys = make([]uint32, 0, n)
		var value uint
		var tm = make(map[uint32]uint)
		for i := 0; i < n; i++ {
			var key uint32
			key = uint32(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]uint32, 0, n)
		WalkUint32UintMapDeterministic(tm, func(k uint32, v uint) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkUint32Uint16MapDeterministic", t, func() {
		var keys = make([]uint32, 0, n)
		var value uint16
		var tm = make(map[uint32]uint16)
		for i := 0; i < n; i++ {
			var key uint32
			key = uint32(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]uint32, 0, n)
		WalkUint32Uint16MapDeterministic(tm, func(k uint32, v uint16) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkUint32Uint32MapDeterministic", t, func() {
		var keys = make([]uint32, 0, n)
		var value uint32
		var tm = make(map[uint32]uint32)
		for i := 0; i < n; i++ {
			var key uint32
			key = uint32(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]uint32, 0, n)
		WalkUint32Uint32MapDeterministic(tm, func(k uint32, v uint32) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkUint32Uint64MapDeterministic", t, func() {
		var keys = make([]uint32, 0, n)
		var value uint64
		var tm = make(map[uint32]uint64)
		for i := 0; i < n; i++ {
			var key uint32
			key = uint32(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]uint32, 0, n)
		WalkUint32Uint64MapDeterministic(tm, func(k uint32, v uint64) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkUint32Uint8MapDeterministic", t, func() {
		var keys = make([]uint32, 0, n)
		var value uint8
		var tm = make(map[uint32]uint8)
		for i := 0; i < n; i++ {
			var key uint32
			key = uint32(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]uint32, 0, n)
		WalkUint32Uint8MapDeterministic(tm, func(k uint32, v uint8) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkUint64Float32MapDeterministic", t, func() {
		var keys = make([]uint64, 0, n)
		var value float32
		var tm = make(map[uint64]float32)
		for i := 0; i < n; i++ {
			var key uint64
			key = uint64(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]uint64, 0, n)
		WalkUint64Float32MapDeterministic(tm, func(k uint64, v float32) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkUint64Float64MapDeterministic", t, func() {
		var keys = make([]uint64, 0, n)
		var value float64
		var tm = make(map[uint64]float64)
		for i := 0; i < n; i++ {
			var key uint64
			key = uint64(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]uint64, 0, n)
		WalkUint64Float64MapDeterministic(tm, func(k uint64, v float64) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkUint64IntMapDeterministic", t, func() {
		var keys = make([]uint64, 0, n)
		var value int
		var tm = make(map[uint64]int)
		for i := 0; i < n; i++ {
			var key uint64
			key = uint64(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]uint64, 0, n)
		WalkUint64IntMapDeterministic(tm, func(k uint64, v int) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkUint64Int16MapDeterministic", t, func() {
		var keys = make([]uint64, 0, n)
		var value int16
		var tm = make(map[uint64]int16)
		for i := 0; i < n; i++ {
			var key uint64
			key = uint64(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]uint64, 0, n)
		WalkUint64Int16MapDeterministic(tm, func(k uint64, v int16) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkUint64Int32MapDeterministic", t, func() {
		var keys = make([]uint64, 0, n)
		var value int32
		var tm = make(map[uint64]int32)
		for i := 0; i < n; i++ {
			var key uint64
			key = uint64(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]uint64, 0, n)
		WalkUint64Int32MapDeterministic(tm, func(k uint64, v int32) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkUint64Int64MapDeterministic", t, func() {
		var keys = make([]uint64, 0, n)
		var value int64
		var tm = make(map[uint64]int64)
		for i := 0; i < n; i++ {
			var key uint64
			key = uint64(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]uint64, 0, n)
		WalkUint64Int64MapDeterministic(tm, func(k uint64, v int64) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkUint64Int8MapDeterministic", t, func() {
		var keys = make([]uint64, 0, n)
		var value int8
		var tm = make(map[uint64]int8)
		for i := 0; i < n; i++ {
			var key uint64
			key = uint64(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]uint64, 0, n)
		WalkUint64Int8MapDeterministic(tm, func(k uint64, v int8) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkUint64InterfaceMapDeterministic", t, func() {
		var keys = make([]uint64, 0, n)
		var value interface{}
		var tm = make(map[uint64]interface{})
		for i := 0; i < n; i++ {
			var key uint64
			key = uint64(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]uint64, 0, n)
		WalkUint64InterfaceMapDeterministic(tm, func(k uint64, v interface{}) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkUint64StringMapDeterministic", t, func() {
		var keys = make([]uint64, 0, n)
		var value string
		var tm = make(map[uint64]string)
		for i := 0; i < n; i++ {
			var key uint64
			key = uint64(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]uint64, 0, n)
		WalkUint64StringMapDeterministic(tm, func(k uint64, v string) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkUint64UintMapDeterministic", t, func() {
		var keys = make([]uint64, 0, n)
		var value uint
		var tm = make(map[uint64]uint)
		for i := 0; i < n; i++ {
			var key uint64
			key = uint64(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]uint64, 0, n)
		WalkUint64UintMapDeterministic(tm, func(k uint64, v uint) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkUint64Uint16MapDeterministic", t, func() {
		var keys = make([]uint64, 0, n)
		var value uint16
		var tm = make(map[uint64]uint16)
		for i := 0; i < n; i++ {
			var key uint64
			key = uint64(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]uint64, 0, n)
		WalkUint64Uint16MapDeterministic(tm, func(k uint64, v uint16) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkUint64Uint32MapDeterministic", t, func() {
		var keys = make([]uint64, 0, n)
		var value uint32
		var tm = make(map[uint64]uint32)
		for i := 0; i < n; i++ {
			var key uint64
			key = uint64(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]uint64, 0, n)
		WalkUint64Uint32MapDeterministic(tm, func(k uint64, v uint32) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkUint64Uint64MapDeterministic", t, func() {
		var keys = make([]uint64, 0, n)
		var value uint64
		var tm = make(map[uint64]uint64)
		for i := 0; i < n; i++ {
			var key uint64
			key = uint64(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]uint64, 0, n)
		WalkUint64Uint64MapDeterministic(tm, func(k uint64, v uint64) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkUint64Uint8MapDeterministic", t, func() {
		var keys = make([]uint64, 0, n)
		var value uint8
		var tm = make(map[uint64]uint8)
		for i := 0; i < n; i++ {
			var key uint64
			key = uint64(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]uint64, 0, n)
		WalkUint64Uint8MapDeterministic(tm, func(k uint64, v uint8) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkUint8Float32MapDeterministic", t, func() {
		var keys = make([]uint8, 0, n)
		var value float32
		var tm = make(map[uint8]float32)
		for i := 0; i < n; i++ {
			var key uint8
			key = uint8(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]uint8, 0, n)
		WalkUint8Float32MapDeterministic(tm, func(k uint8, v float32) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkUint8Float64MapDeterministic", t, func() {
		var keys = make([]uint8, 0, n)
		var value float64
		var tm = make(map[uint8]float64)
		for i := 0; i < n; i++ {
			var key uint8
			key = uint8(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]uint8, 0, n)
		WalkUint8Float64MapDeterministic(tm, func(k uint8, v float64) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkUint8IntMapDeterministic", t, func() {
		var keys = make([]uint8, 0, n)
		var value int
		var tm = make(map[uint8]int)
		for i := 0; i < n; i++ {
			var key uint8
			key = uint8(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]uint8, 0, n)
		WalkUint8IntMapDeterministic(tm, func(k uint8, v int) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkUint8Int16MapDeterministic", t, func() {
		var keys = make([]uint8, 0, n)
		var value int16
		var tm = make(map[uint8]int16)
		for i := 0; i < n; i++ {
			var key uint8
			key = uint8(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]uint8, 0, n)
		WalkUint8Int16MapDeterministic(tm, func(k uint8, v int16) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkUint8Int32MapDeterministic", t, func() {
		var keys = make([]uint8, 0, n)
		var value int32
		var tm = make(map[uint8]int32)
		for i := 0; i < n; i++ {
			var key uint8
			key = uint8(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]uint8, 0, n)
		WalkUint8Int32MapDeterministic(tm, func(k uint8, v int32) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkUint8Int64MapDeterministic", t, func() {
		var keys = make([]uint8, 0, n)
		var value int64
		var tm = make(map[uint8]int64)
		for i := 0; i < n; i++ {
			var key uint8
			key = uint8(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]uint8, 0, n)
		WalkUint8Int64MapDeterministic(tm, func(k uint8, v int64) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkUint8Int8MapDeterministic", t, func() {
		var keys = make([]uint8, 0, n)
		var value int8
		var tm = make(map[uint8]int8)
		for i := 0; i < n; i++ {
			var key uint8
			key = uint8(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]uint8, 0, n)
		WalkUint8Int8MapDeterministic(tm, func(k uint8, v int8) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkUint8InterfaceMapDeterministic", t, func() {
		var keys = make([]uint8, 0, n)
		var value interface{}
		var tm = make(map[uint8]interface{})
		for i := 0; i < n; i++ {
			var key uint8
			key = uint8(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]uint8, 0, n)
		WalkUint8InterfaceMapDeterministic(tm, func(k uint8, v interface{}) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkUint8StringMapDeterministic", t, func() {
		var keys = make([]uint8, 0, n)
		var value string
		var tm = make(map[uint8]string)
		for i := 0; i < n; i++ {
			var key uint8
			key = uint8(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]uint8, 0, n)
		WalkUint8StringMapDeterministic(tm, func(k uint8, v string) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkUint8UintMapDeterministic", t, func() {
		var keys = make([]uint8, 0, n)
		var value uint
		var tm = make(map[uint8]uint)
		for i := 0; i < n; i++ {
			var key uint8
			key = uint8(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]uint8, 0, n)
		WalkUint8UintMapDeterministic(tm, func(k uint8, v uint) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkUint8Uint16MapDeterministic", t, func() {
		var keys = make([]uint8, 0, n)
		var value uint16
		var tm = make(map[uint8]uint16)
		for i := 0; i < n; i++ {
			var key uint8
			key = uint8(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]uint8, 0, n)
		WalkUint8Uint16MapDeterministic(tm, func(k uint8, v uint16) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkUint8Uint32MapDeterministic", t, func() {
		var keys = make([]uint8, 0, n)
		var value uint32
		var tm = make(map[uint8]uint32)
		for i := 0; i < n; i++ {
			var key uint8
			key = uint8(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]uint8, 0, n)
		WalkUint8Uint32MapDeterministic(tm, func(k uint8, v uint32) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkUint8Uint64MapDeterministic", t, func() {
		var keys = make([]uint8, 0, n)
		var value uint64
		var tm = make(map[uint8]uint64)
		for i := 0; i < n; i++ {
			var key uint8
			key = uint8(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]uint8, 0, n)
		WalkUint8Uint64MapDeterministic(tm, func(k uint8, v uint64) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})

	Convey("WalkUint8Uint8MapDeterministic", t, func() {
		var keys = make([]uint8, 0, n)
		var value uint8
		var tm = make(map[uint8]uint8)
		for i := 0; i < n; i++ {
			var key uint8
			key = uint8(i)
			tm[key] = value
			keys = append(keys, key)
		}
		sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })

		var dest = make([]uint8, 0, n)
		WalkUint8Uint8MapDeterministic(tm, func(k uint8, v uint8) bool {
			dest = append(dest, k)
			return true
		})

		for k, v := range keys {
			So(v, ShouldEqual, dest[k])
		}
	})
}