diff --git a/msgp/setof/_gen/main.go b/msgp/setof/_gen/main.go index 1329e19e..369fcc50 100644 --- a/msgp/setof/_gen/main.go +++ b/msgp/setof/_gen/main.go @@ -3,6 +3,7 @@ package main import ( "fmt" "os" + "os/exec" "strings" ) @@ -23,7 +24,7 @@ func (s *Foo) DecodeMsg(reader *msgp.Reader) error { } else { clear(dst) } - for i := uint32(0); i < sz; i++ { + for range sz { var k string k, err = reader.ReadString() if err != nil { @@ -52,7 +53,7 @@ func (s *Foo) UnmarshalMsg(bytes []byte) ([]byte, error) { } else { clear(dst) } - for i := uint32(0); i < sz; i++ { + for range sz { var k string k, bytes, err = msgp.ReadStringBytes(bytes) if err != nil { @@ -69,9 +70,6 @@ func (s Foo) Msgsize() int { if s == nil { return msgp.NilSize } - if len(s) == 0 { - return msgp.ArrayHeaderSize - } size := msgp.ArrayHeaderSize size += len(s) * msgp.StringPrefixSize return size @@ -121,6 +119,7 @@ func (s Foo) MarshalMsg(bytes []byte) ([]byte, error) { if len(s) == 0 { return msgp.AppendArrayHeader(bytes, 0), nil } + bytes = ensure(bytes, s.Msgsize()) bytes = msgp.AppendArrayHeader(bytes, uint32(len(s))) for k := range s { bytes = msgp.AppendString(bytes, string(k)) @@ -159,7 +158,12 @@ func (s Foo) EncodeMsg(writer *msgp.Writer) error { for k := range s { keys = append(keys, k) } - sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] }) + slices.SortFunc(keys, func(a, b string) int { + if a < b { + return -1 + } + return 1 + }) for _, k := range keys { err = writer.WriteString(k) @@ -178,12 +182,18 @@ func (s Foo) MarshalMsg(bytes []byte) ([]byte, error) { if len(s) == 0 { return msgp.AppendArrayHeader(bytes, 0), nil } + bytes = ensure(bytes, s.Msgsize()) bytes = msgp.AppendArrayHeader(bytes, uint32(len(s))) keys := make([]string, 0, len(s)) for k := range s { keys = append(keys, k) } - sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] }) + slices.SortFunc(keys, func(a, b string) int { + if a < b { + return -1 + } + return 1 + }) for _, k := range keys { bytes = msgp.AppendString(bytes, k) } @@ -195,12 +205,330 @@ func (s Foo) AsSlice() []string { if s == nil { return nil } - dst := make([]string, 0, len(s)) + keys := make([]string, 0, len(s)) for k := range s { - dst = append(dst, k) + keys = append(keys, k) + } + slices.SortFunc(keys, func(a, b string) int { + if a < b { + return -1 + } + return 1 + }) + return keys +} +` + +const testTemplate = ` +func Test{{.TypeName}}_RoundTrip(t *testing.T) { + set := make({{.TypeName}}) + {{.PopulateSet}} + + // Test EncodeMsg/DecodeMsg + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + err := set.EncodeMsg(writer) + if err != nil { + t.Fatalf("EncodeMsg failed: %v", err) + } + writer.Flush() + + reader := msgp.NewReader(&buf) + var decoded {{.TypeName}} + err = decoded.DecodeMsg(reader) + if err != nil { + t.Fatalf("DecodeMsg failed: %v", err) + } + + if len(set) != len(decoded) { + t.Fatalf("length mismatch: expected %d, got %d", len(set), len(decoded)) + } + + for k := range set { + if _, ok := decoded[k]; !ok { + t.Fatalf("missing key: %v", k) + } + } + + // Test MarshalMsg/UnmarshalMsg + data, err := set.MarshalMsg(nil) + if err != nil { + t.Fatalf("MarshalMsg failed: %v", err) + } + + var unmarshaled {{.TypeName}} + _, err = unmarshaled.UnmarshalMsg(data) + if err != nil { + t.Fatalf("UnmarshalMsg failed: %v", err) + } + + if len(set) != len(unmarshaled) { + t.Fatalf("length mismatch: expected %d, got %d", len(set), len(unmarshaled)) + } + + for k := range set { + if _, ok := unmarshaled[k]; !ok { + t.Fatalf("missing key: %v", k) + } + } +} + +func Test{{.TypeName}}_AsSlice(t *testing.T) { + set := make({{.TypeName}}) + {{.PopulateSet}} + + slice := set.AsSlice() + if len(slice) != len(set) { + t.Fatalf("length mismatch: expected %d, got %d", len(set), len(slice)) + } + + found := make(map[{{.GoType}}]bool) + for _, v := range slice { + found[v] = true + } + + for k := range set { + if !found[k] { + t.Fatalf("missing key in slice: %v", k) + } + } +} + +func Test{{.TypeName}}_FromSlice(t *testing.T) { + slice := []{{.GoType}}{{{.SliceValues}}} + set := {{.TypeName}}FromSlice(slice) + + if len(set) != len(slice) { + t.Fatalf("length mismatch: expected %d, got %d", len(slice), len(set)) + } + + for _, v := range slice { + if _, ok := set[v]; !ok { + t.Fatalf("missing key: %v", v) + } + } +} + +func Test{{.TypeName}}_NilHandling(t *testing.T) { + var nilSet {{.TypeName}} + + // Test nil encoding + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + err := nilSet.EncodeMsg(writer) + if err != nil { + t.Fatalf("EncodeMsg failed for nil: %v", err) + } + writer.Flush() + + // Test nil decoding + reader := msgp.NewReader(&buf) + var decoded {{.TypeName}} + err = decoded.DecodeMsg(reader) + if err != nil { + t.Fatalf("DecodeMsg failed for nil: %v", err) + } + + if decoded != nil { + t.Fatal("expected nil, got non-nil") + } + + // Test nil marshaling + data, err := nilSet.MarshalMsg(nil) + if err != nil { + t.Fatalf("MarshalMsg failed for nil: %v", err) + } + + // Test nil unmarshaling + var unmarshaled {{.TypeName}} + _, err = unmarshaled.UnmarshalMsg(data) + if err != nil { + t.Fatalf("UnmarshalMsg failed for nil: %v", err) + } + + if unmarshaled != nil { + t.Fatal("expected nil, got non-nil") + } + + // Test AsSlice on nil + slice := nilSet.AsSlice() + if slice != nil { + t.Fatal("expected nil slice, got non-nil") + } + + // Test FromSlice with nil + fromNilSlice := {{.TypeName}}FromSlice(nil) + if fromNilSlice != nil { + t.Fatal("expected nil from nil slice, got non-nil") + } +} + +func Test{{.TypeName}}_EmptySet(t *testing.T) { + set := make({{.TypeName}}) + + // Test empty set encoding + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + err := set.EncodeMsg(writer) + if err != nil { + t.Fatalf("EncodeMsg failed for empty: %v", err) + } + writer.Flush() + + // Test empty set decoding + reader := msgp.NewReader(&buf) + var decoded {{.TypeName}} + err = decoded.DecodeMsg(reader) + if err != nil { + t.Fatalf("DecodeMsg failed for empty: %v", err) + } + + if len(decoded) != 0 { + t.Fatalf("expected empty set, got length %d", len(decoded)) + } + + // Test empty set marshaling + data, err := set.MarshalMsg(nil) + if err != nil { + t.Fatalf("MarshalMsg failed for empty: %v", err) + } + + // Test empty set unmarshaling + var unmarshaled {{.TypeName}} + _, err = unmarshaled.UnmarshalMsg(data) + if err != nil { + t.Fatalf("UnmarshalMsg failed for empty: %v", err) + } + + if len(unmarshaled) != 0 { + t.Fatalf("expected empty set, got length %d", len(unmarshaled)) + } +} +` + +const benchTemplate = ` +func Benchmark{{.TypeName}}_EncodeMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make({{.TypeName}}) + {{.GeneratePopulateCode}} + + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + buf.Reset() + writer.Reset(&buf) + set.EncodeMsg(writer) + writer.Flush() + } + }) + } +} + +func Benchmark{{.TypeName}}_DecodeMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make({{.TypeName}}) + {{.GeneratePopulateCode}} + + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + set.EncodeMsg(writer) + writer.Flush() + encoded := buf.Bytes() + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + reader := msgp.NewReader(bytes.NewReader(encoded)) + var decoded {{.TypeName}} + decoded.DecodeMsg(reader) + } + }) + } +} + +func Benchmark{{.TypeName}}_MarshalMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make({{.TypeName}}) + {{.GeneratePopulateCode}} + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + _, err := set.MarshalMsg(nil) + if err != nil { + b.Fatal(err) + } + } + }) + } +} + +func Benchmark{{.TypeName}}_UnmarshalMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make({{.TypeName}}) + {{.GeneratePopulateCode}} + + data, _ := set.MarshalMsg(nil) + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + var decoded {{.TypeName}} + _, err := decoded.UnmarshalMsg(data) + if err != nil { + b.Fatal(err) + } + } + }) + } +} + +func Benchmark{{.TypeName}}_AsSlice(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make({{.TypeName}}) + {{.GeneratePopulateCode}} + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + _ = set.AsSlice() + } + }) + } +} + +func Benchmark{{.TypeName}}_FromSlice(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + {{.GenerateSliceCode}} + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + _ = {{.TypeName}}FromSlice(slice) + } + }) } - sort.Slice(dst, func(i, j int) bool { return dst[i] < dst[j] }) - return dst } ` @@ -214,6 +542,212 @@ type replacer struct { Sorter string // 'sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })' } +type testGen struct { + TypeName string + GoType string + PopulateSet string + SliceValues string + Size string +} + +func generateTestValues(goType string, size int) (populateSet, sliceValues string) { + var populate []string + var values []string + + switch goType { + case "string": + for i := 0; i < size; i++ { + val := fmt.Sprintf(`"val%d"`, i) + populate = append(populate, fmt.Sprintf("set[%s] = struct{}{}", val)) + values = append(values, val) + } + case "int8": + for i := 0; i < size; i++ { + val := fmt.Sprintf("%d", (i%256)-128) // int8 range: -128 to 127 + populate = append(populate, fmt.Sprintf("set[%s] = struct{}{}", val)) + values = append(values, val) + } + case "int16": + for i := 0; i < size; i++ { + val := fmt.Sprintf("%d", (i%65536)-32768) // int16 range: -32768 to 32767 + populate = append(populate, fmt.Sprintf("set[%s] = struct{}{}", val)) + values = append(values, val) + } + case "int", "int32", "int64": + for i := 0; i < size; i++ { + val := fmt.Sprintf("%d", i) + populate = append(populate, fmt.Sprintf("set[%s] = struct{}{}", val)) + values = append(values, val) + } + case "byte": + for i := 0; i < size; i++ { + val := fmt.Sprintf("%d", i%256) // Prevent byte overflow + populate = append(populate, fmt.Sprintf("set[%s] = struct{}{}", val)) + values = append(values, val) + } + case "uint8": + for i := 0; i < size; i++ { + val := fmt.Sprintf("%d", i%256) // Prevent uint8 overflow + populate = append(populate, fmt.Sprintf("set[%s] = struct{}{}", val)) + values = append(values, val) + } + case "uint16": + for i := 0; i < size; i++ { + val := fmt.Sprintf("%d", i%65536) // Prevent uint16 overflow + populate = append(populate, fmt.Sprintf("set[%s] = struct{}{}", val)) + values = append(values, val) + } + case "uint", "uint32", "uint64": + for i := 0; i < size; i++ { + val := fmt.Sprintf("%d", i) + populate = append(populate, fmt.Sprintf("set[%s] = struct{}{}", val)) + values = append(values, val) + } + case "float32", "float64": + for i := 0; i < size; i++ { + val := fmt.Sprintf("%d.0", i) + populate = append(populate, fmt.Sprintf("set[%s] = struct{}{}", val)) + values = append(values, val) + } + } + + return strings.Join(populate, "\n\t"), strings.Join(values, ", ") +} + +func generateDynamicPopulateCode(goType string) string { + switch goType { + case "string": + return `for i := 0; i < size; i++ { + set[fmt.Sprintf("val%d", i)] = struct{}{} + }` + case "int8": + return `for i := 0; i < size; i++ { + set[int8((i%256)-128)] = struct{}{} + }` + case "int16": + return `for i := 0; i < size; i++ { + set[int16((i%65536)-32768)] = struct{}{} + }` + case "int", "int32", "int64": + return `for i := 0; i < size; i++ { + set[` + goType + `(i)] = struct{}{} + }` + case "byte": + return `for i := 0; i < size; i++ { + set[byte(i%256)] = struct{}{} + }` + case "uint8": + return `for i := 0; i < size; i++ { + set[uint8(i%256)] = struct{}{} + }` + case "uint16": + return `for i := 0; i < size; i++ { + set[uint16(i%65536)] = struct{}{} + }` + case "uint", "uint32", "uint64": + return `for i := 0; i < size; i++ { + set[` + goType + `(i)] = struct{}{} + }` + case "float32", "float64": + return `for i := 0; i < size; i++ { + set[` + goType + `(i)] = struct{}{} + }` + } + return "" +} + +func generateDynamicSliceCode(goType string) string { + switch goType { + case "string": + return `slice := make([]string, size) + for i := 0; i < size; i++ { + slice[i] = fmt.Sprintf("val%d", i) + }` + case "int8": + return `slice := make([]int8, size) + for i := 0; i < size; i++ { + slice[i] = int8((i%256)-128) + }` + case "int16": + return `slice := make([]int16, size) + for i := 0; i < size; i++ { + slice[i] = int16((i%65536)-32768) + }` + case "int", "int32", "int64": + return `slice := make([]` + goType + `, size) + for i := 0; i < size; i++ { + slice[i] = ` + goType + `(i) + }` + case "byte": + return `slice := make([]byte, size) + for i := 0; i < size; i++ { + slice[i] = byte(i%256) + }` + case "uint8": + return `slice := make([]uint8, size) + for i := 0; i < size; i++ { + slice[i] = uint8(i%256) + }` + case "uint16": + return `slice := make([]uint16, size) + for i := 0; i < size; i++ { + slice[i] = uint16(i%65536) + }` + case "uint", "uint32", "uint64": + return `slice := make([]` + goType + `, size) + for i := 0; i < size; i++ { + slice[i] = ` + goType + `(i) + }` + case "float32", "float64": + return `slice := make([]` + goType + `, size) + for i := 0; i < size; i++ { + slice[i] = ` + goType + `(i) + }` + } + return "" +} + +func generateTests(out *os.File, r replacer) { + // Generate basic tests (using small set) + populateSet, sliceValues := generateTestValues(r.GoType, 5) + + // Regular type tests + testCode := testTemplate + testCode = strings.ReplaceAll(testCode, "{{.TypeName}}", r.PackageName) + testCode = strings.ReplaceAll(testCode, "{{.GoType}}", r.GoType) + testCode = strings.ReplaceAll(testCode, "{{.PopulateSet}}", populateSet) + testCode = strings.ReplaceAll(testCode, "{{.SliceValues}}", sliceValues) + fmt.Fprintln(out, testCode) + + // Sorted type tests + testCode = testTemplate + testCode = strings.ReplaceAll(testCode, "{{.TypeName}}", r.PackageName+"Sorted") + testCode = strings.ReplaceAll(testCode, "{{.GoType}}", r.GoType) + testCode = strings.ReplaceAll(testCode, "{{.PopulateSet}}", populateSet) + testCode = strings.ReplaceAll(testCode, "{{.SliceValues}}", sliceValues) + fmt.Fprintln(out, testCode) + + // Generate consolidated benchmarks + populateCode := generateDynamicPopulateCode(r.GoType) + sliceCode := generateDynamicSliceCode(r.GoType) + + // Regular type benchmarks + benchCode := benchTemplate + benchCode = strings.ReplaceAll(benchCode, "{{.TypeName}}", r.PackageName) + benchCode = strings.ReplaceAll(benchCode, "{{.GoType}}", r.GoType) + benchCode = strings.ReplaceAll(benchCode, "{{.GeneratePopulateCode}}", populateCode) + benchCode = strings.ReplaceAll(benchCode, "{{.GenerateSliceCode}}", sliceCode) + fmt.Fprintln(out, benchCode) + + // Sorted type benchmarks + benchCode = benchTemplate + benchCode = strings.ReplaceAll(benchCode, "{{.TypeName}}", r.PackageName+"Sorted") + benchCode = strings.ReplaceAll(benchCode, "{{.GoType}}", r.GoType) + benchCode = strings.ReplaceAll(benchCode, "{{.GeneratePopulateCode}}", populateCode) + benchCode = strings.ReplaceAll(benchCode, "{{.GenerateSliceCode}}", sliceCode) + fmt.Fprintln(out, benchCode) +} + var replacers = []replacer{ { GoType: "string", @@ -222,7 +756,7 @@ var replacers = []replacer{ EncodeValue: "WriteString", AppendValue: "AppendString", KeyLen: "size += len(s) * msgp.StringPrefixSize", - Sorter: "sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })", + Sorter: "slices.SortFunc(keys, func(a, b string) int {\n\t\tif a < b {\n\t\t\treturn -1\n\t\t}\n\t\treturn 1\n\t})", }, { GoType: "string", @@ -231,7 +765,8 @@ var replacers = []replacer{ EncodeValue: "WriteString", AppendValue: "AppendString", KeyLen: "for key := range s {\n\t\t\tsize += msgp.StringPrefixSize + len(key)\n\t\t}", - Sorter: "sort.Strings(keys)", + // Using slices.SortFunc is slower than sort.Strings + Sorter: "sort.Strings(keys)", }, { GoType: "int", @@ -340,6 +875,19 @@ var replacers = []replacer{ } func main() { + defer func() { + if r := recover(); r != nil { + panic(r) + } else { + // Format generated code + if err := exec.Command("go", "fmt", "../generated.go").Run(); err != nil { + fmt.Printf("Warning: failed to format generated.go: %v\n", err) + } + if err := exec.Command("go", "fmt", "../generated_test.go").Run(); err != nil { + fmt.Printf("Warning: failed to format generated_test.go: %v\n", err) + } + } + }() out, err := os.Create("../generated.go") if err != nil { panic(err) @@ -350,6 +898,7 @@ func main() { package setof import ( + "slices" "sort" "github.com/tinylib/msgp/msgp" @@ -368,16 +917,40 @@ import ( fmt.Fprintln(out, replaced) replaced = sorted + template + if r.Sorter != "" { + replaced = strings.ReplaceAll(replaced, base.Sorter, r.Sorter) + } replaced = strings.ReplaceAll(replaced, base.GoType, r.GoType) replaced = strings.ReplaceAll(replaced, base.PackageName, r.PackageName+"Sorted") replaced = strings.ReplaceAll(replaced, base.EncodeValue, r.EncodeValue) replaced = strings.ReplaceAll(replaced, base.DecodeValue, r.DecodeValue) replaced = strings.ReplaceAll(replaced, base.AppendValue, r.AppendValue) replaced = strings.ReplaceAll(replaced, base.KeyLen, r.KeyLen) - if r.Sorter != "" { - replaced = strings.ReplaceAll(replaced, base.Sorter, r.Sorter) - } fmt.Fprintln(out, replaced) } + + // Generate test file + testOut, err := os.Create("../generated_test.go") + if err != nil { + panic(err) + } + defer testOut.Close() + + fmt.Fprintln(testOut, `// Code generated by ./gen/main.go. DO NOT EDIT. + +package setof + +import ( + "bytes" + "fmt" + "testing" + + "github.com/tinylib/msgp/msgp" +)`) + + // Generate tests for each type (skip the template base type) + for _, r := range replacers[1:] { + generateTests(testOut, r) + } } diff --git a/msgp/setof/generated.go b/msgp/setof/generated.go index 2d1efed7..9cf64d0a 100644 --- a/msgp/setof/generated.go +++ b/msgp/setof/generated.go @@ -3,6 +3,7 @@ package setof import ( + "slices" "sort" "github.com/tinylib/msgp/msgp" @@ -38,6 +39,7 @@ func (s String) MarshalMsg(bytes []byte) ([]byte, error) { if len(s) == 0 { return msgp.AppendArrayHeader(bytes, 0), nil } + bytes = ensure(bytes, s.Msgsize()) bytes = msgp.AppendArrayHeader(bytes, uint32(len(s))) for k := range s { bytes = msgp.AppendString(bytes, string(k)) @@ -73,7 +75,7 @@ func (s *String) DecodeMsg(reader *msgp.Reader) error { } else { clear(dst) } - for i := uint32(0); i < sz; i++ { + for range sz { var k string k, err = reader.ReadString() if err != nil { @@ -102,7 +104,7 @@ func (s *String) UnmarshalMsg(bytes []byte) ([]byte, error) { } else { clear(dst) } - for i := uint32(0); i < sz; i++ { + for range sz { var k string k, bytes, err = msgp.ReadStringBytes(bytes) if err != nil { @@ -119,9 +121,6 @@ func (s String) Msgsize() int { if s == nil { return msgp.NilSize } - if len(s) == 0 { - return msgp.ArrayHeaderSize - } size := msgp.ArrayHeaderSize for key := range s { size += msgp.StringPrefixSize + len(key) @@ -177,6 +176,7 @@ func (s StringSorted) MarshalMsg(bytes []byte) ([]byte, error) { if len(s) == 0 { return msgp.AppendArrayHeader(bytes, 0), nil } + bytes = ensure(bytes, s.Msgsize()) bytes = msgp.AppendArrayHeader(bytes, uint32(len(s))) keys := make([]string, 0, len(s)) for k := range s { @@ -194,12 +194,12 @@ func (s StringSorted) AsSlice() []string { if s == nil { return nil } - dst := make([]string, 0, len(s)) + keys := make([]string, 0, len(s)) for k := range s { - dst = append(dst, k) + keys = append(keys, k) } - sort.Slice(dst, func(i, j int) bool { return dst[i] < dst[j] }) - return dst + sort.Strings(keys) + return keys } // DecodeMsg decodes the message from the reader. @@ -218,7 +218,7 @@ func (s *StringSorted) DecodeMsg(reader *msgp.Reader) error { } else { clear(dst) } - for i := uint32(0); i < sz; i++ { + for range sz { var k string k, err = reader.ReadString() if err != nil { @@ -247,7 +247,7 @@ func (s *StringSorted) UnmarshalMsg(bytes []byte) ([]byte, error) { } else { clear(dst) } - for i := uint32(0); i < sz; i++ { + for range sz { var k string k, bytes, err = msgp.ReadStringBytes(bytes) if err != nil { @@ -264,9 +264,6 @@ func (s StringSorted) Msgsize() int { if s == nil { return msgp.NilSize } - if len(s) == 0 { - return msgp.ArrayHeaderSize - } size := msgp.ArrayHeaderSize for key := range s { size += msgp.StringPrefixSize + len(key) @@ -316,6 +313,7 @@ func (s Int) MarshalMsg(bytes []byte) ([]byte, error) { if len(s) == 0 { return msgp.AppendArrayHeader(bytes, 0), nil } + bytes = ensure(bytes, s.Msgsize()) bytes = msgp.AppendArrayHeader(bytes, uint32(len(s))) for k := range s { bytes = msgp.AppendInt(bytes, int(k)) @@ -351,7 +349,7 @@ func (s *Int) DecodeMsg(reader *msgp.Reader) error { } else { clear(dst) } - for i := uint32(0); i < sz; i++ { + for range sz { var k int k, err = reader.ReadInt() if err != nil { @@ -380,7 +378,7 @@ func (s *Int) UnmarshalMsg(bytes []byte) ([]byte, error) { } else { clear(dst) } - for i := uint32(0); i < sz; i++ { + for range sz { var k int k, bytes, err = msgp.ReadIntBytes(bytes) if err != nil { @@ -397,9 +395,6 @@ func (s Int) Msgsize() int { if s == nil { return msgp.NilSize } - if len(s) == 0 { - return msgp.ArrayHeaderSize - } size := msgp.ArrayHeaderSize size += len(s) * msgp.IntSize return size @@ -434,7 +429,12 @@ func (s IntSorted) EncodeMsg(writer *msgp.Writer) error { for k := range s { keys = append(keys, k) } - sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] }) + slices.SortFunc(keys, func(a, b int) int { + if a < b { + return -1 + } + return 1 + }) for _, k := range keys { err = writer.WriteInt(k) @@ -453,12 +453,18 @@ func (s IntSorted) MarshalMsg(bytes []byte) ([]byte, error) { if len(s) == 0 { return msgp.AppendArrayHeader(bytes, 0), nil } + bytes = ensure(bytes, s.Msgsize()) bytes = msgp.AppendArrayHeader(bytes, uint32(len(s))) keys := make([]int, 0, len(s)) for k := range s { keys = append(keys, k) } - sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] }) + slices.SortFunc(keys, func(a, b int) int { + if a < b { + return -1 + } + return 1 + }) for _, k := range keys { bytes = msgp.AppendInt(bytes, k) } @@ -470,12 +476,17 @@ func (s IntSorted) AsSlice() []int { if s == nil { return nil } - dst := make([]int, 0, len(s)) + keys := make([]int, 0, len(s)) for k := range s { - dst = append(dst, k) + keys = append(keys, k) } - sort.Slice(dst, func(i, j int) bool { return dst[i] < dst[j] }) - return dst + slices.SortFunc(keys, func(a, b int) int { + if a < b { + return -1 + } + return 1 + }) + return keys } // DecodeMsg decodes the message from the reader. @@ -494,7 +505,7 @@ func (s *IntSorted) DecodeMsg(reader *msgp.Reader) error { } else { clear(dst) } - for i := uint32(0); i < sz; i++ { + for range sz { var k int k, err = reader.ReadInt() if err != nil { @@ -523,7 +534,7 @@ func (s *IntSorted) UnmarshalMsg(bytes []byte) ([]byte, error) { } else { clear(dst) } - for i := uint32(0); i < sz; i++ { + for range sz { var k int k, bytes, err = msgp.ReadIntBytes(bytes) if err != nil { @@ -540,9 +551,6 @@ func (s IntSorted) Msgsize() int { if s == nil { return msgp.NilSize } - if len(s) == 0 { - return msgp.ArrayHeaderSize - } size := msgp.ArrayHeaderSize size += len(s) * msgp.IntSize return size @@ -590,6 +598,7 @@ func (s Uint) MarshalMsg(bytes []byte) ([]byte, error) { if len(s) == 0 { return msgp.AppendArrayHeader(bytes, 0), nil } + bytes = ensure(bytes, s.Msgsize()) bytes = msgp.AppendArrayHeader(bytes, uint32(len(s))) for k := range s { bytes = msgp.AppendUint(bytes, uint(k)) @@ -625,7 +634,7 @@ func (s *Uint) DecodeMsg(reader *msgp.Reader) error { } else { clear(dst) } - for i := uint32(0); i < sz; i++ { + for range sz { var k uint k, err = reader.ReadUint() if err != nil { @@ -654,7 +663,7 @@ func (s *Uint) UnmarshalMsg(bytes []byte) ([]byte, error) { } else { clear(dst) } - for i := uint32(0); i < sz; i++ { + for range sz { var k uint k, bytes, err = msgp.ReadUintBytes(bytes) if err != nil { @@ -671,9 +680,6 @@ func (s Uint) Msgsize() int { if s == nil { return msgp.NilSize } - if len(s) == 0 { - return msgp.ArrayHeaderSize - } size := msgp.ArrayHeaderSize size += len(s) * msgp.UintSize return size @@ -708,7 +714,12 @@ func (s UintSorted) EncodeMsg(writer *msgp.Writer) error { for k := range s { keys = append(keys, k) } - sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] }) + slices.SortFunc(keys, func(a, b uint) int { + if a < b { + return -1 + } + return 1 + }) for _, k := range keys { err = writer.WriteUint(k) @@ -727,12 +738,18 @@ func (s UintSorted) MarshalMsg(bytes []byte) ([]byte, error) { if len(s) == 0 { return msgp.AppendArrayHeader(bytes, 0), nil } + bytes = ensure(bytes, s.Msgsize()) bytes = msgp.AppendArrayHeader(bytes, uint32(len(s))) keys := make([]uint, 0, len(s)) for k := range s { keys = append(keys, k) } - sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] }) + slices.SortFunc(keys, func(a, b uint) int { + if a < b { + return -1 + } + return 1 + }) for _, k := range keys { bytes = msgp.AppendUint(bytes, k) } @@ -744,12 +761,17 @@ func (s UintSorted) AsSlice() []uint { if s == nil { return nil } - dst := make([]uint, 0, len(s)) + keys := make([]uint, 0, len(s)) for k := range s { - dst = append(dst, k) + keys = append(keys, k) } - sort.Slice(dst, func(i, j int) bool { return dst[i] < dst[j] }) - return dst + slices.SortFunc(keys, func(a, b uint) int { + if a < b { + return -1 + } + return 1 + }) + return keys } // DecodeMsg decodes the message from the reader. @@ -768,7 +790,7 @@ func (s *UintSorted) DecodeMsg(reader *msgp.Reader) error { } else { clear(dst) } - for i := uint32(0); i < sz; i++ { + for range sz { var k uint k, err = reader.ReadUint() if err != nil { @@ -797,7 +819,7 @@ func (s *UintSorted) UnmarshalMsg(bytes []byte) ([]byte, error) { } else { clear(dst) } - for i := uint32(0); i < sz; i++ { + for range sz { var k uint k, bytes, err = msgp.ReadUintBytes(bytes) if err != nil { @@ -814,9 +836,6 @@ func (s UintSorted) Msgsize() int { if s == nil { return msgp.NilSize } - if len(s) == 0 { - return msgp.ArrayHeaderSize - } size := msgp.ArrayHeaderSize size += len(s) * msgp.UintSize return size @@ -864,6 +883,7 @@ func (s Byte) MarshalMsg(bytes []byte) ([]byte, error) { if len(s) == 0 { return msgp.AppendArrayHeader(bytes, 0), nil } + bytes = ensure(bytes, s.Msgsize()) bytes = msgp.AppendArrayHeader(bytes, uint32(len(s))) for k := range s { bytes = msgp.AppendByte(bytes, byte(k)) @@ -899,7 +919,7 @@ func (s *Byte) DecodeMsg(reader *msgp.Reader) error { } else { clear(dst) } - for i := uint32(0); i < sz; i++ { + for range sz { var k byte k, err = reader.ReadByte() if err != nil { @@ -928,7 +948,7 @@ func (s *Byte) UnmarshalMsg(bytes []byte) ([]byte, error) { } else { clear(dst) } - for i := uint32(0); i < sz; i++ { + for range sz { var k byte k, bytes, err = msgp.ReadByteBytes(bytes) if err != nil { @@ -945,9 +965,6 @@ func (s Byte) Msgsize() int { if s == nil { return msgp.NilSize } - if len(s) == 0 { - return msgp.ArrayHeaderSize - } size := msgp.ArrayHeaderSize size += len(s) * msgp.ByteSize return size @@ -982,7 +999,12 @@ func (s ByteSorted) EncodeMsg(writer *msgp.Writer) error { for k := range s { keys = append(keys, k) } - sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] }) + slices.SortFunc(keys, func(a, b byte) int { + if a < b { + return -1 + } + return 1 + }) for _, k := range keys { err = writer.WriteByte(k) @@ -1001,12 +1023,18 @@ func (s ByteSorted) MarshalMsg(bytes []byte) ([]byte, error) { if len(s) == 0 { return msgp.AppendArrayHeader(bytes, 0), nil } + bytes = ensure(bytes, s.Msgsize()) bytes = msgp.AppendArrayHeader(bytes, uint32(len(s))) keys := make([]byte, 0, len(s)) for k := range s { keys = append(keys, k) } - sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] }) + slices.SortFunc(keys, func(a, b byte) int { + if a < b { + return -1 + } + return 1 + }) for _, k := range keys { bytes = msgp.AppendByte(bytes, k) } @@ -1018,12 +1046,17 @@ func (s ByteSorted) AsSlice() []byte { if s == nil { return nil } - dst := make([]byte, 0, len(s)) + keys := make([]byte, 0, len(s)) for k := range s { - dst = append(dst, k) + keys = append(keys, k) } - sort.Slice(dst, func(i, j int) bool { return dst[i] < dst[j] }) - return dst + slices.SortFunc(keys, func(a, b byte) int { + if a < b { + return -1 + } + return 1 + }) + return keys } // DecodeMsg decodes the message from the reader. @@ -1042,7 +1075,7 @@ func (s *ByteSorted) DecodeMsg(reader *msgp.Reader) error { } else { clear(dst) } - for i := uint32(0); i < sz; i++ { + for range sz { var k byte k, err = reader.ReadByte() if err != nil { @@ -1071,7 +1104,7 @@ func (s *ByteSorted) UnmarshalMsg(bytes []byte) ([]byte, error) { } else { clear(dst) } - for i := uint32(0); i < sz; i++ { + for range sz { var k byte k, bytes, err = msgp.ReadByteBytes(bytes) if err != nil { @@ -1088,9 +1121,6 @@ func (s ByteSorted) Msgsize() int { if s == nil { return msgp.NilSize } - if len(s) == 0 { - return msgp.ArrayHeaderSize - } size := msgp.ArrayHeaderSize size += len(s) * msgp.ByteSize return size @@ -1138,6 +1168,7 @@ func (s Int8) MarshalMsg(bytes []byte) ([]byte, error) { if len(s) == 0 { return msgp.AppendArrayHeader(bytes, 0), nil } + bytes = ensure(bytes, s.Msgsize()) bytes = msgp.AppendArrayHeader(bytes, uint32(len(s))) for k := range s { bytes = msgp.AppendInt8(bytes, int8(k)) @@ -1173,7 +1204,7 @@ func (s *Int8) DecodeMsg(reader *msgp.Reader) error { } else { clear(dst) } - for i := uint32(0); i < sz; i++ { + for range sz { var k int8 k, err = reader.ReadInt8() if err != nil { @@ -1202,7 +1233,7 @@ func (s *Int8) UnmarshalMsg(bytes []byte) ([]byte, error) { } else { clear(dst) } - for i := uint32(0); i < sz; i++ { + for range sz { var k int8 k, bytes, err = msgp.ReadInt8Bytes(bytes) if err != nil { @@ -1219,9 +1250,6 @@ func (s Int8) Msgsize() int { if s == nil { return msgp.NilSize } - if len(s) == 0 { - return msgp.ArrayHeaderSize - } size := msgp.ArrayHeaderSize size += len(s) * msgp.Int8Size return size @@ -1256,7 +1284,12 @@ func (s Int8Sorted) EncodeMsg(writer *msgp.Writer) error { for k := range s { keys = append(keys, k) } - sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] }) + slices.SortFunc(keys, func(a, b int8) int { + if a < b { + return -1 + } + return 1 + }) for _, k := range keys { err = writer.WriteInt8(k) @@ -1275,12 +1308,18 @@ func (s Int8Sorted) MarshalMsg(bytes []byte) ([]byte, error) { if len(s) == 0 { return msgp.AppendArrayHeader(bytes, 0), nil } + bytes = ensure(bytes, s.Msgsize()) bytes = msgp.AppendArrayHeader(bytes, uint32(len(s))) keys := make([]int8, 0, len(s)) for k := range s { keys = append(keys, k) } - sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] }) + slices.SortFunc(keys, func(a, b int8) int { + if a < b { + return -1 + } + return 1 + }) for _, k := range keys { bytes = msgp.AppendInt8(bytes, k) } @@ -1292,12 +1331,17 @@ func (s Int8Sorted) AsSlice() []int8 { if s == nil { return nil } - dst := make([]int8, 0, len(s)) + keys := make([]int8, 0, len(s)) for k := range s { - dst = append(dst, k) + keys = append(keys, k) } - sort.Slice(dst, func(i, j int) bool { return dst[i] < dst[j] }) - return dst + slices.SortFunc(keys, func(a, b int8) int { + if a < b { + return -1 + } + return 1 + }) + return keys } // DecodeMsg decodes the message from the reader. @@ -1316,7 +1360,7 @@ func (s *Int8Sorted) DecodeMsg(reader *msgp.Reader) error { } else { clear(dst) } - for i := uint32(0); i < sz; i++ { + for range sz { var k int8 k, err = reader.ReadInt8() if err != nil { @@ -1345,7 +1389,7 @@ func (s *Int8Sorted) UnmarshalMsg(bytes []byte) ([]byte, error) { } else { clear(dst) } - for i := uint32(0); i < sz; i++ { + for range sz { var k int8 k, bytes, err = msgp.ReadInt8Bytes(bytes) if err != nil { @@ -1362,9 +1406,6 @@ func (s Int8Sorted) Msgsize() int { if s == nil { return msgp.NilSize } - if len(s) == 0 { - return msgp.ArrayHeaderSize - } size := msgp.ArrayHeaderSize size += len(s) * msgp.Int8Size return size @@ -1412,6 +1453,7 @@ func (s Uint8) MarshalMsg(bytes []byte) ([]byte, error) { if len(s) == 0 { return msgp.AppendArrayHeader(bytes, 0), nil } + bytes = ensure(bytes, s.Msgsize()) bytes = msgp.AppendArrayHeader(bytes, uint32(len(s))) for k := range s { bytes = msgp.AppendUint8(bytes, uint8(k)) @@ -1447,7 +1489,7 @@ func (s *Uint8) DecodeMsg(reader *msgp.Reader) error { } else { clear(dst) } - for i := uint32(0); i < sz; i++ { + for range sz { var k uint8 k, err = reader.ReadUint8() if err != nil { @@ -1476,7 +1518,7 @@ func (s *Uint8) UnmarshalMsg(bytes []byte) ([]byte, error) { } else { clear(dst) } - for i := uint32(0); i < sz; i++ { + for range sz { var k uint8 k, bytes, err = msgp.ReadUint8Bytes(bytes) if err != nil { @@ -1493,9 +1535,6 @@ func (s Uint8) Msgsize() int { if s == nil { return msgp.NilSize } - if len(s) == 0 { - return msgp.ArrayHeaderSize - } size := msgp.ArrayHeaderSize size += len(s) * msgp.Uint8Size return size @@ -1530,7 +1569,12 @@ func (s Uint8Sorted) EncodeMsg(writer *msgp.Writer) error { for k := range s { keys = append(keys, k) } - sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] }) + slices.SortFunc(keys, func(a, b uint8) int { + if a < b { + return -1 + } + return 1 + }) for _, k := range keys { err = writer.WriteUint8(k) @@ -1549,12 +1593,18 @@ func (s Uint8Sorted) MarshalMsg(bytes []byte) ([]byte, error) { if len(s) == 0 { return msgp.AppendArrayHeader(bytes, 0), nil } + bytes = ensure(bytes, s.Msgsize()) bytes = msgp.AppendArrayHeader(bytes, uint32(len(s))) keys := make([]uint8, 0, len(s)) for k := range s { keys = append(keys, k) } - sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] }) + slices.SortFunc(keys, func(a, b uint8) int { + if a < b { + return -1 + } + return 1 + }) for _, k := range keys { bytes = msgp.AppendUint8(bytes, k) } @@ -1566,12 +1616,17 @@ func (s Uint8Sorted) AsSlice() []uint8 { if s == nil { return nil } - dst := make([]uint8, 0, len(s)) + keys := make([]uint8, 0, len(s)) for k := range s { - dst = append(dst, k) + keys = append(keys, k) } - sort.Slice(dst, func(i, j int) bool { return dst[i] < dst[j] }) - return dst + slices.SortFunc(keys, func(a, b uint8) int { + if a < b { + return -1 + } + return 1 + }) + return keys } // DecodeMsg decodes the message from the reader. @@ -1590,7 +1645,7 @@ func (s *Uint8Sorted) DecodeMsg(reader *msgp.Reader) error { } else { clear(dst) } - for i := uint32(0); i < sz; i++ { + for range sz { var k uint8 k, err = reader.ReadUint8() if err != nil { @@ -1619,7 +1674,7 @@ func (s *Uint8Sorted) UnmarshalMsg(bytes []byte) ([]byte, error) { } else { clear(dst) } - for i := uint32(0); i < sz; i++ { + for range sz { var k uint8 k, bytes, err = msgp.ReadUint8Bytes(bytes) if err != nil { @@ -1636,9 +1691,6 @@ func (s Uint8Sorted) Msgsize() int { if s == nil { return msgp.NilSize } - if len(s) == 0 { - return msgp.ArrayHeaderSize - } size := msgp.ArrayHeaderSize size += len(s) * msgp.Uint8Size return size @@ -1686,6 +1738,7 @@ func (s Int16) MarshalMsg(bytes []byte) ([]byte, error) { if len(s) == 0 { return msgp.AppendArrayHeader(bytes, 0), nil } + bytes = ensure(bytes, s.Msgsize()) bytes = msgp.AppendArrayHeader(bytes, uint32(len(s))) for k := range s { bytes = msgp.AppendInt16(bytes, int16(k)) @@ -1721,7 +1774,7 @@ func (s *Int16) DecodeMsg(reader *msgp.Reader) error { } else { clear(dst) } - for i := uint32(0); i < sz; i++ { + for range sz { var k int16 k, err = reader.ReadInt16() if err != nil { @@ -1750,7 +1803,7 @@ func (s *Int16) UnmarshalMsg(bytes []byte) ([]byte, error) { } else { clear(dst) } - for i := uint32(0); i < sz; i++ { + for range sz { var k int16 k, bytes, err = msgp.ReadInt16Bytes(bytes) if err != nil { @@ -1767,9 +1820,6 @@ func (s Int16) Msgsize() int { if s == nil { return msgp.NilSize } - if len(s) == 0 { - return msgp.ArrayHeaderSize - } size := msgp.ArrayHeaderSize size += len(s) * msgp.Int16Size return size @@ -1804,7 +1854,12 @@ func (s Int16Sorted) EncodeMsg(writer *msgp.Writer) error { for k := range s { keys = append(keys, k) } - sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] }) + slices.SortFunc(keys, func(a, b int16) int { + if a < b { + return -1 + } + return 1 + }) for _, k := range keys { err = writer.WriteInt16(k) @@ -1823,12 +1878,18 @@ func (s Int16Sorted) MarshalMsg(bytes []byte) ([]byte, error) { if len(s) == 0 { return msgp.AppendArrayHeader(bytes, 0), nil } + bytes = ensure(bytes, s.Msgsize()) bytes = msgp.AppendArrayHeader(bytes, uint32(len(s))) keys := make([]int16, 0, len(s)) for k := range s { keys = append(keys, k) } - sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] }) + slices.SortFunc(keys, func(a, b int16) int { + if a < b { + return -1 + } + return 1 + }) for _, k := range keys { bytes = msgp.AppendInt16(bytes, k) } @@ -1840,12 +1901,17 @@ func (s Int16Sorted) AsSlice() []int16 { if s == nil { return nil } - dst := make([]int16, 0, len(s)) + keys := make([]int16, 0, len(s)) for k := range s { - dst = append(dst, k) + keys = append(keys, k) } - sort.Slice(dst, func(i, j int) bool { return dst[i] < dst[j] }) - return dst + slices.SortFunc(keys, func(a, b int16) int { + if a < b { + return -1 + } + return 1 + }) + return keys } // DecodeMsg decodes the message from the reader. @@ -1864,7 +1930,7 @@ func (s *Int16Sorted) DecodeMsg(reader *msgp.Reader) error { } else { clear(dst) } - for i := uint32(0); i < sz; i++ { + for range sz { var k int16 k, err = reader.ReadInt16() if err != nil { @@ -1893,7 +1959,7 @@ func (s *Int16Sorted) UnmarshalMsg(bytes []byte) ([]byte, error) { } else { clear(dst) } - for i := uint32(0); i < sz; i++ { + for range sz { var k int16 k, bytes, err = msgp.ReadInt16Bytes(bytes) if err != nil { @@ -1910,9 +1976,6 @@ func (s Int16Sorted) Msgsize() int { if s == nil { return msgp.NilSize } - if len(s) == 0 { - return msgp.ArrayHeaderSize - } size := msgp.ArrayHeaderSize size += len(s) * msgp.Int16Size return size @@ -1960,6 +2023,7 @@ func (s Uint16) MarshalMsg(bytes []byte) ([]byte, error) { if len(s) == 0 { return msgp.AppendArrayHeader(bytes, 0), nil } + bytes = ensure(bytes, s.Msgsize()) bytes = msgp.AppendArrayHeader(bytes, uint32(len(s))) for k := range s { bytes = msgp.AppendUint16(bytes, uint16(k)) @@ -1995,7 +2059,7 @@ func (s *Uint16) DecodeMsg(reader *msgp.Reader) error { } else { clear(dst) } - for i := uint32(0); i < sz; i++ { + for range sz { var k uint16 k, err = reader.ReadUint16() if err != nil { @@ -2024,7 +2088,7 @@ func (s *Uint16) UnmarshalMsg(bytes []byte) ([]byte, error) { } else { clear(dst) } - for i := uint32(0); i < sz; i++ { + for range sz { var k uint16 k, bytes, err = msgp.ReadUint16Bytes(bytes) if err != nil { @@ -2041,9 +2105,6 @@ func (s Uint16) Msgsize() int { if s == nil { return msgp.NilSize } - if len(s) == 0 { - return msgp.ArrayHeaderSize - } size := msgp.ArrayHeaderSize size += len(s) * msgp.Uint16Size return size @@ -2078,7 +2139,12 @@ func (s Uint16Sorted) EncodeMsg(writer *msgp.Writer) error { for k := range s { keys = append(keys, k) } - sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] }) + slices.SortFunc(keys, func(a, b uint16) int { + if a < b { + return -1 + } + return 1 + }) for _, k := range keys { err = writer.WriteUint16(k) @@ -2097,12 +2163,18 @@ func (s Uint16Sorted) MarshalMsg(bytes []byte) ([]byte, error) { if len(s) == 0 { return msgp.AppendArrayHeader(bytes, 0), nil } + bytes = ensure(bytes, s.Msgsize()) bytes = msgp.AppendArrayHeader(bytes, uint32(len(s))) keys := make([]uint16, 0, len(s)) for k := range s { keys = append(keys, k) } - sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] }) + slices.SortFunc(keys, func(a, b uint16) int { + if a < b { + return -1 + } + return 1 + }) for _, k := range keys { bytes = msgp.AppendUint16(bytes, k) } @@ -2114,12 +2186,17 @@ func (s Uint16Sorted) AsSlice() []uint16 { if s == nil { return nil } - dst := make([]uint16, 0, len(s)) + keys := make([]uint16, 0, len(s)) for k := range s { - dst = append(dst, k) + keys = append(keys, k) } - sort.Slice(dst, func(i, j int) bool { return dst[i] < dst[j] }) - return dst + slices.SortFunc(keys, func(a, b uint16) int { + if a < b { + return -1 + } + return 1 + }) + return keys } // DecodeMsg decodes the message from the reader. @@ -2138,7 +2215,7 @@ func (s *Uint16Sorted) DecodeMsg(reader *msgp.Reader) error { } else { clear(dst) } - for i := uint32(0); i < sz; i++ { + for range sz { var k uint16 k, err = reader.ReadUint16() if err != nil { @@ -2167,7 +2244,7 @@ func (s *Uint16Sorted) UnmarshalMsg(bytes []byte) ([]byte, error) { } else { clear(dst) } - for i := uint32(0); i < sz; i++ { + for range sz { var k uint16 k, bytes, err = msgp.ReadUint16Bytes(bytes) if err != nil { @@ -2184,9 +2261,6 @@ func (s Uint16Sorted) Msgsize() int { if s == nil { return msgp.NilSize } - if len(s) == 0 { - return msgp.ArrayHeaderSize - } size := msgp.ArrayHeaderSize size += len(s) * msgp.Uint16Size return size @@ -2234,6 +2308,7 @@ func (s Int32) MarshalMsg(bytes []byte) ([]byte, error) { if len(s) == 0 { return msgp.AppendArrayHeader(bytes, 0), nil } + bytes = ensure(bytes, s.Msgsize()) bytes = msgp.AppendArrayHeader(bytes, uint32(len(s))) for k := range s { bytes = msgp.AppendInt32(bytes, int32(k)) @@ -2269,7 +2344,7 @@ func (s *Int32) DecodeMsg(reader *msgp.Reader) error { } else { clear(dst) } - for i := uint32(0); i < sz; i++ { + for range sz { var k int32 k, err = reader.ReadInt32() if err != nil { @@ -2298,7 +2373,7 @@ func (s *Int32) UnmarshalMsg(bytes []byte) ([]byte, error) { } else { clear(dst) } - for i := uint32(0); i < sz; i++ { + for range sz { var k int32 k, bytes, err = msgp.ReadInt32Bytes(bytes) if err != nil { @@ -2315,9 +2390,6 @@ func (s Int32) Msgsize() int { if s == nil { return msgp.NilSize } - if len(s) == 0 { - return msgp.ArrayHeaderSize - } size := msgp.ArrayHeaderSize size += len(s) * msgp.Int32Size return size @@ -2352,7 +2424,12 @@ func (s Int32Sorted) EncodeMsg(writer *msgp.Writer) error { for k := range s { keys = append(keys, k) } - sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] }) + slices.SortFunc(keys, func(a, b int32) int { + if a < b { + return -1 + } + return 1 + }) for _, k := range keys { err = writer.WriteInt32(k) @@ -2371,12 +2448,18 @@ func (s Int32Sorted) MarshalMsg(bytes []byte) ([]byte, error) { if len(s) == 0 { return msgp.AppendArrayHeader(bytes, 0), nil } + bytes = ensure(bytes, s.Msgsize()) bytes = msgp.AppendArrayHeader(bytes, uint32(len(s))) keys := make([]int32, 0, len(s)) for k := range s { keys = append(keys, k) } - sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] }) + slices.SortFunc(keys, func(a, b int32) int { + if a < b { + return -1 + } + return 1 + }) for _, k := range keys { bytes = msgp.AppendInt32(bytes, k) } @@ -2388,12 +2471,17 @@ func (s Int32Sorted) AsSlice() []int32 { if s == nil { return nil } - dst := make([]int32, 0, len(s)) + keys := make([]int32, 0, len(s)) for k := range s { - dst = append(dst, k) + keys = append(keys, k) } - sort.Slice(dst, func(i, j int) bool { return dst[i] < dst[j] }) - return dst + slices.SortFunc(keys, func(a, b int32) int { + if a < b { + return -1 + } + return 1 + }) + return keys } // DecodeMsg decodes the message from the reader. @@ -2412,7 +2500,7 @@ func (s *Int32Sorted) DecodeMsg(reader *msgp.Reader) error { } else { clear(dst) } - for i := uint32(0); i < sz; i++ { + for range sz { var k int32 k, err = reader.ReadInt32() if err != nil { @@ -2441,7 +2529,7 @@ func (s *Int32Sorted) UnmarshalMsg(bytes []byte) ([]byte, error) { } else { clear(dst) } - for i := uint32(0); i < sz; i++ { + for range sz { var k int32 k, bytes, err = msgp.ReadInt32Bytes(bytes) if err != nil { @@ -2458,9 +2546,6 @@ func (s Int32Sorted) Msgsize() int { if s == nil { return msgp.NilSize } - if len(s) == 0 { - return msgp.ArrayHeaderSize - } size := msgp.ArrayHeaderSize size += len(s) * msgp.Int32Size return size @@ -2508,6 +2593,7 @@ func (s Uint32) MarshalMsg(bytes []byte) ([]byte, error) { if len(s) == 0 { return msgp.AppendArrayHeader(bytes, 0), nil } + bytes = ensure(bytes, s.Msgsize()) bytes = msgp.AppendArrayHeader(bytes, uint32(len(s))) for k := range s { bytes = msgp.AppendUint32(bytes, uint32(k)) @@ -2543,7 +2629,7 @@ func (s *Uint32) DecodeMsg(reader *msgp.Reader) error { } else { clear(dst) } - for i := uint32(0); i < sz; i++ { + for range sz { var k uint32 k, err = reader.ReadUint32() if err != nil { @@ -2572,7 +2658,7 @@ func (s *Uint32) UnmarshalMsg(bytes []byte) ([]byte, error) { } else { clear(dst) } - for i := uint32(0); i < sz; i++ { + for range sz { var k uint32 k, bytes, err = msgp.ReadUint32Bytes(bytes) if err != nil { @@ -2589,9 +2675,6 @@ func (s Uint32) Msgsize() int { if s == nil { return msgp.NilSize } - if len(s) == 0 { - return msgp.ArrayHeaderSize - } size := msgp.ArrayHeaderSize size += len(s) * msgp.Uint32Size return size @@ -2626,7 +2709,12 @@ func (s Uint32Sorted) EncodeMsg(writer *msgp.Writer) error { for k := range s { keys = append(keys, k) } - sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] }) + slices.SortFunc(keys, func(a, b uint32) int { + if a < b { + return -1 + } + return 1 + }) for _, k := range keys { err = writer.WriteUint32(k) @@ -2645,12 +2733,18 @@ func (s Uint32Sorted) MarshalMsg(bytes []byte) ([]byte, error) { if len(s) == 0 { return msgp.AppendArrayHeader(bytes, 0), nil } + bytes = ensure(bytes, s.Msgsize()) bytes = msgp.AppendArrayHeader(bytes, uint32(len(s))) keys := make([]uint32, 0, len(s)) for k := range s { keys = append(keys, k) } - sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] }) + slices.SortFunc(keys, func(a, b uint32) int { + if a < b { + return -1 + } + return 1 + }) for _, k := range keys { bytes = msgp.AppendUint32(bytes, k) } @@ -2662,12 +2756,17 @@ func (s Uint32Sorted) AsSlice() []uint32 { if s == nil { return nil } - dst := make([]uint32, 0, len(s)) + keys := make([]uint32, 0, len(s)) for k := range s { - dst = append(dst, k) + keys = append(keys, k) } - sort.Slice(dst, func(i, j int) bool { return dst[i] < dst[j] }) - return dst + slices.SortFunc(keys, func(a, b uint32) int { + if a < b { + return -1 + } + return 1 + }) + return keys } // DecodeMsg decodes the message from the reader. @@ -2686,7 +2785,7 @@ func (s *Uint32Sorted) DecodeMsg(reader *msgp.Reader) error { } else { clear(dst) } - for i := uint32(0); i < sz; i++ { + for range sz { var k uint32 k, err = reader.ReadUint32() if err != nil { @@ -2715,7 +2814,7 @@ func (s *Uint32Sorted) UnmarshalMsg(bytes []byte) ([]byte, error) { } else { clear(dst) } - for i := uint32(0); i < sz; i++ { + for range sz { var k uint32 k, bytes, err = msgp.ReadUint32Bytes(bytes) if err != nil { @@ -2732,9 +2831,6 @@ func (s Uint32Sorted) Msgsize() int { if s == nil { return msgp.NilSize } - if len(s) == 0 { - return msgp.ArrayHeaderSize - } size := msgp.ArrayHeaderSize size += len(s) * msgp.Uint32Size return size @@ -2782,6 +2878,7 @@ func (s Int64) MarshalMsg(bytes []byte) ([]byte, error) { if len(s) == 0 { return msgp.AppendArrayHeader(bytes, 0), nil } + bytes = ensure(bytes, s.Msgsize()) bytes = msgp.AppendArrayHeader(bytes, uint32(len(s))) for k := range s { bytes = msgp.AppendInt64(bytes, int64(k)) @@ -2817,7 +2914,7 @@ func (s *Int64) DecodeMsg(reader *msgp.Reader) error { } else { clear(dst) } - for i := uint32(0); i < sz; i++ { + for range sz { var k int64 k, err = reader.ReadInt64() if err != nil { @@ -2846,7 +2943,7 @@ func (s *Int64) UnmarshalMsg(bytes []byte) ([]byte, error) { } else { clear(dst) } - for i := uint32(0); i < sz; i++ { + for range sz { var k int64 k, bytes, err = msgp.ReadInt64Bytes(bytes) if err != nil { @@ -2863,9 +2960,6 @@ func (s Int64) Msgsize() int { if s == nil { return msgp.NilSize } - if len(s) == 0 { - return msgp.ArrayHeaderSize - } size := msgp.ArrayHeaderSize size += len(s) * msgp.Int64Size return size @@ -2900,7 +2994,12 @@ func (s Int64Sorted) EncodeMsg(writer *msgp.Writer) error { for k := range s { keys = append(keys, k) } - sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] }) + slices.SortFunc(keys, func(a, b int64) int { + if a < b { + return -1 + } + return 1 + }) for _, k := range keys { err = writer.WriteInt64(k) @@ -2919,12 +3018,18 @@ func (s Int64Sorted) MarshalMsg(bytes []byte) ([]byte, error) { if len(s) == 0 { return msgp.AppendArrayHeader(bytes, 0), nil } + bytes = ensure(bytes, s.Msgsize()) bytes = msgp.AppendArrayHeader(bytes, uint32(len(s))) keys := make([]int64, 0, len(s)) for k := range s { keys = append(keys, k) } - sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] }) + slices.SortFunc(keys, func(a, b int64) int { + if a < b { + return -1 + } + return 1 + }) for _, k := range keys { bytes = msgp.AppendInt64(bytes, k) } @@ -2936,12 +3041,17 @@ func (s Int64Sorted) AsSlice() []int64 { if s == nil { return nil } - dst := make([]int64, 0, len(s)) + keys := make([]int64, 0, len(s)) for k := range s { - dst = append(dst, k) + keys = append(keys, k) } - sort.Slice(dst, func(i, j int) bool { return dst[i] < dst[j] }) - return dst + slices.SortFunc(keys, func(a, b int64) int { + if a < b { + return -1 + } + return 1 + }) + return keys } // DecodeMsg decodes the message from the reader. @@ -2960,7 +3070,7 @@ func (s *Int64Sorted) DecodeMsg(reader *msgp.Reader) error { } else { clear(dst) } - for i := uint32(0); i < sz; i++ { + for range sz { var k int64 k, err = reader.ReadInt64() if err != nil { @@ -2989,7 +3099,7 @@ func (s *Int64Sorted) UnmarshalMsg(bytes []byte) ([]byte, error) { } else { clear(dst) } - for i := uint32(0); i < sz; i++ { + for range sz { var k int64 k, bytes, err = msgp.ReadInt64Bytes(bytes) if err != nil { @@ -3006,9 +3116,6 @@ func (s Int64Sorted) Msgsize() int { if s == nil { return msgp.NilSize } - if len(s) == 0 { - return msgp.ArrayHeaderSize - } size := msgp.ArrayHeaderSize size += len(s) * msgp.Int64Size return size @@ -3056,6 +3163,7 @@ func (s Uint64) MarshalMsg(bytes []byte) ([]byte, error) { if len(s) == 0 { return msgp.AppendArrayHeader(bytes, 0), nil } + bytes = ensure(bytes, s.Msgsize()) bytes = msgp.AppendArrayHeader(bytes, uint32(len(s))) for k := range s { bytes = msgp.AppendUint64(bytes, uint64(k)) @@ -3091,7 +3199,7 @@ func (s *Uint64) DecodeMsg(reader *msgp.Reader) error { } else { clear(dst) } - for i := uint32(0); i < sz; i++ { + for range sz { var k uint64 k, err = reader.ReadUint64() if err != nil { @@ -3120,7 +3228,7 @@ func (s *Uint64) UnmarshalMsg(bytes []byte) ([]byte, error) { } else { clear(dst) } - for i := uint32(0); i < sz; i++ { + for range sz { var k uint64 k, bytes, err = msgp.ReadUint64Bytes(bytes) if err != nil { @@ -3137,9 +3245,6 @@ func (s Uint64) Msgsize() int { if s == nil { return msgp.NilSize } - if len(s) == 0 { - return msgp.ArrayHeaderSize - } size := msgp.ArrayHeaderSize size += len(s) * msgp.Uint64Size return size @@ -3174,7 +3279,12 @@ func (s Uint64Sorted) EncodeMsg(writer *msgp.Writer) error { for k := range s { keys = append(keys, k) } - sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] }) + slices.SortFunc(keys, func(a, b uint64) int { + if a < b { + return -1 + } + return 1 + }) for _, k := range keys { err = writer.WriteUint64(k) @@ -3193,12 +3303,18 @@ func (s Uint64Sorted) MarshalMsg(bytes []byte) ([]byte, error) { if len(s) == 0 { return msgp.AppendArrayHeader(bytes, 0), nil } + bytes = ensure(bytes, s.Msgsize()) bytes = msgp.AppendArrayHeader(bytes, uint32(len(s))) keys := make([]uint64, 0, len(s)) for k := range s { keys = append(keys, k) } - sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] }) + slices.SortFunc(keys, func(a, b uint64) int { + if a < b { + return -1 + } + return 1 + }) for _, k := range keys { bytes = msgp.AppendUint64(bytes, k) } @@ -3210,12 +3326,17 @@ func (s Uint64Sorted) AsSlice() []uint64 { if s == nil { return nil } - dst := make([]uint64, 0, len(s)) + keys := make([]uint64, 0, len(s)) for k := range s { - dst = append(dst, k) + keys = append(keys, k) } - sort.Slice(dst, func(i, j int) bool { return dst[i] < dst[j] }) - return dst + slices.SortFunc(keys, func(a, b uint64) int { + if a < b { + return -1 + } + return 1 + }) + return keys } // DecodeMsg decodes the message from the reader. @@ -3234,7 +3355,7 @@ func (s *Uint64Sorted) DecodeMsg(reader *msgp.Reader) error { } else { clear(dst) } - for i := uint32(0); i < sz; i++ { + for range sz { var k uint64 k, err = reader.ReadUint64() if err != nil { @@ -3263,7 +3384,7 @@ func (s *Uint64Sorted) UnmarshalMsg(bytes []byte) ([]byte, error) { } else { clear(dst) } - for i := uint32(0); i < sz; i++ { + for range sz { var k uint64 k, bytes, err = msgp.ReadUint64Bytes(bytes) if err != nil { @@ -3280,9 +3401,6 @@ func (s Uint64Sorted) Msgsize() int { if s == nil { return msgp.NilSize } - if len(s) == 0 { - return msgp.ArrayHeaderSize - } size := msgp.ArrayHeaderSize size += len(s) * msgp.Uint64Size return size @@ -3330,6 +3448,7 @@ func (s Float64) MarshalMsg(bytes []byte) ([]byte, error) { if len(s) == 0 { return msgp.AppendArrayHeader(bytes, 0), nil } + bytes = ensure(bytes, s.Msgsize()) bytes = msgp.AppendArrayHeader(bytes, uint32(len(s))) for k := range s { bytes = msgp.AppendFloat(bytes, float64(k)) @@ -3365,7 +3484,7 @@ func (s *Float64) DecodeMsg(reader *msgp.Reader) error { } else { clear(dst) } - for i := uint32(0); i < sz; i++ { + for range sz { var k float64 k, err = reader.ReadFloat64() if err != nil { @@ -3394,7 +3513,7 @@ func (s *Float64) UnmarshalMsg(bytes []byte) ([]byte, error) { } else { clear(dst) } - for i := uint32(0); i < sz; i++ { + for range sz { var k float64 k, bytes, err = msgp.ReadFloat64Bytes(bytes) if err != nil { @@ -3411,9 +3530,6 @@ func (s Float64) Msgsize() int { if s == nil { return msgp.NilSize } - if len(s) == 0 { - return msgp.ArrayHeaderSize - } size := msgp.ArrayHeaderSize size += len(s) * msgp.Float64Size return size @@ -3448,7 +3564,12 @@ func (s Float64Sorted) EncodeMsg(writer *msgp.Writer) error { for k := range s { keys = append(keys, k) } - sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] }) + slices.SortFunc(keys, func(a, b float64) int { + if a < b { + return -1 + } + return 1 + }) for _, k := range keys { err = writer.WriteFloat(k) @@ -3467,12 +3588,18 @@ func (s Float64Sorted) MarshalMsg(bytes []byte) ([]byte, error) { if len(s) == 0 { return msgp.AppendArrayHeader(bytes, 0), nil } + bytes = ensure(bytes, s.Msgsize()) bytes = msgp.AppendArrayHeader(bytes, uint32(len(s))) keys := make([]float64, 0, len(s)) for k := range s { keys = append(keys, k) } - sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] }) + slices.SortFunc(keys, func(a, b float64) int { + if a < b { + return -1 + } + return 1 + }) for _, k := range keys { bytes = msgp.AppendFloat(bytes, k) } @@ -3484,12 +3611,17 @@ func (s Float64Sorted) AsSlice() []float64 { if s == nil { return nil } - dst := make([]float64, 0, len(s)) + keys := make([]float64, 0, len(s)) for k := range s { - dst = append(dst, k) + keys = append(keys, k) } - sort.Slice(dst, func(i, j int) bool { return dst[i] < dst[j] }) - return dst + slices.SortFunc(keys, func(a, b float64) int { + if a < b { + return -1 + } + return 1 + }) + return keys } // DecodeMsg decodes the message from the reader. @@ -3508,7 +3640,7 @@ func (s *Float64Sorted) DecodeMsg(reader *msgp.Reader) error { } else { clear(dst) } - for i := uint32(0); i < sz; i++ { + for range sz { var k float64 k, err = reader.ReadFloat64() if err != nil { @@ -3537,7 +3669,7 @@ func (s *Float64Sorted) UnmarshalMsg(bytes []byte) ([]byte, error) { } else { clear(dst) } - for i := uint32(0); i < sz; i++ { + for range sz { var k float64 k, bytes, err = msgp.ReadFloat64Bytes(bytes) if err != nil { @@ -3554,9 +3686,6 @@ func (s Float64Sorted) Msgsize() int { if s == nil { return msgp.NilSize } - if len(s) == 0 { - return msgp.ArrayHeaderSize - } size := msgp.ArrayHeaderSize size += len(s) * msgp.Float64Size return size @@ -3604,6 +3733,7 @@ func (s Float32) MarshalMsg(bytes []byte) ([]byte, error) { if len(s) == 0 { return msgp.AppendArrayHeader(bytes, 0), nil } + bytes = ensure(bytes, s.Msgsize()) bytes = msgp.AppendArrayHeader(bytes, uint32(len(s))) for k := range s { bytes = msgp.AppendFloat32(bytes, float32(k)) @@ -3639,7 +3769,7 @@ func (s *Float32) DecodeMsg(reader *msgp.Reader) error { } else { clear(dst) } - for i := uint32(0); i < sz; i++ { + for range sz { var k float32 k, err = reader.ReadFloat32() if err != nil { @@ -3668,7 +3798,7 @@ func (s *Float32) UnmarshalMsg(bytes []byte) ([]byte, error) { } else { clear(dst) } - for i := uint32(0); i < sz; i++ { + for range sz { var k float32 k, bytes, err = msgp.ReadFloat32Bytes(bytes) if err != nil { @@ -3685,9 +3815,6 @@ func (s Float32) Msgsize() int { if s == nil { return msgp.NilSize } - if len(s) == 0 { - return msgp.ArrayHeaderSize - } size := msgp.ArrayHeaderSize size += len(s) * msgp.Float32Size return size @@ -3722,7 +3849,12 @@ func (s Float32Sorted) EncodeMsg(writer *msgp.Writer) error { for k := range s { keys = append(keys, k) } - sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] }) + slices.SortFunc(keys, func(a, b float32) int { + if a < b { + return -1 + } + return 1 + }) for _, k := range keys { err = writer.WriteFloat32(k) @@ -3741,12 +3873,18 @@ func (s Float32Sorted) MarshalMsg(bytes []byte) ([]byte, error) { if len(s) == 0 { return msgp.AppendArrayHeader(bytes, 0), nil } + bytes = ensure(bytes, s.Msgsize()) bytes = msgp.AppendArrayHeader(bytes, uint32(len(s))) keys := make([]float32, 0, len(s)) for k := range s { keys = append(keys, k) } - sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] }) + slices.SortFunc(keys, func(a, b float32) int { + if a < b { + return -1 + } + return 1 + }) for _, k := range keys { bytes = msgp.AppendFloat32(bytes, k) } @@ -3758,12 +3896,17 @@ func (s Float32Sorted) AsSlice() []float32 { if s == nil { return nil } - dst := make([]float32, 0, len(s)) + keys := make([]float32, 0, len(s)) for k := range s { - dst = append(dst, k) + keys = append(keys, k) } - sort.Slice(dst, func(i, j int) bool { return dst[i] < dst[j] }) - return dst + slices.SortFunc(keys, func(a, b float32) int { + if a < b { + return -1 + } + return 1 + }) + return keys } // DecodeMsg decodes the message from the reader. @@ -3782,7 +3925,7 @@ func (s *Float32Sorted) DecodeMsg(reader *msgp.Reader) error { } else { clear(dst) } - for i := uint32(0); i < sz; i++ { + for range sz { var k float32 k, err = reader.ReadFloat32() if err != nil { @@ -3811,7 +3954,7 @@ func (s *Float32Sorted) UnmarshalMsg(bytes []byte) ([]byte, error) { } else { clear(dst) } - for i := uint32(0); i < sz; i++ { + for range sz { var k float32 k, bytes, err = msgp.ReadFloat32Bytes(bytes) if err != nil { @@ -3828,9 +3971,6 @@ func (s Float32Sorted) Msgsize() int { if s == nil { return msgp.NilSize } - if len(s) == 0 { - return msgp.ArrayHeaderSize - } size := msgp.ArrayHeaderSize size += len(s) * msgp.Float32Size return size diff --git a/msgp/setof/generated_test.go b/msgp/setof/generated_test.go new file mode 100644 index 00000000..64608127 --- /dev/null +++ b/msgp/setof/generated_test.go @@ -0,0 +1,9251 @@ +// Code generated by ./gen/main.go. DO NOT EDIT. + +package setof + +import ( + "bytes" + "fmt" + "testing" + + "github.com/tinylib/msgp/msgp" +) + +func TestString_RoundTrip(t *testing.T) { + set := make(String) + set["val0"] = struct{}{} + set["val1"] = struct{}{} + set["val2"] = struct{}{} + set["val3"] = struct{}{} + set["val4"] = struct{}{} + + // Test EncodeMsg/DecodeMsg + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + err := set.EncodeMsg(writer) + if err != nil { + t.Fatalf("EncodeMsg failed: %v", err) + } + writer.Flush() + + reader := msgp.NewReader(&buf) + var decoded String + err = decoded.DecodeMsg(reader) + if err != nil { + t.Fatalf("DecodeMsg failed: %v", err) + } + + if len(set) != len(decoded) { + t.Fatalf("length mismatch: expected %d, got %d", len(set), len(decoded)) + } + + for k := range set { + if _, ok := decoded[k]; !ok { + t.Fatalf("missing key: %v", k) + } + } + + // Test MarshalMsg/UnmarshalMsg + data, err := set.MarshalMsg(nil) + if err != nil { + t.Fatalf("MarshalMsg failed: %v", err) + } + + var unmarshaled String + _, err = unmarshaled.UnmarshalMsg(data) + if err != nil { + t.Fatalf("UnmarshalMsg failed: %v", err) + } + + if len(set) != len(unmarshaled) { + t.Fatalf("length mismatch: expected %d, got %d", len(set), len(unmarshaled)) + } + + for k := range set { + if _, ok := unmarshaled[k]; !ok { + t.Fatalf("missing key: %v", k) + } + } +} + +func TestString_AsSlice(t *testing.T) { + set := make(String) + set["val0"] = struct{}{} + set["val1"] = struct{}{} + set["val2"] = struct{}{} + set["val3"] = struct{}{} + set["val4"] = struct{}{} + + slice := set.AsSlice() + if len(slice) != len(set) { + t.Fatalf("length mismatch: expected %d, got %d", len(set), len(slice)) + } + + found := make(map[string]bool) + for _, v := range slice { + found[v] = true + } + + for k := range set { + if !found[k] { + t.Fatalf("missing key in slice: %v", k) + } + } +} + +func TestString_FromSlice(t *testing.T) { + slice := []string{"val0", "val1", "val2", "val3", "val4"} + set := StringFromSlice(slice) + + if len(set) != len(slice) { + t.Fatalf("length mismatch: expected %d, got %d", len(slice), len(set)) + } + + for _, v := range slice { + if _, ok := set[v]; !ok { + t.Fatalf("missing key: %v", v) + } + } +} + +func TestString_NilHandling(t *testing.T) { + var nilSet String + + // Test nil encoding + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + err := nilSet.EncodeMsg(writer) + if err != nil { + t.Fatalf("EncodeMsg failed for nil: %v", err) + } + writer.Flush() + + // Test nil decoding + reader := msgp.NewReader(&buf) + var decoded String + err = decoded.DecodeMsg(reader) + if err != nil { + t.Fatalf("DecodeMsg failed for nil: %v", err) + } + + if decoded != nil { + t.Fatal("expected nil, got non-nil") + } + + // Test nil marshaling + data, err := nilSet.MarshalMsg(nil) + if err != nil { + t.Fatalf("MarshalMsg failed for nil: %v", err) + } + + // Test nil unmarshaling + var unmarshaled String + _, err = unmarshaled.UnmarshalMsg(data) + if err != nil { + t.Fatalf("UnmarshalMsg failed for nil: %v", err) + } + + if unmarshaled != nil { + t.Fatal("expected nil, got non-nil") + } + + // Test AsSlice on nil + slice := nilSet.AsSlice() + if slice != nil { + t.Fatal("expected nil slice, got non-nil") + } + + // Test FromSlice with nil + fromNilSlice := StringFromSlice(nil) + if fromNilSlice != nil { + t.Fatal("expected nil from nil slice, got non-nil") + } +} + +func TestString_EmptySet(t *testing.T) { + set := make(String) + + // Test empty set encoding + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + err := set.EncodeMsg(writer) + if err != nil { + t.Fatalf("EncodeMsg failed for empty: %v", err) + } + writer.Flush() + + // Test empty set decoding + reader := msgp.NewReader(&buf) + var decoded String + err = decoded.DecodeMsg(reader) + if err != nil { + t.Fatalf("DecodeMsg failed for empty: %v", err) + } + + if len(decoded) != 0 { + t.Fatalf("expected empty set, got length %d", len(decoded)) + } + + // Test empty set marshaling + data, err := set.MarshalMsg(nil) + if err != nil { + t.Fatalf("MarshalMsg failed for empty: %v", err) + } + + // Test empty set unmarshaling + var unmarshaled String + _, err = unmarshaled.UnmarshalMsg(data) + if err != nil { + t.Fatalf("UnmarshalMsg failed for empty: %v", err) + } + + if len(unmarshaled) != 0 { + t.Fatalf("expected empty set, got length %d", len(unmarshaled)) + } +} + +func TestStringSorted_RoundTrip(t *testing.T) { + set := make(StringSorted) + set["val0"] = struct{}{} + set["val1"] = struct{}{} + set["val2"] = struct{}{} + set["val3"] = struct{}{} + set["val4"] = struct{}{} + + // Test EncodeMsg/DecodeMsg + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + err := set.EncodeMsg(writer) + if err != nil { + t.Fatalf("EncodeMsg failed: %v", err) + } + writer.Flush() + + reader := msgp.NewReader(&buf) + var decoded StringSorted + err = decoded.DecodeMsg(reader) + if err != nil { + t.Fatalf("DecodeMsg failed: %v", err) + } + + if len(set) != len(decoded) { + t.Fatalf("length mismatch: expected %d, got %d", len(set), len(decoded)) + } + + for k := range set { + if _, ok := decoded[k]; !ok { + t.Fatalf("missing key: %v", k) + } + } + + // Test MarshalMsg/UnmarshalMsg + data, err := set.MarshalMsg(nil) + if err != nil { + t.Fatalf("MarshalMsg failed: %v", err) + } + + var unmarshaled StringSorted + _, err = unmarshaled.UnmarshalMsg(data) + if err != nil { + t.Fatalf("UnmarshalMsg failed: %v", err) + } + + if len(set) != len(unmarshaled) { + t.Fatalf("length mismatch: expected %d, got %d", len(set), len(unmarshaled)) + } + + for k := range set { + if _, ok := unmarshaled[k]; !ok { + t.Fatalf("missing key: %v", k) + } + } +} + +func TestStringSorted_AsSlice(t *testing.T) { + set := make(StringSorted) + set["val0"] = struct{}{} + set["val1"] = struct{}{} + set["val2"] = struct{}{} + set["val3"] = struct{}{} + set["val4"] = struct{}{} + + slice := set.AsSlice() + if len(slice) != len(set) { + t.Fatalf("length mismatch: expected %d, got %d", len(set), len(slice)) + } + + found := make(map[string]bool) + for _, v := range slice { + found[v] = true + } + + for k := range set { + if !found[k] { + t.Fatalf("missing key in slice: %v", k) + } + } +} + +func TestStringSorted_FromSlice(t *testing.T) { + slice := []string{"val0", "val1", "val2", "val3", "val4"} + set := StringSortedFromSlice(slice) + + if len(set) != len(slice) { + t.Fatalf("length mismatch: expected %d, got %d", len(slice), len(set)) + } + + for _, v := range slice { + if _, ok := set[v]; !ok { + t.Fatalf("missing key: %v", v) + } + } +} + +func TestStringSorted_NilHandling(t *testing.T) { + var nilSet StringSorted + + // Test nil encoding + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + err := nilSet.EncodeMsg(writer) + if err != nil { + t.Fatalf("EncodeMsg failed for nil: %v", err) + } + writer.Flush() + + // Test nil decoding + reader := msgp.NewReader(&buf) + var decoded StringSorted + err = decoded.DecodeMsg(reader) + if err != nil { + t.Fatalf("DecodeMsg failed for nil: %v", err) + } + + if decoded != nil { + t.Fatal("expected nil, got non-nil") + } + + // Test nil marshaling + data, err := nilSet.MarshalMsg(nil) + if err != nil { + t.Fatalf("MarshalMsg failed for nil: %v", err) + } + + // Test nil unmarshaling + var unmarshaled StringSorted + _, err = unmarshaled.UnmarshalMsg(data) + if err != nil { + t.Fatalf("UnmarshalMsg failed for nil: %v", err) + } + + if unmarshaled != nil { + t.Fatal("expected nil, got non-nil") + } + + // Test AsSlice on nil + slice := nilSet.AsSlice() + if slice != nil { + t.Fatal("expected nil slice, got non-nil") + } + + // Test FromSlice with nil + fromNilSlice := StringSortedFromSlice(nil) + if fromNilSlice != nil { + t.Fatal("expected nil from nil slice, got non-nil") + } +} + +func TestStringSorted_EmptySet(t *testing.T) { + set := make(StringSorted) + + // Test empty set encoding + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + err := set.EncodeMsg(writer) + if err != nil { + t.Fatalf("EncodeMsg failed for empty: %v", err) + } + writer.Flush() + + // Test empty set decoding + reader := msgp.NewReader(&buf) + var decoded StringSorted + err = decoded.DecodeMsg(reader) + if err != nil { + t.Fatalf("DecodeMsg failed for empty: %v", err) + } + + if len(decoded) != 0 { + t.Fatalf("expected empty set, got length %d", len(decoded)) + } + + // Test empty set marshaling + data, err := set.MarshalMsg(nil) + if err != nil { + t.Fatalf("MarshalMsg failed for empty: %v", err) + } + + // Test empty set unmarshaling + var unmarshaled StringSorted + _, err = unmarshaled.UnmarshalMsg(data) + if err != nil { + t.Fatalf("UnmarshalMsg failed for empty: %v", err) + } + + if len(unmarshaled) != 0 { + t.Fatalf("expected empty set, got length %d", len(unmarshaled)) + } +} + +func BenchmarkString_EncodeMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(String) + for i := 0; i < size; i++ { + set[fmt.Sprintf("val%d", i)] = struct{}{} + } + + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + buf.Reset() + writer.Reset(&buf) + set.EncodeMsg(writer) + writer.Flush() + } + }) + } +} + +func BenchmarkString_DecodeMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(String) + for i := 0; i < size; i++ { + set[fmt.Sprintf("val%d", i)] = struct{}{} + } + + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + set.EncodeMsg(writer) + writer.Flush() + encoded := buf.Bytes() + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + reader := msgp.NewReader(bytes.NewReader(encoded)) + var decoded String + decoded.DecodeMsg(reader) + } + }) + } +} + +func BenchmarkString_MarshalMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(String) + for i := 0; i < size; i++ { + set[fmt.Sprintf("val%d", i)] = struct{}{} + } + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + _, err := set.MarshalMsg(nil) + if err != nil { + b.Fatal(err) + } + } + }) + } +} + +func BenchmarkString_UnmarshalMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(String) + for i := 0; i < size; i++ { + set[fmt.Sprintf("val%d", i)] = struct{}{} + } + + data, _ := set.MarshalMsg(nil) + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + var decoded String + _, err := decoded.UnmarshalMsg(data) + if err != nil { + b.Fatal(err) + } + } + }) + } +} + +func BenchmarkString_AsSlice(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(String) + for i := 0; i < size; i++ { + set[fmt.Sprintf("val%d", i)] = struct{}{} + } + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + _ = set.AsSlice() + } + }) + } +} + +func BenchmarkString_FromSlice(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + slice := make([]string, size) + for i := 0; i < size; i++ { + slice[i] = fmt.Sprintf("val%d", i) + } + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + _ = StringFromSlice(slice) + } + }) + } +} + +func BenchmarkStringSorted_EncodeMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(StringSorted) + for i := 0; i < size; i++ { + set[fmt.Sprintf("val%d", i)] = struct{}{} + } + + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + buf.Reset() + writer.Reset(&buf) + set.EncodeMsg(writer) + writer.Flush() + } + }) + } +} + +func BenchmarkStringSorted_DecodeMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(StringSorted) + for i := 0; i < size; i++ { + set[fmt.Sprintf("val%d", i)] = struct{}{} + } + + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + set.EncodeMsg(writer) + writer.Flush() + encoded := buf.Bytes() + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + reader := msgp.NewReader(bytes.NewReader(encoded)) + var decoded StringSorted + decoded.DecodeMsg(reader) + } + }) + } +} + +func BenchmarkStringSorted_MarshalMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(StringSorted) + for i := 0; i < size; i++ { + set[fmt.Sprintf("val%d", i)] = struct{}{} + } + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + _, err := set.MarshalMsg(nil) + if err != nil { + b.Fatal(err) + } + } + }) + } +} + +func BenchmarkStringSorted_UnmarshalMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(StringSorted) + for i := 0; i < size; i++ { + set[fmt.Sprintf("val%d", i)] = struct{}{} + } + + data, _ := set.MarshalMsg(nil) + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + var decoded StringSorted + _, err := decoded.UnmarshalMsg(data) + if err != nil { + b.Fatal(err) + } + } + }) + } +} + +func BenchmarkStringSorted_AsSlice(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(StringSorted) + for i := 0; i < size; i++ { + set[fmt.Sprintf("val%d", i)] = struct{}{} + } + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + _ = set.AsSlice() + } + }) + } +} + +func BenchmarkStringSorted_FromSlice(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + slice := make([]string, size) + for i := 0; i < size; i++ { + slice[i] = fmt.Sprintf("val%d", i) + } + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + _ = StringSortedFromSlice(slice) + } + }) + } +} + +func TestInt_RoundTrip(t *testing.T) { + set := make(Int) + set[0] = struct{}{} + set[1] = struct{}{} + set[2] = struct{}{} + set[3] = struct{}{} + set[4] = struct{}{} + + // Test EncodeMsg/DecodeMsg + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + err := set.EncodeMsg(writer) + if err != nil { + t.Fatalf("EncodeMsg failed: %v", err) + } + writer.Flush() + + reader := msgp.NewReader(&buf) + var decoded Int + err = decoded.DecodeMsg(reader) + if err != nil { + t.Fatalf("DecodeMsg failed: %v", err) + } + + if len(set) != len(decoded) { + t.Fatalf("length mismatch: expected %d, got %d", len(set), len(decoded)) + } + + for k := range set { + if _, ok := decoded[k]; !ok { + t.Fatalf("missing key: %v", k) + } + } + + // Test MarshalMsg/UnmarshalMsg + data, err := set.MarshalMsg(nil) + if err != nil { + t.Fatalf("MarshalMsg failed: %v", err) + } + + var unmarshaled Int + _, err = unmarshaled.UnmarshalMsg(data) + if err != nil { + t.Fatalf("UnmarshalMsg failed: %v", err) + } + + if len(set) != len(unmarshaled) { + t.Fatalf("length mismatch: expected %d, got %d", len(set), len(unmarshaled)) + } + + for k := range set { + if _, ok := unmarshaled[k]; !ok { + t.Fatalf("missing key: %v", k) + } + } +} + +func TestInt_AsSlice(t *testing.T) { + set := make(Int) + set[0] = struct{}{} + set[1] = struct{}{} + set[2] = struct{}{} + set[3] = struct{}{} + set[4] = struct{}{} + + slice := set.AsSlice() + if len(slice) != len(set) { + t.Fatalf("length mismatch: expected %d, got %d", len(set), len(slice)) + } + + found := make(map[int]bool) + for _, v := range slice { + found[v] = true + } + + for k := range set { + if !found[k] { + t.Fatalf("missing key in slice: %v", k) + } + } +} + +func TestInt_FromSlice(t *testing.T) { + slice := []int{0, 1, 2, 3, 4} + set := IntFromSlice(slice) + + if len(set) != len(slice) { + t.Fatalf("length mismatch: expected %d, got %d", len(slice), len(set)) + } + + for _, v := range slice { + if _, ok := set[v]; !ok { + t.Fatalf("missing key: %v", v) + } + } +} + +func TestInt_NilHandling(t *testing.T) { + var nilSet Int + + // Test nil encoding + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + err := nilSet.EncodeMsg(writer) + if err != nil { + t.Fatalf("EncodeMsg failed for nil: %v", err) + } + writer.Flush() + + // Test nil decoding + reader := msgp.NewReader(&buf) + var decoded Int + err = decoded.DecodeMsg(reader) + if err != nil { + t.Fatalf("DecodeMsg failed for nil: %v", err) + } + + if decoded != nil { + t.Fatal("expected nil, got non-nil") + } + + // Test nil marshaling + data, err := nilSet.MarshalMsg(nil) + if err != nil { + t.Fatalf("MarshalMsg failed for nil: %v", err) + } + + // Test nil unmarshaling + var unmarshaled Int + _, err = unmarshaled.UnmarshalMsg(data) + if err != nil { + t.Fatalf("UnmarshalMsg failed for nil: %v", err) + } + + if unmarshaled != nil { + t.Fatal("expected nil, got non-nil") + } + + // Test AsSlice on nil + slice := nilSet.AsSlice() + if slice != nil { + t.Fatal("expected nil slice, got non-nil") + } + + // Test FromSlice with nil + fromNilSlice := IntFromSlice(nil) + if fromNilSlice != nil { + t.Fatal("expected nil from nil slice, got non-nil") + } +} + +func TestInt_EmptySet(t *testing.T) { + set := make(Int) + + // Test empty set encoding + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + err := set.EncodeMsg(writer) + if err != nil { + t.Fatalf("EncodeMsg failed for empty: %v", err) + } + writer.Flush() + + // Test empty set decoding + reader := msgp.NewReader(&buf) + var decoded Int + err = decoded.DecodeMsg(reader) + if err != nil { + t.Fatalf("DecodeMsg failed for empty: %v", err) + } + + if len(decoded) != 0 { + t.Fatalf("expected empty set, got length %d", len(decoded)) + } + + // Test empty set marshaling + data, err := set.MarshalMsg(nil) + if err != nil { + t.Fatalf("MarshalMsg failed for empty: %v", err) + } + + // Test empty set unmarshaling + var unmarshaled Int + _, err = unmarshaled.UnmarshalMsg(data) + if err != nil { + t.Fatalf("UnmarshalMsg failed for empty: %v", err) + } + + if len(unmarshaled) != 0 { + t.Fatalf("expected empty set, got length %d", len(unmarshaled)) + } +} + +func TestIntSorted_RoundTrip(t *testing.T) { + set := make(IntSorted) + set[0] = struct{}{} + set[1] = struct{}{} + set[2] = struct{}{} + set[3] = struct{}{} + set[4] = struct{}{} + + // Test EncodeMsg/DecodeMsg + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + err := set.EncodeMsg(writer) + if err != nil { + t.Fatalf("EncodeMsg failed: %v", err) + } + writer.Flush() + + reader := msgp.NewReader(&buf) + var decoded IntSorted + err = decoded.DecodeMsg(reader) + if err != nil { + t.Fatalf("DecodeMsg failed: %v", err) + } + + if len(set) != len(decoded) { + t.Fatalf("length mismatch: expected %d, got %d", len(set), len(decoded)) + } + + for k := range set { + if _, ok := decoded[k]; !ok { + t.Fatalf("missing key: %v", k) + } + } + + // Test MarshalMsg/UnmarshalMsg + data, err := set.MarshalMsg(nil) + if err != nil { + t.Fatalf("MarshalMsg failed: %v", err) + } + + var unmarshaled IntSorted + _, err = unmarshaled.UnmarshalMsg(data) + if err != nil { + t.Fatalf("UnmarshalMsg failed: %v", err) + } + + if len(set) != len(unmarshaled) { + t.Fatalf("length mismatch: expected %d, got %d", len(set), len(unmarshaled)) + } + + for k := range set { + if _, ok := unmarshaled[k]; !ok { + t.Fatalf("missing key: %v", k) + } + } +} + +func TestIntSorted_AsSlice(t *testing.T) { + set := make(IntSorted) + set[0] = struct{}{} + set[1] = struct{}{} + set[2] = struct{}{} + set[3] = struct{}{} + set[4] = struct{}{} + + slice := set.AsSlice() + if len(slice) != len(set) { + t.Fatalf("length mismatch: expected %d, got %d", len(set), len(slice)) + } + + found := make(map[int]bool) + for _, v := range slice { + found[v] = true + } + + for k := range set { + if !found[k] { + t.Fatalf("missing key in slice: %v", k) + } + } +} + +func TestIntSorted_FromSlice(t *testing.T) { + slice := []int{0, 1, 2, 3, 4} + set := IntSortedFromSlice(slice) + + if len(set) != len(slice) { + t.Fatalf("length mismatch: expected %d, got %d", len(slice), len(set)) + } + + for _, v := range slice { + if _, ok := set[v]; !ok { + t.Fatalf("missing key: %v", v) + } + } +} + +func TestIntSorted_NilHandling(t *testing.T) { + var nilSet IntSorted + + // Test nil encoding + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + err := nilSet.EncodeMsg(writer) + if err != nil { + t.Fatalf("EncodeMsg failed for nil: %v", err) + } + writer.Flush() + + // Test nil decoding + reader := msgp.NewReader(&buf) + var decoded IntSorted + err = decoded.DecodeMsg(reader) + if err != nil { + t.Fatalf("DecodeMsg failed for nil: %v", err) + } + + if decoded != nil { + t.Fatal("expected nil, got non-nil") + } + + // Test nil marshaling + data, err := nilSet.MarshalMsg(nil) + if err != nil { + t.Fatalf("MarshalMsg failed for nil: %v", err) + } + + // Test nil unmarshaling + var unmarshaled IntSorted + _, err = unmarshaled.UnmarshalMsg(data) + if err != nil { + t.Fatalf("UnmarshalMsg failed for nil: %v", err) + } + + if unmarshaled != nil { + t.Fatal("expected nil, got non-nil") + } + + // Test AsSlice on nil + slice := nilSet.AsSlice() + if slice != nil { + t.Fatal("expected nil slice, got non-nil") + } + + // Test FromSlice with nil + fromNilSlice := IntSortedFromSlice(nil) + if fromNilSlice != nil { + t.Fatal("expected nil from nil slice, got non-nil") + } +} + +func TestIntSorted_EmptySet(t *testing.T) { + set := make(IntSorted) + + // Test empty set encoding + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + err := set.EncodeMsg(writer) + if err != nil { + t.Fatalf("EncodeMsg failed for empty: %v", err) + } + writer.Flush() + + // Test empty set decoding + reader := msgp.NewReader(&buf) + var decoded IntSorted + err = decoded.DecodeMsg(reader) + if err != nil { + t.Fatalf("DecodeMsg failed for empty: %v", err) + } + + if len(decoded) != 0 { + t.Fatalf("expected empty set, got length %d", len(decoded)) + } + + // Test empty set marshaling + data, err := set.MarshalMsg(nil) + if err != nil { + t.Fatalf("MarshalMsg failed for empty: %v", err) + } + + // Test empty set unmarshaling + var unmarshaled IntSorted + _, err = unmarshaled.UnmarshalMsg(data) + if err != nil { + t.Fatalf("UnmarshalMsg failed for empty: %v", err) + } + + if len(unmarshaled) != 0 { + t.Fatalf("expected empty set, got length %d", len(unmarshaled)) + } +} + +func BenchmarkInt_EncodeMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Int) + for i := 0; i < size; i++ { + set[int(i)] = struct{}{} + } + + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + buf.Reset() + writer.Reset(&buf) + set.EncodeMsg(writer) + writer.Flush() + } + }) + } +} + +func BenchmarkInt_DecodeMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Int) + for i := 0; i < size; i++ { + set[int(i)] = struct{}{} + } + + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + set.EncodeMsg(writer) + writer.Flush() + encoded := buf.Bytes() + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + reader := msgp.NewReader(bytes.NewReader(encoded)) + var decoded Int + decoded.DecodeMsg(reader) + } + }) + } +} + +func BenchmarkInt_MarshalMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Int) + for i := 0; i < size; i++ { + set[int(i)] = struct{}{} + } + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + _, err := set.MarshalMsg(nil) + if err != nil { + b.Fatal(err) + } + } + }) + } +} + +func BenchmarkInt_UnmarshalMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Int) + for i := 0; i < size; i++ { + set[int(i)] = struct{}{} + } + + data, _ := set.MarshalMsg(nil) + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + var decoded Int + _, err := decoded.UnmarshalMsg(data) + if err != nil { + b.Fatal(err) + } + } + }) + } +} + +func BenchmarkInt_AsSlice(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Int) + for i := 0; i < size; i++ { + set[int(i)] = struct{}{} + } + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + _ = set.AsSlice() + } + }) + } +} + +func BenchmarkInt_FromSlice(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + slice := make([]int, size) + for i := 0; i < size; i++ { + slice[i] = int(i) + } + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + _ = IntFromSlice(slice) + } + }) + } +} + +func BenchmarkIntSorted_EncodeMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(IntSorted) + for i := 0; i < size; i++ { + set[int(i)] = struct{}{} + } + + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + buf.Reset() + writer.Reset(&buf) + set.EncodeMsg(writer) + writer.Flush() + } + }) + } +} + +func BenchmarkIntSorted_DecodeMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(IntSorted) + for i := 0; i < size; i++ { + set[int(i)] = struct{}{} + } + + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + set.EncodeMsg(writer) + writer.Flush() + encoded := buf.Bytes() + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + reader := msgp.NewReader(bytes.NewReader(encoded)) + var decoded IntSorted + decoded.DecodeMsg(reader) + } + }) + } +} + +func BenchmarkIntSorted_MarshalMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(IntSorted) + for i := 0; i < size; i++ { + set[int(i)] = struct{}{} + } + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + _, err := set.MarshalMsg(nil) + if err != nil { + b.Fatal(err) + } + } + }) + } +} + +func BenchmarkIntSorted_UnmarshalMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(IntSorted) + for i := 0; i < size; i++ { + set[int(i)] = struct{}{} + } + + data, _ := set.MarshalMsg(nil) + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + var decoded IntSorted + _, err := decoded.UnmarshalMsg(data) + if err != nil { + b.Fatal(err) + } + } + }) + } +} + +func BenchmarkIntSorted_AsSlice(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(IntSorted) + for i := 0; i < size; i++ { + set[int(i)] = struct{}{} + } + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + _ = set.AsSlice() + } + }) + } +} + +func BenchmarkIntSorted_FromSlice(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + slice := make([]int, size) + for i := 0; i < size; i++ { + slice[i] = int(i) + } + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + _ = IntSortedFromSlice(slice) + } + }) + } +} + +func TestUint_RoundTrip(t *testing.T) { + set := make(Uint) + set[0] = struct{}{} + set[1] = struct{}{} + set[2] = struct{}{} + set[3] = struct{}{} + set[4] = struct{}{} + + // Test EncodeMsg/DecodeMsg + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + err := set.EncodeMsg(writer) + if err != nil { + t.Fatalf("EncodeMsg failed: %v", err) + } + writer.Flush() + + reader := msgp.NewReader(&buf) + var decoded Uint + err = decoded.DecodeMsg(reader) + if err != nil { + t.Fatalf("DecodeMsg failed: %v", err) + } + + if len(set) != len(decoded) { + t.Fatalf("length mismatch: expected %d, got %d", len(set), len(decoded)) + } + + for k := range set { + if _, ok := decoded[k]; !ok { + t.Fatalf("missing key: %v", k) + } + } + + // Test MarshalMsg/UnmarshalMsg + data, err := set.MarshalMsg(nil) + if err != nil { + t.Fatalf("MarshalMsg failed: %v", err) + } + + var unmarshaled Uint + _, err = unmarshaled.UnmarshalMsg(data) + if err != nil { + t.Fatalf("UnmarshalMsg failed: %v", err) + } + + if len(set) != len(unmarshaled) { + t.Fatalf("length mismatch: expected %d, got %d", len(set), len(unmarshaled)) + } + + for k := range set { + if _, ok := unmarshaled[k]; !ok { + t.Fatalf("missing key: %v", k) + } + } +} + +func TestUint_AsSlice(t *testing.T) { + set := make(Uint) + set[0] = struct{}{} + set[1] = struct{}{} + set[2] = struct{}{} + set[3] = struct{}{} + set[4] = struct{}{} + + slice := set.AsSlice() + if len(slice) != len(set) { + t.Fatalf("length mismatch: expected %d, got %d", len(set), len(slice)) + } + + found := make(map[uint]bool) + for _, v := range slice { + found[v] = true + } + + for k := range set { + if !found[k] { + t.Fatalf("missing key in slice: %v", k) + } + } +} + +func TestUint_FromSlice(t *testing.T) { + slice := []uint{0, 1, 2, 3, 4} + set := UintFromSlice(slice) + + if len(set) != len(slice) { + t.Fatalf("length mismatch: expected %d, got %d", len(slice), len(set)) + } + + for _, v := range slice { + if _, ok := set[v]; !ok { + t.Fatalf("missing key: %v", v) + } + } +} + +func TestUint_NilHandling(t *testing.T) { + var nilSet Uint + + // Test nil encoding + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + err := nilSet.EncodeMsg(writer) + if err != nil { + t.Fatalf("EncodeMsg failed for nil: %v", err) + } + writer.Flush() + + // Test nil decoding + reader := msgp.NewReader(&buf) + var decoded Uint + err = decoded.DecodeMsg(reader) + if err != nil { + t.Fatalf("DecodeMsg failed for nil: %v", err) + } + + if decoded != nil { + t.Fatal("expected nil, got non-nil") + } + + // Test nil marshaling + data, err := nilSet.MarshalMsg(nil) + if err != nil { + t.Fatalf("MarshalMsg failed for nil: %v", err) + } + + // Test nil unmarshaling + var unmarshaled Uint + _, err = unmarshaled.UnmarshalMsg(data) + if err != nil { + t.Fatalf("UnmarshalMsg failed for nil: %v", err) + } + + if unmarshaled != nil { + t.Fatal("expected nil, got non-nil") + } + + // Test AsSlice on nil + slice := nilSet.AsSlice() + if slice != nil { + t.Fatal("expected nil slice, got non-nil") + } + + // Test FromSlice with nil + fromNilSlice := UintFromSlice(nil) + if fromNilSlice != nil { + t.Fatal("expected nil from nil slice, got non-nil") + } +} + +func TestUint_EmptySet(t *testing.T) { + set := make(Uint) + + // Test empty set encoding + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + err := set.EncodeMsg(writer) + if err != nil { + t.Fatalf("EncodeMsg failed for empty: %v", err) + } + writer.Flush() + + // Test empty set decoding + reader := msgp.NewReader(&buf) + var decoded Uint + err = decoded.DecodeMsg(reader) + if err != nil { + t.Fatalf("DecodeMsg failed for empty: %v", err) + } + + if len(decoded) != 0 { + t.Fatalf("expected empty set, got length %d", len(decoded)) + } + + // Test empty set marshaling + data, err := set.MarshalMsg(nil) + if err != nil { + t.Fatalf("MarshalMsg failed for empty: %v", err) + } + + // Test empty set unmarshaling + var unmarshaled Uint + _, err = unmarshaled.UnmarshalMsg(data) + if err != nil { + t.Fatalf("UnmarshalMsg failed for empty: %v", err) + } + + if len(unmarshaled) != 0 { + t.Fatalf("expected empty set, got length %d", len(unmarshaled)) + } +} + +func TestUintSorted_RoundTrip(t *testing.T) { + set := make(UintSorted) + set[0] = struct{}{} + set[1] = struct{}{} + set[2] = struct{}{} + set[3] = struct{}{} + set[4] = struct{}{} + + // Test EncodeMsg/DecodeMsg + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + err := set.EncodeMsg(writer) + if err != nil { + t.Fatalf("EncodeMsg failed: %v", err) + } + writer.Flush() + + reader := msgp.NewReader(&buf) + var decoded UintSorted + err = decoded.DecodeMsg(reader) + if err != nil { + t.Fatalf("DecodeMsg failed: %v", err) + } + + if len(set) != len(decoded) { + t.Fatalf("length mismatch: expected %d, got %d", len(set), len(decoded)) + } + + for k := range set { + if _, ok := decoded[k]; !ok { + t.Fatalf("missing key: %v", k) + } + } + + // Test MarshalMsg/UnmarshalMsg + data, err := set.MarshalMsg(nil) + if err != nil { + t.Fatalf("MarshalMsg failed: %v", err) + } + + var unmarshaled UintSorted + _, err = unmarshaled.UnmarshalMsg(data) + if err != nil { + t.Fatalf("UnmarshalMsg failed: %v", err) + } + + if len(set) != len(unmarshaled) { + t.Fatalf("length mismatch: expected %d, got %d", len(set), len(unmarshaled)) + } + + for k := range set { + if _, ok := unmarshaled[k]; !ok { + t.Fatalf("missing key: %v", k) + } + } +} + +func TestUintSorted_AsSlice(t *testing.T) { + set := make(UintSorted) + set[0] = struct{}{} + set[1] = struct{}{} + set[2] = struct{}{} + set[3] = struct{}{} + set[4] = struct{}{} + + slice := set.AsSlice() + if len(slice) != len(set) { + t.Fatalf("length mismatch: expected %d, got %d", len(set), len(slice)) + } + + found := make(map[uint]bool) + for _, v := range slice { + found[v] = true + } + + for k := range set { + if !found[k] { + t.Fatalf("missing key in slice: %v", k) + } + } +} + +func TestUintSorted_FromSlice(t *testing.T) { + slice := []uint{0, 1, 2, 3, 4} + set := UintSortedFromSlice(slice) + + if len(set) != len(slice) { + t.Fatalf("length mismatch: expected %d, got %d", len(slice), len(set)) + } + + for _, v := range slice { + if _, ok := set[v]; !ok { + t.Fatalf("missing key: %v", v) + } + } +} + +func TestUintSorted_NilHandling(t *testing.T) { + var nilSet UintSorted + + // Test nil encoding + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + err := nilSet.EncodeMsg(writer) + if err != nil { + t.Fatalf("EncodeMsg failed for nil: %v", err) + } + writer.Flush() + + // Test nil decoding + reader := msgp.NewReader(&buf) + var decoded UintSorted + err = decoded.DecodeMsg(reader) + if err != nil { + t.Fatalf("DecodeMsg failed for nil: %v", err) + } + + if decoded != nil { + t.Fatal("expected nil, got non-nil") + } + + // Test nil marshaling + data, err := nilSet.MarshalMsg(nil) + if err != nil { + t.Fatalf("MarshalMsg failed for nil: %v", err) + } + + // Test nil unmarshaling + var unmarshaled UintSorted + _, err = unmarshaled.UnmarshalMsg(data) + if err != nil { + t.Fatalf("UnmarshalMsg failed for nil: %v", err) + } + + if unmarshaled != nil { + t.Fatal("expected nil, got non-nil") + } + + // Test AsSlice on nil + slice := nilSet.AsSlice() + if slice != nil { + t.Fatal("expected nil slice, got non-nil") + } + + // Test FromSlice with nil + fromNilSlice := UintSortedFromSlice(nil) + if fromNilSlice != nil { + t.Fatal("expected nil from nil slice, got non-nil") + } +} + +func TestUintSorted_EmptySet(t *testing.T) { + set := make(UintSorted) + + // Test empty set encoding + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + err := set.EncodeMsg(writer) + if err != nil { + t.Fatalf("EncodeMsg failed for empty: %v", err) + } + writer.Flush() + + // Test empty set decoding + reader := msgp.NewReader(&buf) + var decoded UintSorted + err = decoded.DecodeMsg(reader) + if err != nil { + t.Fatalf("DecodeMsg failed for empty: %v", err) + } + + if len(decoded) != 0 { + t.Fatalf("expected empty set, got length %d", len(decoded)) + } + + // Test empty set marshaling + data, err := set.MarshalMsg(nil) + if err != nil { + t.Fatalf("MarshalMsg failed for empty: %v", err) + } + + // Test empty set unmarshaling + var unmarshaled UintSorted + _, err = unmarshaled.UnmarshalMsg(data) + if err != nil { + t.Fatalf("UnmarshalMsg failed for empty: %v", err) + } + + if len(unmarshaled) != 0 { + t.Fatalf("expected empty set, got length %d", len(unmarshaled)) + } +} + +func BenchmarkUint_EncodeMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Uint) + for i := 0; i < size; i++ { + set[uint(i)] = struct{}{} + } + + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + buf.Reset() + writer.Reset(&buf) + set.EncodeMsg(writer) + writer.Flush() + } + }) + } +} + +func BenchmarkUint_DecodeMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Uint) + for i := 0; i < size; i++ { + set[uint(i)] = struct{}{} + } + + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + set.EncodeMsg(writer) + writer.Flush() + encoded := buf.Bytes() + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + reader := msgp.NewReader(bytes.NewReader(encoded)) + var decoded Uint + decoded.DecodeMsg(reader) + } + }) + } +} + +func BenchmarkUint_MarshalMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Uint) + for i := 0; i < size; i++ { + set[uint(i)] = struct{}{} + } + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + _, err := set.MarshalMsg(nil) + if err != nil { + b.Fatal(err) + } + } + }) + } +} + +func BenchmarkUint_UnmarshalMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Uint) + for i := 0; i < size; i++ { + set[uint(i)] = struct{}{} + } + + data, _ := set.MarshalMsg(nil) + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + var decoded Uint + _, err := decoded.UnmarshalMsg(data) + if err != nil { + b.Fatal(err) + } + } + }) + } +} + +func BenchmarkUint_AsSlice(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Uint) + for i := 0; i < size; i++ { + set[uint(i)] = struct{}{} + } + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + _ = set.AsSlice() + } + }) + } +} + +func BenchmarkUint_FromSlice(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + slice := make([]uint, size) + for i := 0; i < size; i++ { + slice[i] = uint(i) + } + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + _ = UintFromSlice(slice) + } + }) + } +} + +func BenchmarkUintSorted_EncodeMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(UintSorted) + for i := 0; i < size; i++ { + set[uint(i)] = struct{}{} + } + + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + buf.Reset() + writer.Reset(&buf) + set.EncodeMsg(writer) + writer.Flush() + } + }) + } +} + +func BenchmarkUintSorted_DecodeMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(UintSorted) + for i := 0; i < size; i++ { + set[uint(i)] = struct{}{} + } + + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + set.EncodeMsg(writer) + writer.Flush() + encoded := buf.Bytes() + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + reader := msgp.NewReader(bytes.NewReader(encoded)) + var decoded UintSorted + decoded.DecodeMsg(reader) + } + }) + } +} + +func BenchmarkUintSorted_MarshalMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(UintSorted) + for i := 0; i < size; i++ { + set[uint(i)] = struct{}{} + } + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + _, err := set.MarshalMsg(nil) + if err != nil { + b.Fatal(err) + } + } + }) + } +} + +func BenchmarkUintSorted_UnmarshalMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(UintSorted) + for i := 0; i < size; i++ { + set[uint(i)] = struct{}{} + } + + data, _ := set.MarshalMsg(nil) + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + var decoded UintSorted + _, err := decoded.UnmarshalMsg(data) + if err != nil { + b.Fatal(err) + } + } + }) + } +} + +func BenchmarkUintSorted_AsSlice(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(UintSorted) + for i := 0; i < size; i++ { + set[uint(i)] = struct{}{} + } + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + _ = set.AsSlice() + } + }) + } +} + +func BenchmarkUintSorted_FromSlice(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + slice := make([]uint, size) + for i := 0; i < size; i++ { + slice[i] = uint(i) + } + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + _ = UintSortedFromSlice(slice) + } + }) + } +} + +func TestByte_RoundTrip(t *testing.T) { + set := make(Byte) + set[0] = struct{}{} + set[1] = struct{}{} + set[2] = struct{}{} + set[3] = struct{}{} + set[4] = struct{}{} + + // Test EncodeMsg/DecodeMsg + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + err := set.EncodeMsg(writer) + if err != nil { + t.Fatalf("EncodeMsg failed: %v", err) + } + writer.Flush() + + reader := msgp.NewReader(&buf) + var decoded Byte + err = decoded.DecodeMsg(reader) + if err != nil { + t.Fatalf("DecodeMsg failed: %v", err) + } + + if len(set) != len(decoded) { + t.Fatalf("length mismatch: expected %d, got %d", len(set), len(decoded)) + } + + for k := range set { + if _, ok := decoded[k]; !ok { + t.Fatalf("missing key: %v", k) + } + } + + // Test MarshalMsg/UnmarshalMsg + data, err := set.MarshalMsg(nil) + if err != nil { + t.Fatalf("MarshalMsg failed: %v", err) + } + + var unmarshaled Byte + _, err = unmarshaled.UnmarshalMsg(data) + if err != nil { + t.Fatalf("UnmarshalMsg failed: %v", err) + } + + if len(set) != len(unmarshaled) { + t.Fatalf("length mismatch: expected %d, got %d", len(set), len(unmarshaled)) + } + + for k := range set { + if _, ok := unmarshaled[k]; !ok { + t.Fatalf("missing key: %v", k) + } + } +} + +func TestByte_AsSlice(t *testing.T) { + set := make(Byte) + set[0] = struct{}{} + set[1] = struct{}{} + set[2] = struct{}{} + set[3] = struct{}{} + set[4] = struct{}{} + + slice := set.AsSlice() + if len(slice) != len(set) { + t.Fatalf("length mismatch: expected %d, got %d", len(set), len(slice)) + } + + found := make(map[byte]bool) + for _, v := range slice { + found[v] = true + } + + for k := range set { + if !found[k] { + t.Fatalf("missing key in slice: %v", k) + } + } +} + +func TestByte_FromSlice(t *testing.T) { + slice := []byte{0, 1, 2, 3, 4} + set := ByteFromSlice(slice) + + if len(set) != len(slice) { + t.Fatalf("length mismatch: expected %d, got %d", len(slice), len(set)) + } + + for _, v := range slice { + if _, ok := set[v]; !ok { + t.Fatalf("missing key: %v", v) + } + } +} + +func TestByte_NilHandling(t *testing.T) { + var nilSet Byte + + // Test nil encoding + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + err := nilSet.EncodeMsg(writer) + if err != nil { + t.Fatalf("EncodeMsg failed for nil: %v", err) + } + writer.Flush() + + // Test nil decoding + reader := msgp.NewReader(&buf) + var decoded Byte + err = decoded.DecodeMsg(reader) + if err != nil { + t.Fatalf("DecodeMsg failed for nil: %v", err) + } + + if decoded != nil { + t.Fatal("expected nil, got non-nil") + } + + // Test nil marshaling + data, err := nilSet.MarshalMsg(nil) + if err != nil { + t.Fatalf("MarshalMsg failed for nil: %v", err) + } + + // Test nil unmarshaling + var unmarshaled Byte + _, err = unmarshaled.UnmarshalMsg(data) + if err != nil { + t.Fatalf("UnmarshalMsg failed for nil: %v", err) + } + + if unmarshaled != nil { + t.Fatal("expected nil, got non-nil") + } + + // Test AsSlice on nil + slice := nilSet.AsSlice() + if slice != nil { + t.Fatal("expected nil slice, got non-nil") + } + + // Test FromSlice with nil + fromNilSlice := ByteFromSlice(nil) + if fromNilSlice != nil { + t.Fatal("expected nil from nil slice, got non-nil") + } +} + +func TestByte_EmptySet(t *testing.T) { + set := make(Byte) + + // Test empty set encoding + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + err := set.EncodeMsg(writer) + if err != nil { + t.Fatalf("EncodeMsg failed for empty: %v", err) + } + writer.Flush() + + // Test empty set decoding + reader := msgp.NewReader(&buf) + var decoded Byte + err = decoded.DecodeMsg(reader) + if err != nil { + t.Fatalf("DecodeMsg failed for empty: %v", err) + } + + if len(decoded) != 0 { + t.Fatalf("expected empty set, got length %d", len(decoded)) + } + + // Test empty set marshaling + data, err := set.MarshalMsg(nil) + if err != nil { + t.Fatalf("MarshalMsg failed for empty: %v", err) + } + + // Test empty set unmarshaling + var unmarshaled Byte + _, err = unmarshaled.UnmarshalMsg(data) + if err != nil { + t.Fatalf("UnmarshalMsg failed for empty: %v", err) + } + + if len(unmarshaled) != 0 { + t.Fatalf("expected empty set, got length %d", len(unmarshaled)) + } +} + +func TestByteSorted_RoundTrip(t *testing.T) { + set := make(ByteSorted) + set[0] = struct{}{} + set[1] = struct{}{} + set[2] = struct{}{} + set[3] = struct{}{} + set[4] = struct{}{} + + // Test EncodeMsg/DecodeMsg + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + err := set.EncodeMsg(writer) + if err != nil { + t.Fatalf("EncodeMsg failed: %v", err) + } + writer.Flush() + + reader := msgp.NewReader(&buf) + var decoded ByteSorted + err = decoded.DecodeMsg(reader) + if err != nil { + t.Fatalf("DecodeMsg failed: %v", err) + } + + if len(set) != len(decoded) { + t.Fatalf("length mismatch: expected %d, got %d", len(set), len(decoded)) + } + + for k := range set { + if _, ok := decoded[k]; !ok { + t.Fatalf("missing key: %v", k) + } + } + + // Test MarshalMsg/UnmarshalMsg + data, err := set.MarshalMsg(nil) + if err != nil { + t.Fatalf("MarshalMsg failed: %v", err) + } + + var unmarshaled ByteSorted + _, err = unmarshaled.UnmarshalMsg(data) + if err != nil { + t.Fatalf("UnmarshalMsg failed: %v", err) + } + + if len(set) != len(unmarshaled) { + t.Fatalf("length mismatch: expected %d, got %d", len(set), len(unmarshaled)) + } + + for k := range set { + if _, ok := unmarshaled[k]; !ok { + t.Fatalf("missing key: %v", k) + } + } +} + +func TestByteSorted_AsSlice(t *testing.T) { + set := make(ByteSorted) + set[0] = struct{}{} + set[1] = struct{}{} + set[2] = struct{}{} + set[3] = struct{}{} + set[4] = struct{}{} + + slice := set.AsSlice() + if len(slice) != len(set) { + t.Fatalf("length mismatch: expected %d, got %d", len(set), len(slice)) + } + + found := make(map[byte]bool) + for _, v := range slice { + found[v] = true + } + + for k := range set { + if !found[k] { + t.Fatalf("missing key in slice: %v", k) + } + } +} + +func TestByteSorted_FromSlice(t *testing.T) { + slice := []byte{0, 1, 2, 3, 4} + set := ByteSortedFromSlice(slice) + + if len(set) != len(slice) { + t.Fatalf("length mismatch: expected %d, got %d", len(slice), len(set)) + } + + for _, v := range slice { + if _, ok := set[v]; !ok { + t.Fatalf("missing key: %v", v) + } + } +} + +func TestByteSorted_NilHandling(t *testing.T) { + var nilSet ByteSorted + + // Test nil encoding + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + err := nilSet.EncodeMsg(writer) + if err != nil { + t.Fatalf("EncodeMsg failed for nil: %v", err) + } + writer.Flush() + + // Test nil decoding + reader := msgp.NewReader(&buf) + var decoded ByteSorted + err = decoded.DecodeMsg(reader) + if err != nil { + t.Fatalf("DecodeMsg failed for nil: %v", err) + } + + if decoded != nil { + t.Fatal("expected nil, got non-nil") + } + + // Test nil marshaling + data, err := nilSet.MarshalMsg(nil) + if err != nil { + t.Fatalf("MarshalMsg failed for nil: %v", err) + } + + // Test nil unmarshaling + var unmarshaled ByteSorted + _, err = unmarshaled.UnmarshalMsg(data) + if err != nil { + t.Fatalf("UnmarshalMsg failed for nil: %v", err) + } + + if unmarshaled != nil { + t.Fatal("expected nil, got non-nil") + } + + // Test AsSlice on nil + slice := nilSet.AsSlice() + if slice != nil { + t.Fatal("expected nil slice, got non-nil") + } + + // Test FromSlice with nil + fromNilSlice := ByteSortedFromSlice(nil) + if fromNilSlice != nil { + t.Fatal("expected nil from nil slice, got non-nil") + } +} + +func TestByteSorted_EmptySet(t *testing.T) { + set := make(ByteSorted) + + // Test empty set encoding + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + err := set.EncodeMsg(writer) + if err != nil { + t.Fatalf("EncodeMsg failed for empty: %v", err) + } + writer.Flush() + + // Test empty set decoding + reader := msgp.NewReader(&buf) + var decoded ByteSorted + err = decoded.DecodeMsg(reader) + if err != nil { + t.Fatalf("DecodeMsg failed for empty: %v", err) + } + + if len(decoded) != 0 { + t.Fatalf("expected empty set, got length %d", len(decoded)) + } + + // Test empty set marshaling + data, err := set.MarshalMsg(nil) + if err != nil { + t.Fatalf("MarshalMsg failed for empty: %v", err) + } + + // Test empty set unmarshaling + var unmarshaled ByteSorted + _, err = unmarshaled.UnmarshalMsg(data) + if err != nil { + t.Fatalf("UnmarshalMsg failed for empty: %v", err) + } + + if len(unmarshaled) != 0 { + t.Fatalf("expected empty set, got length %d", len(unmarshaled)) + } +} + +func BenchmarkByte_EncodeMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Byte) + for i := 0; i < size; i++ { + set[byte(i%256)] = struct{}{} + } + + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + buf.Reset() + writer.Reset(&buf) + set.EncodeMsg(writer) + writer.Flush() + } + }) + } +} + +func BenchmarkByte_DecodeMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Byte) + for i := 0; i < size; i++ { + set[byte(i%256)] = struct{}{} + } + + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + set.EncodeMsg(writer) + writer.Flush() + encoded := buf.Bytes() + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + reader := msgp.NewReader(bytes.NewReader(encoded)) + var decoded Byte + decoded.DecodeMsg(reader) + } + }) + } +} + +func BenchmarkByte_MarshalMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Byte) + for i := 0; i < size; i++ { + set[byte(i%256)] = struct{}{} + } + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + _, err := set.MarshalMsg(nil) + if err != nil { + b.Fatal(err) + } + } + }) + } +} + +func BenchmarkByte_UnmarshalMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Byte) + for i := 0; i < size; i++ { + set[byte(i%256)] = struct{}{} + } + + data, _ := set.MarshalMsg(nil) + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + var decoded Byte + _, err := decoded.UnmarshalMsg(data) + if err != nil { + b.Fatal(err) + } + } + }) + } +} + +func BenchmarkByte_AsSlice(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Byte) + for i := 0; i < size; i++ { + set[byte(i%256)] = struct{}{} + } + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + _ = set.AsSlice() + } + }) + } +} + +func BenchmarkByte_FromSlice(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + slice := make([]byte, size) + for i := 0; i < size; i++ { + slice[i] = byte(i % 256) + } + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + _ = ByteFromSlice(slice) + } + }) + } +} + +func BenchmarkByteSorted_EncodeMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(ByteSorted) + for i := 0; i < size; i++ { + set[byte(i%256)] = struct{}{} + } + + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + buf.Reset() + writer.Reset(&buf) + set.EncodeMsg(writer) + writer.Flush() + } + }) + } +} + +func BenchmarkByteSorted_DecodeMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(ByteSorted) + for i := 0; i < size; i++ { + set[byte(i%256)] = struct{}{} + } + + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + set.EncodeMsg(writer) + writer.Flush() + encoded := buf.Bytes() + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + reader := msgp.NewReader(bytes.NewReader(encoded)) + var decoded ByteSorted + decoded.DecodeMsg(reader) + } + }) + } +} + +func BenchmarkByteSorted_MarshalMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(ByteSorted) + for i := 0; i < size; i++ { + set[byte(i%256)] = struct{}{} + } + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + _, err := set.MarshalMsg(nil) + if err != nil { + b.Fatal(err) + } + } + }) + } +} + +func BenchmarkByteSorted_UnmarshalMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(ByteSorted) + for i := 0; i < size; i++ { + set[byte(i%256)] = struct{}{} + } + + data, _ := set.MarshalMsg(nil) + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + var decoded ByteSorted + _, err := decoded.UnmarshalMsg(data) + if err != nil { + b.Fatal(err) + } + } + }) + } +} + +func BenchmarkByteSorted_AsSlice(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(ByteSorted) + for i := 0; i < size; i++ { + set[byte(i%256)] = struct{}{} + } + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + _ = set.AsSlice() + } + }) + } +} + +func BenchmarkByteSorted_FromSlice(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + slice := make([]byte, size) + for i := 0; i < size; i++ { + slice[i] = byte(i % 256) + } + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + _ = ByteSortedFromSlice(slice) + } + }) + } +} + +func TestInt8_RoundTrip(t *testing.T) { + set := make(Int8) + set[-128] = struct{}{} + set[-127] = struct{}{} + set[-126] = struct{}{} + set[-125] = struct{}{} + set[-124] = struct{}{} + + // Test EncodeMsg/DecodeMsg + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + err := set.EncodeMsg(writer) + if err != nil { + t.Fatalf("EncodeMsg failed: %v", err) + } + writer.Flush() + + reader := msgp.NewReader(&buf) + var decoded Int8 + err = decoded.DecodeMsg(reader) + if err != nil { + t.Fatalf("DecodeMsg failed: %v", err) + } + + if len(set) != len(decoded) { + t.Fatalf("length mismatch: expected %d, got %d", len(set), len(decoded)) + } + + for k := range set { + if _, ok := decoded[k]; !ok { + t.Fatalf("missing key: %v", k) + } + } + + // Test MarshalMsg/UnmarshalMsg + data, err := set.MarshalMsg(nil) + if err != nil { + t.Fatalf("MarshalMsg failed: %v", err) + } + + var unmarshaled Int8 + _, err = unmarshaled.UnmarshalMsg(data) + if err != nil { + t.Fatalf("UnmarshalMsg failed: %v", err) + } + + if len(set) != len(unmarshaled) { + t.Fatalf("length mismatch: expected %d, got %d", len(set), len(unmarshaled)) + } + + for k := range set { + if _, ok := unmarshaled[k]; !ok { + t.Fatalf("missing key: %v", k) + } + } +} + +func TestInt8_AsSlice(t *testing.T) { + set := make(Int8) + set[-128] = struct{}{} + set[-127] = struct{}{} + set[-126] = struct{}{} + set[-125] = struct{}{} + set[-124] = struct{}{} + + slice := set.AsSlice() + if len(slice) != len(set) { + t.Fatalf("length mismatch: expected %d, got %d", len(set), len(slice)) + } + + found := make(map[int8]bool) + for _, v := range slice { + found[v] = true + } + + for k := range set { + if !found[k] { + t.Fatalf("missing key in slice: %v", k) + } + } +} + +func TestInt8_FromSlice(t *testing.T) { + slice := []int8{-128, -127, -126, -125, -124} + set := Int8FromSlice(slice) + + if len(set) != len(slice) { + t.Fatalf("length mismatch: expected %d, got %d", len(slice), len(set)) + } + + for _, v := range slice { + if _, ok := set[v]; !ok { + t.Fatalf("missing key: %v", v) + } + } +} + +func TestInt8_NilHandling(t *testing.T) { + var nilSet Int8 + + // Test nil encoding + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + err := nilSet.EncodeMsg(writer) + if err != nil { + t.Fatalf("EncodeMsg failed for nil: %v", err) + } + writer.Flush() + + // Test nil decoding + reader := msgp.NewReader(&buf) + var decoded Int8 + err = decoded.DecodeMsg(reader) + if err != nil { + t.Fatalf("DecodeMsg failed for nil: %v", err) + } + + if decoded != nil { + t.Fatal("expected nil, got non-nil") + } + + // Test nil marshaling + data, err := nilSet.MarshalMsg(nil) + if err != nil { + t.Fatalf("MarshalMsg failed for nil: %v", err) + } + + // Test nil unmarshaling + var unmarshaled Int8 + _, err = unmarshaled.UnmarshalMsg(data) + if err != nil { + t.Fatalf("UnmarshalMsg failed for nil: %v", err) + } + + if unmarshaled != nil { + t.Fatal("expected nil, got non-nil") + } + + // Test AsSlice on nil + slice := nilSet.AsSlice() + if slice != nil { + t.Fatal("expected nil slice, got non-nil") + } + + // Test FromSlice with nil + fromNilSlice := Int8FromSlice(nil) + if fromNilSlice != nil { + t.Fatal("expected nil from nil slice, got non-nil") + } +} + +func TestInt8_EmptySet(t *testing.T) { + set := make(Int8) + + // Test empty set encoding + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + err := set.EncodeMsg(writer) + if err != nil { + t.Fatalf("EncodeMsg failed for empty: %v", err) + } + writer.Flush() + + // Test empty set decoding + reader := msgp.NewReader(&buf) + var decoded Int8 + err = decoded.DecodeMsg(reader) + if err != nil { + t.Fatalf("DecodeMsg failed for empty: %v", err) + } + + if len(decoded) != 0 { + t.Fatalf("expected empty set, got length %d", len(decoded)) + } + + // Test empty set marshaling + data, err := set.MarshalMsg(nil) + if err != nil { + t.Fatalf("MarshalMsg failed for empty: %v", err) + } + + // Test empty set unmarshaling + var unmarshaled Int8 + _, err = unmarshaled.UnmarshalMsg(data) + if err != nil { + t.Fatalf("UnmarshalMsg failed for empty: %v", err) + } + + if len(unmarshaled) != 0 { + t.Fatalf("expected empty set, got length %d", len(unmarshaled)) + } +} + +func TestInt8Sorted_RoundTrip(t *testing.T) { + set := make(Int8Sorted) + set[-128] = struct{}{} + set[-127] = struct{}{} + set[-126] = struct{}{} + set[-125] = struct{}{} + set[-124] = struct{}{} + + // Test EncodeMsg/DecodeMsg + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + err := set.EncodeMsg(writer) + if err != nil { + t.Fatalf("EncodeMsg failed: %v", err) + } + writer.Flush() + + reader := msgp.NewReader(&buf) + var decoded Int8Sorted + err = decoded.DecodeMsg(reader) + if err != nil { + t.Fatalf("DecodeMsg failed: %v", err) + } + + if len(set) != len(decoded) { + t.Fatalf("length mismatch: expected %d, got %d", len(set), len(decoded)) + } + + for k := range set { + if _, ok := decoded[k]; !ok { + t.Fatalf("missing key: %v", k) + } + } + + // Test MarshalMsg/UnmarshalMsg + data, err := set.MarshalMsg(nil) + if err != nil { + t.Fatalf("MarshalMsg failed: %v", err) + } + + var unmarshaled Int8Sorted + _, err = unmarshaled.UnmarshalMsg(data) + if err != nil { + t.Fatalf("UnmarshalMsg failed: %v", err) + } + + if len(set) != len(unmarshaled) { + t.Fatalf("length mismatch: expected %d, got %d", len(set), len(unmarshaled)) + } + + for k := range set { + if _, ok := unmarshaled[k]; !ok { + t.Fatalf("missing key: %v", k) + } + } +} + +func TestInt8Sorted_AsSlice(t *testing.T) { + set := make(Int8Sorted) + set[-128] = struct{}{} + set[-127] = struct{}{} + set[-126] = struct{}{} + set[-125] = struct{}{} + set[-124] = struct{}{} + + slice := set.AsSlice() + if len(slice) != len(set) { + t.Fatalf("length mismatch: expected %d, got %d", len(set), len(slice)) + } + + found := make(map[int8]bool) + for _, v := range slice { + found[v] = true + } + + for k := range set { + if !found[k] { + t.Fatalf("missing key in slice: %v", k) + } + } +} + +func TestInt8Sorted_FromSlice(t *testing.T) { + slice := []int8{-128, -127, -126, -125, -124} + set := Int8SortedFromSlice(slice) + + if len(set) != len(slice) { + t.Fatalf("length mismatch: expected %d, got %d", len(slice), len(set)) + } + + for _, v := range slice { + if _, ok := set[v]; !ok { + t.Fatalf("missing key: %v", v) + } + } +} + +func TestInt8Sorted_NilHandling(t *testing.T) { + var nilSet Int8Sorted + + // Test nil encoding + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + err := nilSet.EncodeMsg(writer) + if err != nil { + t.Fatalf("EncodeMsg failed for nil: %v", err) + } + writer.Flush() + + // Test nil decoding + reader := msgp.NewReader(&buf) + var decoded Int8Sorted + err = decoded.DecodeMsg(reader) + if err != nil { + t.Fatalf("DecodeMsg failed for nil: %v", err) + } + + if decoded != nil { + t.Fatal("expected nil, got non-nil") + } + + // Test nil marshaling + data, err := nilSet.MarshalMsg(nil) + if err != nil { + t.Fatalf("MarshalMsg failed for nil: %v", err) + } + + // Test nil unmarshaling + var unmarshaled Int8Sorted + _, err = unmarshaled.UnmarshalMsg(data) + if err != nil { + t.Fatalf("UnmarshalMsg failed for nil: %v", err) + } + + if unmarshaled != nil { + t.Fatal("expected nil, got non-nil") + } + + // Test AsSlice on nil + slice := nilSet.AsSlice() + if slice != nil { + t.Fatal("expected nil slice, got non-nil") + } + + // Test FromSlice with nil + fromNilSlice := Int8SortedFromSlice(nil) + if fromNilSlice != nil { + t.Fatal("expected nil from nil slice, got non-nil") + } +} + +func TestInt8Sorted_EmptySet(t *testing.T) { + set := make(Int8Sorted) + + // Test empty set encoding + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + err := set.EncodeMsg(writer) + if err != nil { + t.Fatalf("EncodeMsg failed for empty: %v", err) + } + writer.Flush() + + // Test empty set decoding + reader := msgp.NewReader(&buf) + var decoded Int8Sorted + err = decoded.DecodeMsg(reader) + if err != nil { + t.Fatalf("DecodeMsg failed for empty: %v", err) + } + + if len(decoded) != 0 { + t.Fatalf("expected empty set, got length %d", len(decoded)) + } + + // Test empty set marshaling + data, err := set.MarshalMsg(nil) + if err != nil { + t.Fatalf("MarshalMsg failed for empty: %v", err) + } + + // Test empty set unmarshaling + var unmarshaled Int8Sorted + _, err = unmarshaled.UnmarshalMsg(data) + if err != nil { + t.Fatalf("UnmarshalMsg failed for empty: %v", err) + } + + if len(unmarshaled) != 0 { + t.Fatalf("expected empty set, got length %d", len(unmarshaled)) + } +} + +func BenchmarkInt8_EncodeMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Int8) + for i := 0; i < size; i++ { + set[int8((i%256)-128)] = struct{}{} + } + + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + buf.Reset() + writer.Reset(&buf) + set.EncodeMsg(writer) + writer.Flush() + } + }) + } +} + +func BenchmarkInt8_DecodeMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Int8) + for i := 0; i < size; i++ { + set[int8((i%256)-128)] = struct{}{} + } + + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + set.EncodeMsg(writer) + writer.Flush() + encoded := buf.Bytes() + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + reader := msgp.NewReader(bytes.NewReader(encoded)) + var decoded Int8 + decoded.DecodeMsg(reader) + } + }) + } +} + +func BenchmarkInt8_MarshalMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Int8) + for i := 0; i < size; i++ { + set[int8((i%256)-128)] = struct{}{} + } + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + _, err := set.MarshalMsg(nil) + if err != nil { + b.Fatal(err) + } + } + }) + } +} + +func BenchmarkInt8_UnmarshalMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Int8) + for i := 0; i < size; i++ { + set[int8((i%256)-128)] = struct{}{} + } + + data, _ := set.MarshalMsg(nil) + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + var decoded Int8 + _, err := decoded.UnmarshalMsg(data) + if err != nil { + b.Fatal(err) + } + } + }) + } +} + +func BenchmarkInt8_AsSlice(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Int8) + for i := 0; i < size; i++ { + set[int8((i%256)-128)] = struct{}{} + } + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + _ = set.AsSlice() + } + }) + } +} + +func BenchmarkInt8_FromSlice(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + slice := make([]int8, size) + for i := 0; i < size; i++ { + slice[i] = int8((i % 256) - 128) + } + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + _ = Int8FromSlice(slice) + } + }) + } +} + +func BenchmarkInt8Sorted_EncodeMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Int8Sorted) + for i := 0; i < size; i++ { + set[int8((i%256)-128)] = struct{}{} + } + + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + buf.Reset() + writer.Reset(&buf) + set.EncodeMsg(writer) + writer.Flush() + } + }) + } +} + +func BenchmarkInt8Sorted_DecodeMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Int8Sorted) + for i := 0; i < size; i++ { + set[int8((i%256)-128)] = struct{}{} + } + + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + set.EncodeMsg(writer) + writer.Flush() + encoded := buf.Bytes() + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + reader := msgp.NewReader(bytes.NewReader(encoded)) + var decoded Int8Sorted + decoded.DecodeMsg(reader) + } + }) + } +} + +func BenchmarkInt8Sorted_MarshalMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Int8Sorted) + for i := 0; i < size; i++ { + set[int8((i%256)-128)] = struct{}{} + } + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + _, err := set.MarshalMsg(nil) + if err != nil { + b.Fatal(err) + } + } + }) + } +} + +func BenchmarkInt8Sorted_UnmarshalMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Int8Sorted) + for i := 0; i < size; i++ { + set[int8((i%256)-128)] = struct{}{} + } + + data, _ := set.MarshalMsg(nil) + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + var decoded Int8Sorted + _, err := decoded.UnmarshalMsg(data) + if err != nil { + b.Fatal(err) + } + } + }) + } +} + +func BenchmarkInt8Sorted_AsSlice(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Int8Sorted) + for i := 0; i < size; i++ { + set[int8((i%256)-128)] = struct{}{} + } + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + _ = set.AsSlice() + } + }) + } +} + +func BenchmarkInt8Sorted_FromSlice(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + slice := make([]int8, size) + for i := 0; i < size; i++ { + slice[i] = int8((i % 256) - 128) + } + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + _ = Int8SortedFromSlice(slice) + } + }) + } +} + +func TestUint8_RoundTrip(t *testing.T) { + set := make(Uint8) + set[0] = struct{}{} + set[1] = struct{}{} + set[2] = struct{}{} + set[3] = struct{}{} + set[4] = struct{}{} + + // Test EncodeMsg/DecodeMsg + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + err := set.EncodeMsg(writer) + if err != nil { + t.Fatalf("EncodeMsg failed: %v", err) + } + writer.Flush() + + reader := msgp.NewReader(&buf) + var decoded Uint8 + err = decoded.DecodeMsg(reader) + if err != nil { + t.Fatalf("DecodeMsg failed: %v", err) + } + + if len(set) != len(decoded) { + t.Fatalf("length mismatch: expected %d, got %d", len(set), len(decoded)) + } + + for k := range set { + if _, ok := decoded[k]; !ok { + t.Fatalf("missing key: %v", k) + } + } + + // Test MarshalMsg/UnmarshalMsg + data, err := set.MarshalMsg(nil) + if err != nil { + t.Fatalf("MarshalMsg failed: %v", err) + } + + var unmarshaled Uint8 + _, err = unmarshaled.UnmarshalMsg(data) + if err != nil { + t.Fatalf("UnmarshalMsg failed: %v", err) + } + + if len(set) != len(unmarshaled) { + t.Fatalf("length mismatch: expected %d, got %d", len(set), len(unmarshaled)) + } + + for k := range set { + if _, ok := unmarshaled[k]; !ok { + t.Fatalf("missing key: %v", k) + } + } +} + +func TestUint8_AsSlice(t *testing.T) { + set := make(Uint8) + set[0] = struct{}{} + set[1] = struct{}{} + set[2] = struct{}{} + set[3] = struct{}{} + set[4] = struct{}{} + + slice := set.AsSlice() + if len(slice) != len(set) { + t.Fatalf("length mismatch: expected %d, got %d", len(set), len(slice)) + } + + found := make(map[uint8]bool) + for _, v := range slice { + found[v] = true + } + + for k := range set { + if !found[k] { + t.Fatalf("missing key in slice: %v", k) + } + } +} + +func TestUint8_FromSlice(t *testing.T) { + slice := []uint8{0, 1, 2, 3, 4} + set := Uint8FromSlice(slice) + + if len(set) != len(slice) { + t.Fatalf("length mismatch: expected %d, got %d", len(slice), len(set)) + } + + for _, v := range slice { + if _, ok := set[v]; !ok { + t.Fatalf("missing key: %v", v) + } + } +} + +func TestUint8_NilHandling(t *testing.T) { + var nilSet Uint8 + + // Test nil encoding + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + err := nilSet.EncodeMsg(writer) + if err != nil { + t.Fatalf("EncodeMsg failed for nil: %v", err) + } + writer.Flush() + + // Test nil decoding + reader := msgp.NewReader(&buf) + var decoded Uint8 + err = decoded.DecodeMsg(reader) + if err != nil { + t.Fatalf("DecodeMsg failed for nil: %v", err) + } + + if decoded != nil { + t.Fatal("expected nil, got non-nil") + } + + // Test nil marshaling + data, err := nilSet.MarshalMsg(nil) + if err != nil { + t.Fatalf("MarshalMsg failed for nil: %v", err) + } + + // Test nil unmarshaling + var unmarshaled Uint8 + _, err = unmarshaled.UnmarshalMsg(data) + if err != nil { + t.Fatalf("UnmarshalMsg failed for nil: %v", err) + } + + if unmarshaled != nil { + t.Fatal("expected nil, got non-nil") + } + + // Test AsSlice on nil + slice := nilSet.AsSlice() + if slice != nil { + t.Fatal("expected nil slice, got non-nil") + } + + // Test FromSlice with nil + fromNilSlice := Uint8FromSlice(nil) + if fromNilSlice != nil { + t.Fatal("expected nil from nil slice, got non-nil") + } +} + +func TestUint8_EmptySet(t *testing.T) { + set := make(Uint8) + + // Test empty set encoding + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + err := set.EncodeMsg(writer) + if err != nil { + t.Fatalf("EncodeMsg failed for empty: %v", err) + } + writer.Flush() + + // Test empty set decoding + reader := msgp.NewReader(&buf) + var decoded Uint8 + err = decoded.DecodeMsg(reader) + if err != nil { + t.Fatalf("DecodeMsg failed for empty: %v", err) + } + + if len(decoded) != 0 { + t.Fatalf("expected empty set, got length %d", len(decoded)) + } + + // Test empty set marshaling + data, err := set.MarshalMsg(nil) + if err != nil { + t.Fatalf("MarshalMsg failed for empty: %v", err) + } + + // Test empty set unmarshaling + var unmarshaled Uint8 + _, err = unmarshaled.UnmarshalMsg(data) + if err != nil { + t.Fatalf("UnmarshalMsg failed for empty: %v", err) + } + + if len(unmarshaled) != 0 { + t.Fatalf("expected empty set, got length %d", len(unmarshaled)) + } +} + +func TestUint8Sorted_RoundTrip(t *testing.T) { + set := make(Uint8Sorted) + set[0] = struct{}{} + set[1] = struct{}{} + set[2] = struct{}{} + set[3] = struct{}{} + set[4] = struct{}{} + + // Test EncodeMsg/DecodeMsg + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + err := set.EncodeMsg(writer) + if err != nil { + t.Fatalf("EncodeMsg failed: %v", err) + } + writer.Flush() + + reader := msgp.NewReader(&buf) + var decoded Uint8Sorted + err = decoded.DecodeMsg(reader) + if err != nil { + t.Fatalf("DecodeMsg failed: %v", err) + } + + if len(set) != len(decoded) { + t.Fatalf("length mismatch: expected %d, got %d", len(set), len(decoded)) + } + + for k := range set { + if _, ok := decoded[k]; !ok { + t.Fatalf("missing key: %v", k) + } + } + + // Test MarshalMsg/UnmarshalMsg + data, err := set.MarshalMsg(nil) + if err != nil { + t.Fatalf("MarshalMsg failed: %v", err) + } + + var unmarshaled Uint8Sorted + _, err = unmarshaled.UnmarshalMsg(data) + if err != nil { + t.Fatalf("UnmarshalMsg failed: %v", err) + } + + if len(set) != len(unmarshaled) { + t.Fatalf("length mismatch: expected %d, got %d", len(set), len(unmarshaled)) + } + + for k := range set { + if _, ok := unmarshaled[k]; !ok { + t.Fatalf("missing key: %v", k) + } + } +} + +func TestUint8Sorted_AsSlice(t *testing.T) { + set := make(Uint8Sorted) + set[0] = struct{}{} + set[1] = struct{}{} + set[2] = struct{}{} + set[3] = struct{}{} + set[4] = struct{}{} + + slice := set.AsSlice() + if len(slice) != len(set) { + t.Fatalf("length mismatch: expected %d, got %d", len(set), len(slice)) + } + + found := make(map[uint8]bool) + for _, v := range slice { + found[v] = true + } + + for k := range set { + if !found[k] { + t.Fatalf("missing key in slice: %v", k) + } + } +} + +func TestUint8Sorted_FromSlice(t *testing.T) { + slice := []uint8{0, 1, 2, 3, 4} + set := Uint8SortedFromSlice(slice) + + if len(set) != len(slice) { + t.Fatalf("length mismatch: expected %d, got %d", len(slice), len(set)) + } + + for _, v := range slice { + if _, ok := set[v]; !ok { + t.Fatalf("missing key: %v", v) + } + } +} + +func TestUint8Sorted_NilHandling(t *testing.T) { + var nilSet Uint8Sorted + + // Test nil encoding + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + err := nilSet.EncodeMsg(writer) + if err != nil { + t.Fatalf("EncodeMsg failed for nil: %v", err) + } + writer.Flush() + + // Test nil decoding + reader := msgp.NewReader(&buf) + var decoded Uint8Sorted + err = decoded.DecodeMsg(reader) + if err != nil { + t.Fatalf("DecodeMsg failed for nil: %v", err) + } + + if decoded != nil { + t.Fatal("expected nil, got non-nil") + } + + // Test nil marshaling + data, err := nilSet.MarshalMsg(nil) + if err != nil { + t.Fatalf("MarshalMsg failed for nil: %v", err) + } + + // Test nil unmarshaling + var unmarshaled Uint8Sorted + _, err = unmarshaled.UnmarshalMsg(data) + if err != nil { + t.Fatalf("UnmarshalMsg failed for nil: %v", err) + } + + if unmarshaled != nil { + t.Fatal("expected nil, got non-nil") + } + + // Test AsSlice on nil + slice := nilSet.AsSlice() + if slice != nil { + t.Fatal("expected nil slice, got non-nil") + } + + // Test FromSlice with nil + fromNilSlice := Uint8SortedFromSlice(nil) + if fromNilSlice != nil { + t.Fatal("expected nil from nil slice, got non-nil") + } +} + +func TestUint8Sorted_EmptySet(t *testing.T) { + set := make(Uint8Sorted) + + // Test empty set encoding + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + err := set.EncodeMsg(writer) + if err != nil { + t.Fatalf("EncodeMsg failed for empty: %v", err) + } + writer.Flush() + + // Test empty set decoding + reader := msgp.NewReader(&buf) + var decoded Uint8Sorted + err = decoded.DecodeMsg(reader) + if err != nil { + t.Fatalf("DecodeMsg failed for empty: %v", err) + } + + if len(decoded) != 0 { + t.Fatalf("expected empty set, got length %d", len(decoded)) + } + + // Test empty set marshaling + data, err := set.MarshalMsg(nil) + if err != nil { + t.Fatalf("MarshalMsg failed for empty: %v", err) + } + + // Test empty set unmarshaling + var unmarshaled Uint8Sorted + _, err = unmarshaled.UnmarshalMsg(data) + if err != nil { + t.Fatalf("UnmarshalMsg failed for empty: %v", err) + } + + if len(unmarshaled) != 0 { + t.Fatalf("expected empty set, got length %d", len(unmarshaled)) + } +} + +func BenchmarkUint8_EncodeMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Uint8) + for i := 0; i < size; i++ { + set[uint8(i%256)] = struct{}{} + } + + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + buf.Reset() + writer.Reset(&buf) + set.EncodeMsg(writer) + writer.Flush() + } + }) + } +} + +func BenchmarkUint8_DecodeMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Uint8) + for i := 0; i < size; i++ { + set[uint8(i%256)] = struct{}{} + } + + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + set.EncodeMsg(writer) + writer.Flush() + encoded := buf.Bytes() + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + reader := msgp.NewReader(bytes.NewReader(encoded)) + var decoded Uint8 + decoded.DecodeMsg(reader) + } + }) + } +} + +func BenchmarkUint8_MarshalMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Uint8) + for i := 0; i < size; i++ { + set[uint8(i%256)] = struct{}{} + } + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + _, err := set.MarshalMsg(nil) + if err != nil { + b.Fatal(err) + } + } + }) + } +} + +func BenchmarkUint8_UnmarshalMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Uint8) + for i := 0; i < size; i++ { + set[uint8(i%256)] = struct{}{} + } + + data, _ := set.MarshalMsg(nil) + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + var decoded Uint8 + _, err := decoded.UnmarshalMsg(data) + if err != nil { + b.Fatal(err) + } + } + }) + } +} + +func BenchmarkUint8_AsSlice(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Uint8) + for i := 0; i < size; i++ { + set[uint8(i%256)] = struct{}{} + } + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + _ = set.AsSlice() + } + }) + } +} + +func BenchmarkUint8_FromSlice(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + slice := make([]uint8, size) + for i := 0; i < size; i++ { + slice[i] = uint8(i % 256) + } + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + _ = Uint8FromSlice(slice) + } + }) + } +} + +func BenchmarkUint8Sorted_EncodeMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Uint8Sorted) + for i := 0; i < size; i++ { + set[uint8(i%256)] = struct{}{} + } + + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + buf.Reset() + writer.Reset(&buf) + set.EncodeMsg(writer) + writer.Flush() + } + }) + } +} + +func BenchmarkUint8Sorted_DecodeMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Uint8Sorted) + for i := 0; i < size; i++ { + set[uint8(i%256)] = struct{}{} + } + + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + set.EncodeMsg(writer) + writer.Flush() + encoded := buf.Bytes() + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + reader := msgp.NewReader(bytes.NewReader(encoded)) + var decoded Uint8Sorted + decoded.DecodeMsg(reader) + } + }) + } +} + +func BenchmarkUint8Sorted_MarshalMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Uint8Sorted) + for i := 0; i < size; i++ { + set[uint8(i%256)] = struct{}{} + } + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + _, err := set.MarshalMsg(nil) + if err != nil { + b.Fatal(err) + } + } + }) + } +} + +func BenchmarkUint8Sorted_UnmarshalMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Uint8Sorted) + for i := 0; i < size; i++ { + set[uint8(i%256)] = struct{}{} + } + + data, _ := set.MarshalMsg(nil) + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + var decoded Uint8Sorted + _, err := decoded.UnmarshalMsg(data) + if err != nil { + b.Fatal(err) + } + } + }) + } +} + +func BenchmarkUint8Sorted_AsSlice(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Uint8Sorted) + for i := 0; i < size; i++ { + set[uint8(i%256)] = struct{}{} + } + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + _ = set.AsSlice() + } + }) + } +} + +func BenchmarkUint8Sorted_FromSlice(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + slice := make([]uint8, size) + for i := 0; i < size; i++ { + slice[i] = uint8(i % 256) + } + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + _ = Uint8SortedFromSlice(slice) + } + }) + } +} + +func TestInt16_RoundTrip(t *testing.T) { + set := make(Int16) + set[-32768] = struct{}{} + set[-32767] = struct{}{} + set[-32766] = struct{}{} + set[-32765] = struct{}{} + set[-32764] = struct{}{} + + // Test EncodeMsg/DecodeMsg + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + err := set.EncodeMsg(writer) + if err != nil { + t.Fatalf("EncodeMsg failed: %v", err) + } + writer.Flush() + + reader := msgp.NewReader(&buf) + var decoded Int16 + err = decoded.DecodeMsg(reader) + if err != nil { + t.Fatalf("DecodeMsg failed: %v", err) + } + + if len(set) != len(decoded) { + t.Fatalf("length mismatch: expected %d, got %d", len(set), len(decoded)) + } + + for k := range set { + if _, ok := decoded[k]; !ok { + t.Fatalf("missing key: %v", k) + } + } + + // Test MarshalMsg/UnmarshalMsg + data, err := set.MarshalMsg(nil) + if err != nil { + t.Fatalf("MarshalMsg failed: %v", err) + } + + var unmarshaled Int16 + _, err = unmarshaled.UnmarshalMsg(data) + if err != nil { + t.Fatalf("UnmarshalMsg failed: %v", err) + } + + if len(set) != len(unmarshaled) { + t.Fatalf("length mismatch: expected %d, got %d", len(set), len(unmarshaled)) + } + + for k := range set { + if _, ok := unmarshaled[k]; !ok { + t.Fatalf("missing key: %v", k) + } + } +} + +func TestInt16_AsSlice(t *testing.T) { + set := make(Int16) + set[-32768] = struct{}{} + set[-32767] = struct{}{} + set[-32766] = struct{}{} + set[-32765] = struct{}{} + set[-32764] = struct{}{} + + slice := set.AsSlice() + if len(slice) != len(set) { + t.Fatalf("length mismatch: expected %d, got %d", len(set), len(slice)) + } + + found := make(map[int16]bool) + for _, v := range slice { + found[v] = true + } + + for k := range set { + if !found[k] { + t.Fatalf("missing key in slice: %v", k) + } + } +} + +func TestInt16_FromSlice(t *testing.T) { + slice := []int16{-32768, -32767, -32766, -32765, -32764} + set := Int16FromSlice(slice) + + if len(set) != len(slice) { + t.Fatalf("length mismatch: expected %d, got %d", len(slice), len(set)) + } + + for _, v := range slice { + if _, ok := set[v]; !ok { + t.Fatalf("missing key: %v", v) + } + } +} + +func TestInt16_NilHandling(t *testing.T) { + var nilSet Int16 + + // Test nil encoding + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + err := nilSet.EncodeMsg(writer) + if err != nil { + t.Fatalf("EncodeMsg failed for nil: %v", err) + } + writer.Flush() + + // Test nil decoding + reader := msgp.NewReader(&buf) + var decoded Int16 + err = decoded.DecodeMsg(reader) + if err != nil { + t.Fatalf("DecodeMsg failed for nil: %v", err) + } + + if decoded != nil { + t.Fatal("expected nil, got non-nil") + } + + // Test nil marshaling + data, err := nilSet.MarshalMsg(nil) + if err != nil { + t.Fatalf("MarshalMsg failed for nil: %v", err) + } + + // Test nil unmarshaling + var unmarshaled Int16 + _, err = unmarshaled.UnmarshalMsg(data) + if err != nil { + t.Fatalf("UnmarshalMsg failed for nil: %v", err) + } + + if unmarshaled != nil { + t.Fatal("expected nil, got non-nil") + } + + // Test AsSlice on nil + slice := nilSet.AsSlice() + if slice != nil { + t.Fatal("expected nil slice, got non-nil") + } + + // Test FromSlice with nil + fromNilSlice := Int16FromSlice(nil) + if fromNilSlice != nil { + t.Fatal("expected nil from nil slice, got non-nil") + } +} + +func TestInt16_EmptySet(t *testing.T) { + set := make(Int16) + + // Test empty set encoding + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + err := set.EncodeMsg(writer) + if err != nil { + t.Fatalf("EncodeMsg failed for empty: %v", err) + } + writer.Flush() + + // Test empty set decoding + reader := msgp.NewReader(&buf) + var decoded Int16 + err = decoded.DecodeMsg(reader) + if err != nil { + t.Fatalf("DecodeMsg failed for empty: %v", err) + } + + if len(decoded) != 0 { + t.Fatalf("expected empty set, got length %d", len(decoded)) + } + + // Test empty set marshaling + data, err := set.MarshalMsg(nil) + if err != nil { + t.Fatalf("MarshalMsg failed for empty: %v", err) + } + + // Test empty set unmarshaling + var unmarshaled Int16 + _, err = unmarshaled.UnmarshalMsg(data) + if err != nil { + t.Fatalf("UnmarshalMsg failed for empty: %v", err) + } + + if len(unmarshaled) != 0 { + t.Fatalf("expected empty set, got length %d", len(unmarshaled)) + } +} + +func TestInt16Sorted_RoundTrip(t *testing.T) { + set := make(Int16Sorted) + set[-32768] = struct{}{} + set[-32767] = struct{}{} + set[-32766] = struct{}{} + set[-32765] = struct{}{} + set[-32764] = struct{}{} + + // Test EncodeMsg/DecodeMsg + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + err := set.EncodeMsg(writer) + if err != nil { + t.Fatalf("EncodeMsg failed: %v", err) + } + writer.Flush() + + reader := msgp.NewReader(&buf) + var decoded Int16Sorted + err = decoded.DecodeMsg(reader) + if err != nil { + t.Fatalf("DecodeMsg failed: %v", err) + } + + if len(set) != len(decoded) { + t.Fatalf("length mismatch: expected %d, got %d", len(set), len(decoded)) + } + + for k := range set { + if _, ok := decoded[k]; !ok { + t.Fatalf("missing key: %v", k) + } + } + + // Test MarshalMsg/UnmarshalMsg + data, err := set.MarshalMsg(nil) + if err != nil { + t.Fatalf("MarshalMsg failed: %v", err) + } + + var unmarshaled Int16Sorted + _, err = unmarshaled.UnmarshalMsg(data) + if err != nil { + t.Fatalf("UnmarshalMsg failed: %v", err) + } + + if len(set) != len(unmarshaled) { + t.Fatalf("length mismatch: expected %d, got %d", len(set), len(unmarshaled)) + } + + for k := range set { + if _, ok := unmarshaled[k]; !ok { + t.Fatalf("missing key: %v", k) + } + } +} + +func TestInt16Sorted_AsSlice(t *testing.T) { + set := make(Int16Sorted) + set[-32768] = struct{}{} + set[-32767] = struct{}{} + set[-32766] = struct{}{} + set[-32765] = struct{}{} + set[-32764] = struct{}{} + + slice := set.AsSlice() + if len(slice) != len(set) { + t.Fatalf("length mismatch: expected %d, got %d", len(set), len(slice)) + } + + found := make(map[int16]bool) + for _, v := range slice { + found[v] = true + } + + for k := range set { + if !found[k] { + t.Fatalf("missing key in slice: %v", k) + } + } +} + +func TestInt16Sorted_FromSlice(t *testing.T) { + slice := []int16{-32768, -32767, -32766, -32765, -32764} + set := Int16SortedFromSlice(slice) + + if len(set) != len(slice) { + t.Fatalf("length mismatch: expected %d, got %d", len(slice), len(set)) + } + + for _, v := range slice { + if _, ok := set[v]; !ok { + t.Fatalf("missing key: %v", v) + } + } +} + +func TestInt16Sorted_NilHandling(t *testing.T) { + var nilSet Int16Sorted + + // Test nil encoding + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + err := nilSet.EncodeMsg(writer) + if err != nil { + t.Fatalf("EncodeMsg failed for nil: %v", err) + } + writer.Flush() + + // Test nil decoding + reader := msgp.NewReader(&buf) + var decoded Int16Sorted + err = decoded.DecodeMsg(reader) + if err != nil { + t.Fatalf("DecodeMsg failed for nil: %v", err) + } + + if decoded != nil { + t.Fatal("expected nil, got non-nil") + } + + // Test nil marshaling + data, err := nilSet.MarshalMsg(nil) + if err != nil { + t.Fatalf("MarshalMsg failed for nil: %v", err) + } + + // Test nil unmarshaling + var unmarshaled Int16Sorted + _, err = unmarshaled.UnmarshalMsg(data) + if err != nil { + t.Fatalf("UnmarshalMsg failed for nil: %v", err) + } + + if unmarshaled != nil { + t.Fatal("expected nil, got non-nil") + } + + // Test AsSlice on nil + slice := nilSet.AsSlice() + if slice != nil { + t.Fatal("expected nil slice, got non-nil") + } + + // Test FromSlice with nil + fromNilSlice := Int16SortedFromSlice(nil) + if fromNilSlice != nil { + t.Fatal("expected nil from nil slice, got non-nil") + } +} + +func TestInt16Sorted_EmptySet(t *testing.T) { + set := make(Int16Sorted) + + // Test empty set encoding + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + err := set.EncodeMsg(writer) + if err != nil { + t.Fatalf("EncodeMsg failed for empty: %v", err) + } + writer.Flush() + + // Test empty set decoding + reader := msgp.NewReader(&buf) + var decoded Int16Sorted + err = decoded.DecodeMsg(reader) + if err != nil { + t.Fatalf("DecodeMsg failed for empty: %v", err) + } + + if len(decoded) != 0 { + t.Fatalf("expected empty set, got length %d", len(decoded)) + } + + // Test empty set marshaling + data, err := set.MarshalMsg(nil) + if err != nil { + t.Fatalf("MarshalMsg failed for empty: %v", err) + } + + // Test empty set unmarshaling + var unmarshaled Int16Sorted + _, err = unmarshaled.UnmarshalMsg(data) + if err != nil { + t.Fatalf("UnmarshalMsg failed for empty: %v", err) + } + + if len(unmarshaled) != 0 { + t.Fatalf("expected empty set, got length %d", len(unmarshaled)) + } +} + +func BenchmarkInt16_EncodeMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Int16) + for i := 0; i < size; i++ { + set[int16((i%65536)-32768)] = struct{}{} + } + + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + buf.Reset() + writer.Reset(&buf) + set.EncodeMsg(writer) + writer.Flush() + } + }) + } +} + +func BenchmarkInt16_DecodeMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Int16) + for i := 0; i < size; i++ { + set[int16((i%65536)-32768)] = struct{}{} + } + + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + set.EncodeMsg(writer) + writer.Flush() + encoded := buf.Bytes() + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + reader := msgp.NewReader(bytes.NewReader(encoded)) + var decoded Int16 + decoded.DecodeMsg(reader) + } + }) + } +} + +func BenchmarkInt16_MarshalMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Int16) + for i := 0; i < size; i++ { + set[int16((i%65536)-32768)] = struct{}{} + } + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + _, err := set.MarshalMsg(nil) + if err != nil { + b.Fatal(err) + } + } + }) + } +} + +func BenchmarkInt16_UnmarshalMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Int16) + for i := 0; i < size; i++ { + set[int16((i%65536)-32768)] = struct{}{} + } + + data, _ := set.MarshalMsg(nil) + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + var decoded Int16 + _, err := decoded.UnmarshalMsg(data) + if err != nil { + b.Fatal(err) + } + } + }) + } +} + +func BenchmarkInt16_AsSlice(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Int16) + for i := 0; i < size; i++ { + set[int16((i%65536)-32768)] = struct{}{} + } + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + _ = set.AsSlice() + } + }) + } +} + +func BenchmarkInt16_FromSlice(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + slice := make([]int16, size) + for i := 0; i < size; i++ { + slice[i] = int16((i % 65536) - 32768) + } + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + _ = Int16FromSlice(slice) + } + }) + } +} + +func BenchmarkInt16Sorted_EncodeMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Int16Sorted) + for i := 0; i < size; i++ { + set[int16((i%65536)-32768)] = struct{}{} + } + + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + buf.Reset() + writer.Reset(&buf) + set.EncodeMsg(writer) + writer.Flush() + } + }) + } +} + +func BenchmarkInt16Sorted_DecodeMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Int16Sorted) + for i := 0; i < size; i++ { + set[int16((i%65536)-32768)] = struct{}{} + } + + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + set.EncodeMsg(writer) + writer.Flush() + encoded := buf.Bytes() + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + reader := msgp.NewReader(bytes.NewReader(encoded)) + var decoded Int16Sorted + decoded.DecodeMsg(reader) + } + }) + } +} + +func BenchmarkInt16Sorted_MarshalMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Int16Sorted) + for i := 0; i < size; i++ { + set[int16((i%65536)-32768)] = struct{}{} + } + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + _, err := set.MarshalMsg(nil) + if err != nil { + b.Fatal(err) + } + } + }) + } +} + +func BenchmarkInt16Sorted_UnmarshalMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Int16Sorted) + for i := 0; i < size; i++ { + set[int16((i%65536)-32768)] = struct{}{} + } + + data, _ := set.MarshalMsg(nil) + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + var decoded Int16Sorted + _, err := decoded.UnmarshalMsg(data) + if err != nil { + b.Fatal(err) + } + } + }) + } +} + +func BenchmarkInt16Sorted_AsSlice(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Int16Sorted) + for i := 0; i < size; i++ { + set[int16((i%65536)-32768)] = struct{}{} + } + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + _ = set.AsSlice() + } + }) + } +} + +func BenchmarkInt16Sorted_FromSlice(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + slice := make([]int16, size) + for i := 0; i < size; i++ { + slice[i] = int16((i % 65536) - 32768) + } + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + _ = Int16SortedFromSlice(slice) + } + }) + } +} + +func TestUint16_RoundTrip(t *testing.T) { + set := make(Uint16) + set[0] = struct{}{} + set[1] = struct{}{} + set[2] = struct{}{} + set[3] = struct{}{} + set[4] = struct{}{} + + // Test EncodeMsg/DecodeMsg + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + err := set.EncodeMsg(writer) + if err != nil { + t.Fatalf("EncodeMsg failed: %v", err) + } + writer.Flush() + + reader := msgp.NewReader(&buf) + var decoded Uint16 + err = decoded.DecodeMsg(reader) + if err != nil { + t.Fatalf("DecodeMsg failed: %v", err) + } + + if len(set) != len(decoded) { + t.Fatalf("length mismatch: expected %d, got %d", len(set), len(decoded)) + } + + for k := range set { + if _, ok := decoded[k]; !ok { + t.Fatalf("missing key: %v", k) + } + } + + // Test MarshalMsg/UnmarshalMsg + data, err := set.MarshalMsg(nil) + if err != nil { + t.Fatalf("MarshalMsg failed: %v", err) + } + + var unmarshaled Uint16 + _, err = unmarshaled.UnmarshalMsg(data) + if err != nil { + t.Fatalf("UnmarshalMsg failed: %v", err) + } + + if len(set) != len(unmarshaled) { + t.Fatalf("length mismatch: expected %d, got %d", len(set), len(unmarshaled)) + } + + for k := range set { + if _, ok := unmarshaled[k]; !ok { + t.Fatalf("missing key: %v", k) + } + } +} + +func TestUint16_AsSlice(t *testing.T) { + set := make(Uint16) + set[0] = struct{}{} + set[1] = struct{}{} + set[2] = struct{}{} + set[3] = struct{}{} + set[4] = struct{}{} + + slice := set.AsSlice() + if len(slice) != len(set) { + t.Fatalf("length mismatch: expected %d, got %d", len(set), len(slice)) + } + + found := make(map[uint16]bool) + for _, v := range slice { + found[v] = true + } + + for k := range set { + if !found[k] { + t.Fatalf("missing key in slice: %v", k) + } + } +} + +func TestUint16_FromSlice(t *testing.T) { + slice := []uint16{0, 1, 2, 3, 4} + set := Uint16FromSlice(slice) + + if len(set) != len(slice) { + t.Fatalf("length mismatch: expected %d, got %d", len(slice), len(set)) + } + + for _, v := range slice { + if _, ok := set[v]; !ok { + t.Fatalf("missing key: %v", v) + } + } +} + +func TestUint16_NilHandling(t *testing.T) { + var nilSet Uint16 + + // Test nil encoding + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + err := nilSet.EncodeMsg(writer) + if err != nil { + t.Fatalf("EncodeMsg failed for nil: %v", err) + } + writer.Flush() + + // Test nil decoding + reader := msgp.NewReader(&buf) + var decoded Uint16 + err = decoded.DecodeMsg(reader) + if err != nil { + t.Fatalf("DecodeMsg failed for nil: %v", err) + } + + if decoded != nil { + t.Fatal("expected nil, got non-nil") + } + + // Test nil marshaling + data, err := nilSet.MarshalMsg(nil) + if err != nil { + t.Fatalf("MarshalMsg failed for nil: %v", err) + } + + // Test nil unmarshaling + var unmarshaled Uint16 + _, err = unmarshaled.UnmarshalMsg(data) + if err != nil { + t.Fatalf("UnmarshalMsg failed for nil: %v", err) + } + + if unmarshaled != nil { + t.Fatal("expected nil, got non-nil") + } + + // Test AsSlice on nil + slice := nilSet.AsSlice() + if slice != nil { + t.Fatal("expected nil slice, got non-nil") + } + + // Test FromSlice with nil + fromNilSlice := Uint16FromSlice(nil) + if fromNilSlice != nil { + t.Fatal("expected nil from nil slice, got non-nil") + } +} + +func TestUint16_EmptySet(t *testing.T) { + set := make(Uint16) + + // Test empty set encoding + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + err := set.EncodeMsg(writer) + if err != nil { + t.Fatalf("EncodeMsg failed for empty: %v", err) + } + writer.Flush() + + // Test empty set decoding + reader := msgp.NewReader(&buf) + var decoded Uint16 + err = decoded.DecodeMsg(reader) + if err != nil { + t.Fatalf("DecodeMsg failed for empty: %v", err) + } + + if len(decoded) != 0 { + t.Fatalf("expected empty set, got length %d", len(decoded)) + } + + // Test empty set marshaling + data, err := set.MarshalMsg(nil) + if err != nil { + t.Fatalf("MarshalMsg failed for empty: %v", err) + } + + // Test empty set unmarshaling + var unmarshaled Uint16 + _, err = unmarshaled.UnmarshalMsg(data) + if err != nil { + t.Fatalf("UnmarshalMsg failed for empty: %v", err) + } + + if len(unmarshaled) != 0 { + t.Fatalf("expected empty set, got length %d", len(unmarshaled)) + } +} + +func TestUint16Sorted_RoundTrip(t *testing.T) { + set := make(Uint16Sorted) + set[0] = struct{}{} + set[1] = struct{}{} + set[2] = struct{}{} + set[3] = struct{}{} + set[4] = struct{}{} + + // Test EncodeMsg/DecodeMsg + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + err := set.EncodeMsg(writer) + if err != nil { + t.Fatalf("EncodeMsg failed: %v", err) + } + writer.Flush() + + reader := msgp.NewReader(&buf) + var decoded Uint16Sorted + err = decoded.DecodeMsg(reader) + if err != nil { + t.Fatalf("DecodeMsg failed: %v", err) + } + + if len(set) != len(decoded) { + t.Fatalf("length mismatch: expected %d, got %d", len(set), len(decoded)) + } + + for k := range set { + if _, ok := decoded[k]; !ok { + t.Fatalf("missing key: %v", k) + } + } + + // Test MarshalMsg/UnmarshalMsg + data, err := set.MarshalMsg(nil) + if err != nil { + t.Fatalf("MarshalMsg failed: %v", err) + } + + var unmarshaled Uint16Sorted + _, err = unmarshaled.UnmarshalMsg(data) + if err != nil { + t.Fatalf("UnmarshalMsg failed: %v", err) + } + + if len(set) != len(unmarshaled) { + t.Fatalf("length mismatch: expected %d, got %d", len(set), len(unmarshaled)) + } + + for k := range set { + if _, ok := unmarshaled[k]; !ok { + t.Fatalf("missing key: %v", k) + } + } +} + +func TestUint16Sorted_AsSlice(t *testing.T) { + set := make(Uint16Sorted) + set[0] = struct{}{} + set[1] = struct{}{} + set[2] = struct{}{} + set[3] = struct{}{} + set[4] = struct{}{} + + slice := set.AsSlice() + if len(slice) != len(set) { + t.Fatalf("length mismatch: expected %d, got %d", len(set), len(slice)) + } + + found := make(map[uint16]bool) + for _, v := range slice { + found[v] = true + } + + for k := range set { + if !found[k] { + t.Fatalf("missing key in slice: %v", k) + } + } +} + +func TestUint16Sorted_FromSlice(t *testing.T) { + slice := []uint16{0, 1, 2, 3, 4} + set := Uint16SortedFromSlice(slice) + + if len(set) != len(slice) { + t.Fatalf("length mismatch: expected %d, got %d", len(slice), len(set)) + } + + for _, v := range slice { + if _, ok := set[v]; !ok { + t.Fatalf("missing key: %v", v) + } + } +} + +func TestUint16Sorted_NilHandling(t *testing.T) { + var nilSet Uint16Sorted + + // Test nil encoding + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + err := nilSet.EncodeMsg(writer) + if err != nil { + t.Fatalf("EncodeMsg failed for nil: %v", err) + } + writer.Flush() + + // Test nil decoding + reader := msgp.NewReader(&buf) + var decoded Uint16Sorted + err = decoded.DecodeMsg(reader) + if err != nil { + t.Fatalf("DecodeMsg failed for nil: %v", err) + } + + if decoded != nil { + t.Fatal("expected nil, got non-nil") + } + + // Test nil marshaling + data, err := nilSet.MarshalMsg(nil) + if err != nil { + t.Fatalf("MarshalMsg failed for nil: %v", err) + } + + // Test nil unmarshaling + var unmarshaled Uint16Sorted + _, err = unmarshaled.UnmarshalMsg(data) + if err != nil { + t.Fatalf("UnmarshalMsg failed for nil: %v", err) + } + + if unmarshaled != nil { + t.Fatal("expected nil, got non-nil") + } + + // Test AsSlice on nil + slice := nilSet.AsSlice() + if slice != nil { + t.Fatal("expected nil slice, got non-nil") + } + + // Test FromSlice with nil + fromNilSlice := Uint16SortedFromSlice(nil) + if fromNilSlice != nil { + t.Fatal("expected nil from nil slice, got non-nil") + } +} + +func TestUint16Sorted_EmptySet(t *testing.T) { + set := make(Uint16Sorted) + + // Test empty set encoding + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + err := set.EncodeMsg(writer) + if err != nil { + t.Fatalf("EncodeMsg failed for empty: %v", err) + } + writer.Flush() + + // Test empty set decoding + reader := msgp.NewReader(&buf) + var decoded Uint16Sorted + err = decoded.DecodeMsg(reader) + if err != nil { + t.Fatalf("DecodeMsg failed for empty: %v", err) + } + + if len(decoded) != 0 { + t.Fatalf("expected empty set, got length %d", len(decoded)) + } + + // Test empty set marshaling + data, err := set.MarshalMsg(nil) + if err != nil { + t.Fatalf("MarshalMsg failed for empty: %v", err) + } + + // Test empty set unmarshaling + var unmarshaled Uint16Sorted + _, err = unmarshaled.UnmarshalMsg(data) + if err != nil { + t.Fatalf("UnmarshalMsg failed for empty: %v", err) + } + + if len(unmarshaled) != 0 { + t.Fatalf("expected empty set, got length %d", len(unmarshaled)) + } +} + +func BenchmarkUint16_EncodeMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Uint16) + for i := 0; i < size; i++ { + set[uint16(i%65536)] = struct{}{} + } + + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + buf.Reset() + writer.Reset(&buf) + set.EncodeMsg(writer) + writer.Flush() + } + }) + } +} + +func BenchmarkUint16_DecodeMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Uint16) + for i := 0; i < size; i++ { + set[uint16(i%65536)] = struct{}{} + } + + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + set.EncodeMsg(writer) + writer.Flush() + encoded := buf.Bytes() + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + reader := msgp.NewReader(bytes.NewReader(encoded)) + var decoded Uint16 + decoded.DecodeMsg(reader) + } + }) + } +} + +func BenchmarkUint16_MarshalMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Uint16) + for i := 0; i < size; i++ { + set[uint16(i%65536)] = struct{}{} + } + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + _, err := set.MarshalMsg(nil) + if err != nil { + b.Fatal(err) + } + } + }) + } +} + +func BenchmarkUint16_UnmarshalMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Uint16) + for i := 0; i < size; i++ { + set[uint16(i%65536)] = struct{}{} + } + + data, _ := set.MarshalMsg(nil) + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + var decoded Uint16 + _, err := decoded.UnmarshalMsg(data) + if err != nil { + b.Fatal(err) + } + } + }) + } +} + +func BenchmarkUint16_AsSlice(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Uint16) + for i := 0; i < size; i++ { + set[uint16(i%65536)] = struct{}{} + } + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + _ = set.AsSlice() + } + }) + } +} + +func BenchmarkUint16_FromSlice(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + slice := make([]uint16, size) + for i := 0; i < size; i++ { + slice[i] = uint16(i % 65536) + } + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + _ = Uint16FromSlice(slice) + } + }) + } +} + +func BenchmarkUint16Sorted_EncodeMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Uint16Sorted) + for i := 0; i < size; i++ { + set[uint16(i%65536)] = struct{}{} + } + + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + buf.Reset() + writer.Reset(&buf) + set.EncodeMsg(writer) + writer.Flush() + } + }) + } +} + +func BenchmarkUint16Sorted_DecodeMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Uint16Sorted) + for i := 0; i < size; i++ { + set[uint16(i%65536)] = struct{}{} + } + + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + set.EncodeMsg(writer) + writer.Flush() + encoded := buf.Bytes() + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + reader := msgp.NewReader(bytes.NewReader(encoded)) + var decoded Uint16Sorted + decoded.DecodeMsg(reader) + } + }) + } +} + +func BenchmarkUint16Sorted_MarshalMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Uint16Sorted) + for i := 0; i < size; i++ { + set[uint16(i%65536)] = struct{}{} + } + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + _, err := set.MarshalMsg(nil) + if err != nil { + b.Fatal(err) + } + } + }) + } +} + +func BenchmarkUint16Sorted_UnmarshalMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Uint16Sorted) + for i := 0; i < size; i++ { + set[uint16(i%65536)] = struct{}{} + } + + data, _ := set.MarshalMsg(nil) + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + var decoded Uint16Sorted + _, err := decoded.UnmarshalMsg(data) + if err != nil { + b.Fatal(err) + } + } + }) + } +} + +func BenchmarkUint16Sorted_AsSlice(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Uint16Sorted) + for i := 0; i < size; i++ { + set[uint16(i%65536)] = struct{}{} + } + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + _ = set.AsSlice() + } + }) + } +} + +func BenchmarkUint16Sorted_FromSlice(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + slice := make([]uint16, size) + for i := 0; i < size; i++ { + slice[i] = uint16(i % 65536) + } + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + _ = Uint16SortedFromSlice(slice) + } + }) + } +} + +func TestInt32_RoundTrip(t *testing.T) { + set := make(Int32) + set[0] = struct{}{} + set[1] = struct{}{} + set[2] = struct{}{} + set[3] = struct{}{} + set[4] = struct{}{} + + // Test EncodeMsg/DecodeMsg + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + err := set.EncodeMsg(writer) + if err != nil { + t.Fatalf("EncodeMsg failed: %v", err) + } + writer.Flush() + + reader := msgp.NewReader(&buf) + var decoded Int32 + err = decoded.DecodeMsg(reader) + if err != nil { + t.Fatalf("DecodeMsg failed: %v", err) + } + + if len(set) != len(decoded) { + t.Fatalf("length mismatch: expected %d, got %d", len(set), len(decoded)) + } + + for k := range set { + if _, ok := decoded[k]; !ok { + t.Fatalf("missing key: %v", k) + } + } + + // Test MarshalMsg/UnmarshalMsg + data, err := set.MarshalMsg(nil) + if err != nil { + t.Fatalf("MarshalMsg failed: %v", err) + } + + var unmarshaled Int32 + _, err = unmarshaled.UnmarshalMsg(data) + if err != nil { + t.Fatalf("UnmarshalMsg failed: %v", err) + } + + if len(set) != len(unmarshaled) { + t.Fatalf("length mismatch: expected %d, got %d", len(set), len(unmarshaled)) + } + + for k := range set { + if _, ok := unmarshaled[k]; !ok { + t.Fatalf("missing key: %v", k) + } + } +} + +func TestInt32_AsSlice(t *testing.T) { + set := make(Int32) + set[0] = struct{}{} + set[1] = struct{}{} + set[2] = struct{}{} + set[3] = struct{}{} + set[4] = struct{}{} + + slice := set.AsSlice() + if len(slice) != len(set) { + t.Fatalf("length mismatch: expected %d, got %d", len(set), len(slice)) + } + + found := make(map[int32]bool) + for _, v := range slice { + found[v] = true + } + + for k := range set { + if !found[k] { + t.Fatalf("missing key in slice: %v", k) + } + } +} + +func TestInt32_FromSlice(t *testing.T) { + slice := []int32{0, 1, 2, 3, 4} + set := Int32FromSlice(slice) + + if len(set) != len(slice) { + t.Fatalf("length mismatch: expected %d, got %d", len(slice), len(set)) + } + + for _, v := range slice { + if _, ok := set[v]; !ok { + t.Fatalf("missing key: %v", v) + } + } +} + +func TestInt32_NilHandling(t *testing.T) { + var nilSet Int32 + + // Test nil encoding + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + err := nilSet.EncodeMsg(writer) + if err != nil { + t.Fatalf("EncodeMsg failed for nil: %v", err) + } + writer.Flush() + + // Test nil decoding + reader := msgp.NewReader(&buf) + var decoded Int32 + err = decoded.DecodeMsg(reader) + if err != nil { + t.Fatalf("DecodeMsg failed for nil: %v", err) + } + + if decoded != nil { + t.Fatal("expected nil, got non-nil") + } + + // Test nil marshaling + data, err := nilSet.MarshalMsg(nil) + if err != nil { + t.Fatalf("MarshalMsg failed for nil: %v", err) + } + + // Test nil unmarshaling + var unmarshaled Int32 + _, err = unmarshaled.UnmarshalMsg(data) + if err != nil { + t.Fatalf("UnmarshalMsg failed for nil: %v", err) + } + + if unmarshaled != nil { + t.Fatal("expected nil, got non-nil") + } + + // Test AsSlice on nil + slice := nilSet.AsSlice() + if slice != nil { + t.Fatal("expected nil slice, got non-nil") + } + + // Test FromSlice with nil + fromNilSlice := Int32FromSlice(nil) + if fromNilSlice != nil { + t.Fatal("expected nil from nil slice, got non-nil") + } +} + +func TestInt32_EmptySet(t *testing.T) { + set := make(Int32) + + // Test empty set encoding + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + err := set.EncodeMsg(writer) + if err != nil { + t.Fatalf("EncodeMsg failed for empty: %v", err) + } + writer.Flush() + + // Test empty set decoding + reader := msgp.NewReader(&buf) + var decoded Int32 + err = decoded.DecodeMsg(reader) + if err != nil { + t.Fatalf("DecodeMsg failed for empty: %v", err) + } + + if len(decoded) != 0 { + t.Fatalf("expected empty set, got length %d", len(decoded)) + } + + // Test empty set marshaling + data, err := set.MarshalMsg(nil) + if err != nil { + t.Fatalf("MarshalMsg failed for empty: %v", err) + } + + // Test empty set unmarshaling + var unmarshaled Int32 + _, err = unmarshaled.UnmarshalMsg(data) + if err != nil { + t.Fatalf("UnmarshalMsg failed for empty: %v", err) + } + + if len(unmarshaled) != 0 { + t.Fatalf("expected empty set, got length %d", len(unmarshaled)) + } +} + +func TestInt32Sorted_RoundTrip(t *testing.T) { + set := make(Int32Sorted) + set[0] = struct{}{} + set[1] = struct{}{} + set[2] = struct{}{} + set[3] = struct{}{} + set[4] = struct{}{} + + // Test EncodeMsg/DecodeMsg + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + err := set.EncodeMsg(writer) + if err != nil { + t.Fatalf("EncodeMsg failed: %v", err) + } + writer.Flush() + + reader := msgp.NewReader(&buf) + var decoded Int32Sorted + err = decoded.DecodeMsg(reader) + if err != nil { + t.Fatalf("DecodeMsg failed: %v", err) + } + + if len(set) != len(decoded) { + t.Fatalf("length mismatch: expected %d, got %d", len(set), len(decoded)) + } + + for k := range set { + if _, ok := decoded[k]; !ok { + t.Fatalf("missing key: %v", k) + } + } + + // Test MarshalMsg/UnmarshalMsg + data, err := set.MarshalMsg(nil) + if err != nil { + t.Fatalf("MarshalMsg failed: %v", err) + } + + var unmarshaled Int32Sorted + _, err = unmarshaled.UnmarshalMsg(data) + if err != nil { + t.Fatalf("UnmarshalMsg failed: %v", err) + } + + if len(set) != len(unmarshaled) { + t.Fatalf("length mismatch: expected %d, got %d", len(set), len(unmarshaled)) + } + + for k := range set { + if _, ok := unmarshaled[k]; !ok { + t.Fatalf("missing key: %v", k) + } + } +} + +func TestInt32Sorted_AsSlice(t *testing.T) { + set := make(Int32Sorted) + set[0] = struct{}{} + set[1] = struct{}{} + set[2] = struct{}{} + set[3] = struct{}{} + set[4] = struct{}{} + + slice := set.AsSlice() + if len(slice) != len(set) { + t.Fatalf("length mismatch: expected %d, got %d", len(set), len(slice)) + } + + found := make(map[int32]bool) + for _, v := range slice { + found[v] = true + } + + for k := range set { + if !found[k] { + t.Fatalf("missing key in slice: %v", k) + } + } +} + +func TestInt32Sorted_FromSlice(t *testing.T) { + slice := []int32{0, 1, 2, 3, 4} + set := Int32SortedFromSlice(slice) + + if len(set) != len(slice) { + t.Fatalf("length mismatch: expected %d, got %d", len(slice), len(set)) + } + + for _, v := range slice { + if _, ok := set[v]; !ok { + t.Fatalf("missing key: %v", v) + } + } +} + +func TestInt32Sorted_NilHandling(t *testing.T) { + var nilSet Int32Sorted + + // Test nil encoding + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + err := nilSet.EncodeMsg(writer) + if err != nil { + t.Fatalf("EncodeMsg failed for nil: %v", err) + } + writer.Flush() + + // Test nil decoding + reader := msgp.NewReader(&buf) + var decoded Int32Sorted + err = decoded.DecodeMsg(reader) + if err != nil { + t.Fatalf("DecodeMsg failed for nil: %v", err) + } + + if decoded != nil { + t.Fatal("expected nil, got non-nil") + } + + // Test nil marshaling + data, err := nilSet.MarshalMsg(nil) + if err != nil { + t.Fatalf("MarshalMsg failed for nil: %v", err) + } + + // Test nil unmarshaling + var unmarshaled Int32Sorted + _, err = unmarshaled.UnmarshalMsg(data) + if err != nil { + t.Fatalf("UnmarshalMsg failed for nil: %v", err) + } + + if unmarshaled != nil { + t.Fatal("expected nil, got non-nil") + } + + // Test AsSlice on nil + slice := nilSet.AsSlice() + if slice != nil { + t.Fatal("expected nil slice, got non-nil") + } + + // Test FromSlice with nil + fromNilSlice := Int32SortedFromSlice(nil) + if fromNilSlice != nil { + t.Fatal("expected nil from nil slice, got non-nil") + } +} + +func TestInt32Sorted_EmptySet(t *testing.T) { + set := make(Int32Sorted) + + // Test empty set encoding + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + err := set.EncodeMsg(writer) + if err != nil { + t.Fatalf("EncodeMsg failed for empty: %v", err) + } + writer.Flush() + + // Test empty set decoding + reader := msgp.NewReader(&buf) + var decoded Int32Sorted + err = decoded.DecodeMsg(reader) + if err != nil { + t.Fatalf("DecodeMsg failed for empty: %v", err) + } + + if len(decoded) != 0 { + t.Fatalf("expected empty set, got length %d", len(decoded)) + } + + // Test empty set marshaling + data, err := set.MarshalMsg(nil) + if err != nil { + t.Fatalf("MarshalMsg failed for empty: %v", err) + } + + // Test empty set unmarshaling + var unmarshaled Int32Sorted + _, err = unmarshaled.UnmarshalMsg(data) + if err != nil { + t.Fatalf("UnmarshalMsg failed for empty: %v", err) + } + + if len(unmarshaled) != 0 { + t.Fatalf("expected empty set, got length %d", len(unmarshaled)) + } +} + +func BenchmarkInt32_EncodeMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Int32) + for i := 0; i < size; i++ { + set[int32(i)] = struct{}{} + } + + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + buf.Reset() + writer.Reset(&buf) + set.EncodeMsg(writer) + writer.Flush() + } + }) + } +} + +func BenchmarkInt32_DecodeMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Int32) + for i := 0; i < size; i++ { + set[int32(i)] = struct{}{} + } + + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + set.EncodeMsg(writer) + writer.Flush() + encoded := buf.Bytes() + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + reader := msgp.NewReader(bytes.NewReader(encoded)) + var decoded Int32 + decoded.DecodeMsg(reader) + } + }) + } +} + +func BenchmarkInt32_MarshalMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Int32) + for i := 0; i < size; i++ { + set[int32(i)] = struct{}{} + } + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + _, err := set.MarshalMsg(nil) + if err != nil { + b.Fatal(err) + } + } + }) + } +} + +func BenchmarkInt32_UnmarshalMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Int32) + for i := 0; i < size; i++ { + set[int32(i)] = struct{}{} + } + + data, _ := set.MarshalMsg(nil) + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + var decoded Int32 + _, err := decoded.UnmarshalMsg(data) + if err != nil { + b.Fatal(err) + } + } + }) + } +} + +func BenchmarkInt32_AsSlice(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Int32) + for i := 0; i < size; i++ { + set[int32(i)] = struct{}{} + } + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + _ = set.AsSlice() + } + }) + } +} + +func BenchmarkInt32_FromSlice(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + slice := make([]int32, size) + for i := 0; i < size; i++ { + slice[i] = int32(i) + } + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + _ = Int32FromSlice(slice) + } + }) + } +} + +func BenchmarkInt32Sorted_EncodeMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Int32Sorted) + for i := 0; i < size; i++ { + set[int32(i)] = struct{}{} + } + + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + buf.Reset() + writer.Reset(&buf) + set.EncodeMsg(writer) + writer.Flush() + } + }) + } +} + +func BenchmarkInt32Sorted_DecodeMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Int32Sorted) + for i := 0; i < size; i++ { + set[int32(i)] = struct{}{} + } + + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + set.EncodeMsg(writer) + writer.Flush() + encoded := buf.Bytes() + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + reader := msgp.NewReader(bytes.NewReader(encoded)) + var decoded Int32Sorted + decoded.DecodeMsg(reader) + } + }) + } +} + +func BenchmarkInt32Sorted_MarshalMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Int32Sorted) + for i := 0; i < size; i++ { + set[int32(i)] = struct{}{} + } + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + _, err := set.MarshalMsg(nil) + if err != nil { + b.Fatal(err) + } + } + }) + } +} + +func BenchmarkInt32Sorted_UnmarshalMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Int32Sorted) + for i := 0; i < size; i++ { + set[int32(i)] = struct{}{} + } + + data, _ := set.MarshalMsg(nil) + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + var decoded Int32Sorted + _, err := decoded.UnmarshalMsg(data) + if err != nil { + b.Fatal(err) + } + } + }) + } +} + +func BenchmarkInt32Sorted_AsSlice(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Int32Sorted) + for i := 0; i < size; i++ { + set[int32(i)] = struct{}{} + } + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + _ = set.AsSlice() + } + }) + } +} + +func BenchmarkInt32Sorted_FromSlice(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + slice := make([]int32, size) + for i := 0; i < size; i++ { + slice[i] = int32(i) + } + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + _ = Int32SortedFromSlice(slice) + } + }) + } +} + +func TestUint32_RoundTrip(t *testing.T) { + set := make(Uint32) + set[0] = struct{}{} + set[1] = struct{}{} + set[2] = struct{}{} + set[3] = struct{}{} + set[4] = struct{}{} + + // Test EncodeMsg/DecodeMsg + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + err := set.EncodeMsg(writer) + if err != nil { + t.Fatalf("EncodeMsg failed: %v", err) + } + writer.Flush() + + reader := msgp.NewReader(&buf) + var decoded Uint32 + err = decoded.DecodeMsg(reader) + if err != nil { + t.Fatalf("DecodeMsg failed: %v", err) + } + + if len(set) != len(decoded) { + t.Fatalf("length mismatch: expected %d, got %d", len(set), len(decoded)) + } + + for k := range set { + if _, ok := decoded[k]; !ok { + t.Fatalf("missing key: %v", k) + } + } + + // Test MarshalMsg/UnmarshalMsg + data, err := set.MarshalMsg(nil) + if err != nil { + t.Fatalf("MarshalMsg failed: %v", err) + } + + var unmarshaled Uint32 + _, err = unmarshaled.UnmarshalMsg(data) + if err != nil { + t.Fatalf("UnmarshalMsg failed: %v", err) + } + + if len(set) != len(unmarshaled) { + t.Fatalf("length mismatch: expected %d, got %d", len(set), len(unmarshaled)) + } + + for k := range set { + if _, ok := unmarshaled[k]; !ok { + t.Fatalf("missing key: %v", k) + } + } +} + +func TestUint32_AsSlice(t *testing.T) { + set := make(Uint32) + set[0] = struct{}{} + set[1] = struct{}{} + set[2] = struct{}{} + set[3] = struct{}{} + set[4] = struct{}{} + + slice := set.AsSlice() + if len(slice) != len(set) { + t.Fatalf("length mismatch: expected %d, got %d", len(set), len(slice)) + } + + found := make(map[uint32]bool) + for _, v := range slice { + found[v] = true + } + + for k := range set { + if !found[k] { + t.Fatalf("missing key in slice: %v", k) + } + } +} + +func TestUint32_FromSlice(t *testing.T) { + slice := []uint32{0, 1, 2, 3, 4} + set := Uint32FromSlice(slice) + + if len(set) != len(slice) { + t.Fatalf("length mismatch: expected %d, got %d", len(slice), len(set)) + } + + for _, v := range slice { + if _, ok := set[v]; !ok { + t.Fatalf("missing key: %v", v) + } + } +} + +func TestUint32_NilHandling(t *testing.T) { + var nilSet Uint32 + + // Test nil encoding + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + err := nilSet.EncodeMsg(writer) + if err != nil { + t.Fatalf("EncodeMsg failed for nil: %v", err) + } + writer.Flush() + + // Test nil decoding + reader := msgp.NewReader(&buf) + var decoded Uint32 + err = decoded.DecodeMsg(reader) + if err != nil { + t.Fatalf("DecodeMsg failed for nil: %v", err) + } + + if decoded != nil { + t.Fatal("expected nil, got non-nil") + } + + // Test nil marshaling + data, err := nilSet.MarshalMsg(nil) + if err != nil { + t.Fatalf("MarshalMsg failed for nil: %v", err) + } + + // Test nil unmarshaling + var unmarshaled Uint32 + _, err = unmarshaled.UnmarshalMsg(data) + if err != nil { + t.Fatalf("UnmarshalMsg failed for nil: %v", err) + } + + if unmarshaled != nil { + t.Fatal("expected nil, got non-nil") + } + + // Test AsSlice on nil + slice := nilSet.AsSlice() + if slice != nil { + t.Fatal("expected nil slice, got non-nil") + } + + // Test FromSlice with nil + fromNilSlice := Uint32FromSlice(nil) + if fromNilSlice != nil { + t.Fatal("expected nil from nil slice, got non-nil") + } +} + +func TestUint32_EmptySet(t *testing.T) { + set := make(Uint32) + + // Test empty set encoding + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + err := set.EncodeMsg(writer) + if err != nil { + t.Fatalf("EncodeMsg failed for empty: %v", err) + } + writer.Flush() + + // Test empty set decoding + reader := msgp.NewReader(&buf) + var decoded Uint32 + err = decoded.DecodeMsg(reader) + if err != nil { + t.Fatalf("DecodeMsg failed for empty: %v", err) + } + + if len(decoded) != 0 { + t.Fatalf("expected empty set, got length %d", len(decoded)) + } + + // Test empty set marshaling + data, err := set.MarshalMsg(nil) + if err != nil { + t.Fatalf("MarshalMsg failed for empty: %v", err) + } + + // Test empty set unmarshaling + var unmarshaled Uint32 + _, err = unmarshaled.UnmarshalMsg(data) + if err != nil { + t.Fatalf("UnmarshalMsg failed for empty: %v", err) + } + + if len(unmarshaled) != 0 { + t.Fatalf("expected empty set, got length %d", len(unmarshaled)) + } +} + +func TestUint32Sorted_RoundTrip(t *testing.T) { + set := make(Uint32Sorted) + set[0] = struct{}{} + set[1] = struct{}{} + set[2] = struct{}{} + set[3] = struct{}{} + set[4] = struct{}{} + + // Test EncodeMsg/DecodeMsg + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + err := set.EncodeMsg(writer) + if err != nil { + t.Fatalf("EncodeMsg failed: %v", err) + } + writer.Flush() + + reader := msgp.NewReader(&buf) + var decoded Uint32Sorted + err = decoded.DecodeMsg(reader) + if err != nil { + t.Fatalf("DecodeMsg failed: %v", err) + } + + if len(set) != len(decoded) { + t.Fatalf("length mismatch: expected %d, got %d", len(set), len(decoded)) + } + + for k := range set { + if _, ok := decoded[k]; !ok { + t.Fatalf("missing key: %v", k) + } + } + + // Test MarshalMsg/UnmarshalMsg + data, err := set.MarshalMsg(nil) + if err != nil { + t.Fatalf("MarshalMsg failed: %v", err) + } + + var unmarshaled Uint32Sorted + _, err = unmarshaled.UnmarshalMsg(data) + if err != nil { + t.Fatalf("UnmarshalMsg failed: %v", err) + } + + if len(set) != len(unmarshaled) { + t.Fatalf("length mismatch: expected %d, got %d", len(set), len(unmarshaled)) + } + + for k := range set { + if _, ok := unmarshaled[k]; !ok { + t.Fatalf("missing key: %v", k) + } + } +} + +func TestUint32Sorted_AsSlice(t *testing.T) { + set := make(Uint32Sorted) + set[0] = struct{}{} + set[1] = struct{}{} + set[2] = struct{}{} + set[3] = struct{}{} + set[4] = struct{}{} + + slice := set.AsSlice() + if len(slice) != len(set) { + t.Fatalf("length mismatch: expected %d, got %d", len(set), len(slice)) + } + + found := make(map[uint32]bool) + for _, v := range slice { + found[v] = true + } + + for k := range set { + if !found[k] { + t.Fatalf("missing key in slice: %v", k) + } + } +} + +func TestUint32Sorted_FromSlice(t *testing.T) { + slice := []uint32{0, 1, 2, 3, 4} + set := Uint32SortedFromSlice(slice) + + if len(set) != len(slice) { + t.Fatalf("length mismatch: expected %d, got %d", len(slice), len(set)) + } + + for _, v := range slice { + if _, ok := set[v]; !ok { + t.Fatalf("missing key: %v", v) + } + } +} + +func TestUint32Sorted_NilHandling(t *testing.T) { + var nilSet Uint32Sorted + + // Test nil encoding + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + err := nilSet.EncodeMsg(writer) + if err != nil { + t.Fatalf("EncodeMsg failed for nil: %v", err) + } + writer.Flush() + + // Test nil decoding + reader := msgp.NewReader(&buf) + var decoded Uint32Sorted + err = decoded.DecodeMsg(reader) + if err != nil { + t.Fatalf("DecodeMsg failed for nil: %v", err) + } + + if decoded != nil { + t.Fatal("expected nil, got non-nil") + } + + // Test nil marshaling + data, err := nilSet.MarshalMsg(nil) + if err != nil { + t.Fatalf("MarshalMsg failed for nil: %v", err) + } + + // Test nil unmarshaling + var unmarshaled Uint32Sorted + _, err = unmarshaled.UnmarshalMsg(data) + if err != nil { + t.Fatalf("UnmarshalMsg failed for nil: %v", err) + } + + if unmarshaled != nil { + t.Fatal("expected nil, got non-nil") + } + + // Test AsSlice on nil + slice := nilSet.AsSlice() + if slice != nil { + t.Fatal("expected nil slice, got non-nil") + } + + // Test FromSlice with nil + fromNilSlice := Uint32SortedFromSlice(nil) + if fromNilSlice != nil { + t.Fatal("expected nil from nil slice, got non-nil") + } +} + +func TestUint32Sorted_EmptySet(t *testing.T) { + set := make(Uint32Sorted) + + // Test empty set encoding + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + err := set.EncodeMsg(writer) + if err != nil { + t.Fatalf("EncodeMsg failed for empty: %v", err) + } + writer.Flush() + + // Test empty set decoding + reader := msgp.NewReader(&buf) + var decoded Uint32Sorted + err = decoded.DecodeMsg(reader) + if err != nil { + t.Fatalf("DecodeMsg failed for empty: %v", err) + } + + if len(decoded) != 0 { + t.Fatalf("expected empty set, got length %d", len(decoded)) + } + + // Test empty set marshaling + data, err := set.MarshalMsg(nil) + if err != nil { + t.Fatalf("MarshalMsg failed for empty: %v", err) + } + + // Test empty set unmarshaling + var unmarshaled Uint32Sorted + _, err = unmarshaled.UnmarshalMsg(data) + if err != nil { + t.Fatalf("UnmarshalMsg failed for empty: %v", err) + } + + if len(unmarshaled) != 0 { + t.Fatalf("expected empty set, got length %d", len(unmarshaled)) + } +} + +func BenchmarkUint32_EncodeMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Uint32) + for i := 0; i < size; i++ { + set[uint32(i)] = struct{}{} + } + + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + buf.Reset() + writer.Reset(&buf) + set.EncodeMsg(writer) + writer.Flush() + } + }) + } +} + +func BenchmarkUint32_DecodeMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Uint32) + for i := 0; i < size; i++ { + set[uint32(i)] = struct{}{} + } + + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + set.EncodeMsg(writer) + writer.Flush() + encoded := buf.Bytes() + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + reader := msgp.NewReader(bytes.NewReader(encoded)) + var decoded Uint32 + decoded.DecodeMsg(reader) + } + }) + } +} + +func BenchmarkUint32_MarshalMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Uint32) + for i := 0; i < size; i++ { + set[uint32(i)] = struct{}{} + } + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + _, err := set.MarshalMsg(nil) + if err != nil { + b.Fatal(err) + } + } + }) + } +} + +func BenchmarkUint32_UnmarshalMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Uint32) + for i := 0; i < size; i++ { + set[uint32(i)] = struct{}{} + } + + data, _ := set.MarshalMsg(nil) + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + var decoded Uint32 + _, err := decoded.UnmarshalMsg(data) + if err != nil { + b.Fatal(err) + } + } + }) + } +} + +func BenchmarkUint32_AsSlice(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Uint32) + for i := 0; i < size; i++ { + set[uint32(i)] = struct{}{} + } + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + _ = set.AsSlice() + } + }) + } +} + +func BenchmarkUint32_FromSlice(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + slice := make([]uint32, size) + for i := 0; i < size; i++ { + slice[i] = uint32(i) + } + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + _ = Uint32FromSlice(slice) + } + }) + } +} + +func BenchmarkUint32Sorted_EncodeMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Uint32Sorted) + for i := 0; i < size; i++ { + set[uint32(i)] = struct{}{} + } + + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + buf.Reset() + writer.Reset(&buf) + set.EncodeMsg(writer) + writer.Flush() + } + }) + } +} + +func BenchmarkUint32Sorted_DecodeMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Uint32Sorted) + for i := 0; i < size; i++ { + set[uint32(i)] = struct{}{} + } + + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + set.EncodeMsg(writer) + writer.Flush() + encoded := buf.Bytes() + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + reader := msgp.NewReader(bytes.NewReader(encoded)) + var decoded Uint32Sorted + decoded.DecodeMsg(reader) + } + }) + } +} + +func BenchmarkUint32Sorted_MarshalMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Uint32Sorted) + for i := 0; i < size; i++ { + set[uint32(i)] = struct{}{} + } + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + _, err := set.MarshalMsg(nil) + if err != nil { + b.Fatal(err) + } + } + }) + } +} + +func BenchmarkUint32Sorted_UnmarshalMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Uint32Sorted) + for i := 0; i < size; i++ { + set[uint32(i)] = struct{}{} + } + + data, _ := set.MarshalMsg(nil) + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + var decoded Uint32Sorted + _, err := decoded.UnmarshalMsg(data) + if err != nil { + b.Fatal(err) + } + } + }) + } +} + +func BenchmarkUint32Sorted_AsSlice(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Uint32Sorted) + for i := 0; i < size; i++ { + set[uint32(i)] = struct{}{} + } + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + _ = set.AsSlice() + } + }) + } +} + +func BenchmarkUint32Sorted_FromSlice(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + slice := make([]uint32, size) + for i := 0; i < size; i++ { + slice[i] = uint32(i) + } + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + _ = Uint32SortedFromSlice(slice) + } + }) + } +} + +func TestInt64_RoundTrip(t *testing.T) { + set := make(Int64) + set[0] = struct{}{} + set[1] = struct{}{} + set[2] = struct{}{} + set[3] = struct{}{} + set[4] = struct{}{} + + // Test EncodeMsg/DecodeMsg + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + err := set.EncodeMsg(writer) + if err != nil { + t.Fatalf("EncodeMsg failed: %v", err) + } + writer.Flush() + + reader := msgp.NewReader(&buf) + var decoded Int64 + err = decoded.DecodeMsg(reader) + if err != nil { + t.Fatalf("DecodeMsg failed: %v", err) + } + + if len(set) != len(decoded) { + t.Fatalf("length mismatch: expected %d, got %d", len(set), len(decoded)) + } + + for k := range set { + if _, ok := decoded[k]; !ok { + t.Fatalf("missing key: %v", k) + } + } + + // Test MarshalMsg/UnmarshalMsg + data, err := set.MarshalMsg(nil) + if err != nil { + t.Fatalf("MarshalMsg failed: %v", err) + } + + var unmarshaled Int64 + _, err = unmarshaled.UnmarshalMsg(data) + if err != nil { + t.Fatalf("UnmarshalMsg failed: %v", err) + } + + if len(set) != len(unmarshaled) { + t.Fatalf("length mismatch: expected %d, got %d", len(set), len(unmarshaled)) + } + + for k := range set { + if _, ok := unmarshaled[k]; !ok { + t.Fatalf("missing key: %v", k) + } + } +} + +func TestInt64_AsSlice(t *testing.T) { + set := make(Int64) + set[0] = struct{}{} + set[1] = struct{}{} + set[2] = struct{}{} + set[3] = struct{}{} + set[4] = struct{}{} + + slice := set.AsSlice() + if len(slice) != len(set) { + t.Fatalf("length mismatch: expected %d, got %d", len(set), len(slice)) + } + + found := make(map[int64]bool) + for _, v := range slice { + found[v] = true + } + + for k := range set { + if !found[k] { + t.Fatalf("missing key in slice: %v", k) + } + } +} + +func TestInt64_FromSlice(t *testing.T) { + slice := []int64{0, 1, 2, 3, 4} + set := Int64FromSlice(slice) + + if len(set) != len(slice) { + t.Fatalf("length mismatch: expected %d, got %d", len(slice), len(set)) + } + + for _, v := range slice { + if _, ok := set[v]; !ok { + t.Fatalf("missing key: %v", v) + } + } +} + +func TestInt64_NilHandling(t *testing.T) { + var nilSet Int64 + + // Test nil encoding + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + err := nilSet.EncodeMsg(writer) + if err != nil { + t.Fatalf("EncodeMsg failed for nil: %v", err) + } + writer.Flush() + + // Test nil decoding + reader := msgp.NewReader(&buf) + var decoded Int64 + err = decoded.DecodeMsg(reader) + if err != nil { + t.Fatalf("DecodeMsg failed for nil: %v", err) + } + + if decoded != nil { + t.Fatal("expected nil, got non-nil") + } + + // Test nil marshaling + data, err := nilSet.MarshalMsg(nil) + if err != nil { + t.Fatalf("MarshalMsg failed for nil: %v", err) + } + + // Test nil unmarshaling + var unmarshaled Int64 + _, err = unmarshaled.UnmarshalMsg(data) + if err != nil { + t.Fatalf("UnmarshalMsg failed for nil: %v", err) + } + + if unmarshaled != nil { + t.Fatal("expected nil, got non-nil") + } + + // Test AsSlice on nil + slice := nilSet.AsSlice() + if slice != nil { + t.Fatal("expected nil slice, got non-nil") + } + + // Test FromSlice with nil + fromNilSlice := Int64FromSlice(nil) + if fromNilSlice != nil { + t.Fatal("expected nil from nil slice, got non-nil") + } +} + +func TestInt64_EmptySet(t *testing.T) { + set := make(Int64) + + // Test empty set encoding + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + err := set.EncodeMsg(writer) + if err != nil { + t.Fatalf("EncodeMsg failed for empty: %v", err) + } + writer.Flush() + + // Test empty set decoding + reader := msgp.NewReader(&buf) + var decoded Int64 + err = decoded.DecodeMsg(reader) + if err != nil { + t.Fatalf("DecodeMsg failed for empty: %v", err) + } + + if len(decoded) != 0 { + t.Fatalf("expected empty set, got length %d", len(decoded)) + } + + // Test empty set marshaling + data, err := set.MarshalMsg(nil) + if err != nil { + t.Fatalf("MarshalMsg failed for empty: %v", err) + } + + // Test empty set unmarshaling + var unmarshaled Int64 + _, err = unmarshaled.UnmarshalMsg(data) + if err != nil { + t.Fatalf("UnmarshalMsg failed for empty: %v", err) + } + + if len(unmarshaled) != 0 { + t.Fatalf("expected empty set, got length %d", len(unmarshaled)) + } +} + +func TestInt64Sorted_RoundTrip(t *testing.T) { + set := make(Int64Sorted) + set[0] = struct{}{} + set[1] = struct{}{} + set[2] = struct{}{} + set[3] = struct{}{} + set[4] = struct{}{} + + // Test EncodeMsg/DecodeMsg + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + err := set.EncodeMsg(writer) + if err != nil { + t.Fatalf("EncodeMsg failed: %v", err) + } + writer.Flush() + + reader := msgp.NewReader(&buf) + var decoded Int64Sorted + err = decoded.DecodeMsg(reader) + if err != nil { + t.Fatalf("DecodeMsg failed: %v", err) + } + + if len(set) != len(decoded) { + t.Fatalf("length mismatch: expected %d, got %d", len(set), len(decoded)) + } + + for k := range set { + if _, ok := decoded[k]; !ok { + t.Fatalf("missing key: %v", k) + } + } + + // Test MarshalMsg/UnmarshalMsg + data, err := set.MarshalMsg(nil) + if err != nil { + t.Fatalf("MarshalMsg failed: %v", err) + } + + var unmarshaled Int64Sorted + _, err = unmarshaled.UnmarshalMsg(data) + if err != nil { + t.Fatalf("UnmarshalMsg failed: %v", err) + } + + if len(set) != len(unmarshaled) { + t.Fatalf("length mismatch: expected %d, got %d", len(set), len(unmarshaled)) + } + + for k := range set { + if _, ok := unmarshaled[k]; !ok { + t.Fatalf("missing key: %v", k) + } + } +} + +func TestInt64Sorted_AsSlice(t *testing.T) { + set := make(Int64Sorted) + set[0] = struct{}{} + set[1] = struct{}{} + set[2] = struct{}{} + set[3] = struct{}{} + set[4] = struct{}{} + + slice := set.AsSlice() + if len(slice) != len(set) { + t.Fatalf("length mismatch: expected %d, got %d", len(set), len(slice)) + } + + found := make(map[int64]bool) + for _, v := range slice { + found[v] = true + } + + for k := range set { + if !found[k] { + t.Fatalf("missing key in slice: %v", k) + } + } +} + +func TestInt64Sorted_FromSlice(t *testing.T) { + slice := []int64{0, 1, 2, 3, 4} + set := Int64SortedFromSlice(slice) + + if len(set) != len(slice) { + t.Fatalf("length mismatch: expected %d, got %d", len(slice), len(set)) + } + + for _, v := range slice { + if _, ok := set[v]; !ok { + t.Fatalf("missing key: %v", v) + } + } +} + +func TestInt64Sorted_NilHandling(t *testing.T) { + var nilSet Int64Sorted + + // Test nil encoding + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + err := nilSet.EncodeMsg(writer) + if err != nil { + t.Fatalf("EncodeMsg failed for nil: %v", err) + } + writer.Flush() + + // Test nil decoding + reader := msgp.NewReader(&buf) + var decoded Int64Sorted + err = decoded.DecodeMsg(reader) + if err != nil { + t.Fatalf("DecodeMsg failed for nil: %v", err) + } + + if decoded != nil { + t.Fatal("expected nil, got non-nil") + } + + // Test nil marshaling + data, err := nilSet.MarshalMsg(nil) + if err != nil { + t.Fatalf("MarshalMsg failed for nil: %v", err) + } + + // Test nil unmarshaling + var unmarshaled Int64Sorted + _, err = unmarshaled.UnmarshalMsg(data) + if err != nil { + t.Fatalf("UnmarshalMsg failed for nil: %v", err) + } + + if unmarshaled != nil { + t.Fatal("expected nil, got non-nil") + } + + // Test AsSlice on nil + slice := nilSet.AsSlice() + if slice != nil { + t.Fatal("expected nil slice, got non-nil") + } + + // Test FromSlice with nil + fromNilSlice := Int64SortedFromSlice(nil) + if fromNilSlice != nil { + t.Fatal("expected nil from nil slice, got non-nil") + } +} + +func TestInt64Sorted_EmptySet(t *testing.T) { + set := make(Int64Sorted) + + // Test empty set encoding + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + err := set.EncodeMsg(writer) + if err != nil { + t.Fatalf("EncodeMsg failed for empty: %v", err) + } + writer.Flush() + + // Test empty set decoding + reader := msgp.NewReader(&buf) + var decoded Int64Sorted + err = decoded.DecodeMsg(reader) + if err != nil { + t.Fatalf("DecodeMsg failed for empty: %v", err) + } + + if len(decoded) != 0 { + t.Fatalf("expected empty set, got length %d", len(decoded)) + } + + // Test empty set marshaling + data, err := set.MarshalMsg(nil) + if err != nil { + t.Fatalf("MarshalMsg failed for empty: %v", err) + } + + // Test empty set unmarshaling + var unmarshaled Int64Sorted + _, err = unmarshaled.UnmarshalMsg(data) + if err != nil { + t.Fatalf("UnmarshalMsg failed for empty: %v", err) + } + + if len(unmarshaled) != 0 { + t.Fatalf("expected empty set, got length %d", len(unmarshaled)) + } +} + +func BenchmarkInt64_EncodeMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Int64) + for i := 0; i < size; i++ { + set[int64(i)] = struct{}{} + } + + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + buf.Reset() + writer.Reset(&buf) + set.EncodeMsg(writer) + writer.Flush() + } + }) + } +} + +func BenchmarkInt64_DecodeMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Int64) + for i := 0; i < size; i++ { + set[int64(i)] = struct{}{} + } + + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + set.EncodeMsg(writer) + writer.Flush() + encoded := buf.Bytes() + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + reader := msgp.NewReader(bytes.NewReader(encoded)) + var decoded Int64 + decoded.DecodeMsg(reader) + } + }) + } +} + +func BenchmarkInt64_MarshalMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Int64) + for i := 0; i < size; i++ { + set[int64(i)] = struct{}{} + } + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + _, err := set.MarshalMsg(nil) + if err != nil { + b.Fatal(err) + } + } + }) + } +} + +func BenchmarkInt64_UnmarshalMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Int64) + for i := 0; i < size; i++ { + set[int64(i)] = struct{}{} + } + + data, _ := set.MarshalMsg(nil) + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + var decoded Int64 + _, err := decoded.UnmarshalMsg(data) + if err != nil { + b.Fatal(err) + } + } + }) + } +} + +func BenchmarkInt64_AsSlice(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Int64) + for i := 0; i < size; i++ { + set[int64(i)] = struct{}{} + } + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + _ = set.AsSlice() + } + }) + } +} + +func BenchmarkInt64_FromSlice(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + slice := make([]int64, size) + for i := 0; i < size; i++ { + slice[i] = int64(i) + } + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + _ = Int64FromSlice(slice) + } + }) + } +} + +func BenchmarkInt64Sorted_EncodeMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Int64Sorted) + for i := 0; i < size; i++ { + set[int64(i)] = struct{}{} + } + + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + buf.Reset() + writer.Reset(&buf) + set.EncodeMsg(writer) + writer.Flush() + } + }) + } +} + +func BenchmarkInt64Sorted_DecodeMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Int64Sorted) + for i := 0; i < size; i++ { + set[int64(i)] = struct{}{} + } + + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + set.EncodeMsg(writer) + writer.Flush() + encoded := buf.Bytes() + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + reader := msgp.NewReader(bytes.NewReader(encoded)) + var decoded Int64Sorted + decoded.DecodeMsg(reader) + } + }) + } +} + +func BenchmarkInt64Sorted_MarshalMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Int64Sorted) + for i := 0; i < size; i++ { + set[int64(i)] = struct{}{} + } + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + _, err := set.MarshalMsg(nil) + if err != nil { + b.Fatal(err) + } + } + }) + } +} + +func BenchmarkInt64Sorted_UnmarshalMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Int64Sorted) + for i := 0; i < size; i++ { + set[int64(i)] = struct{}{} + } + + data, _ := set.MarshalMsg(nil) + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + var decoded Int64Sorted + _, err := decoded.UnmarshalMsg(data) + if err != nil { + b.Fatal(err) + } + } + }) + } +} + +func BenchmarkInt64Sorted_AsSlice(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Int64Sorted) + for i := 0; i < size; i++ { + set[int64(i)] = struct{}{} + } + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + _ = set.AsSlice() + } + }) + } +} + +func BenchmarkInt64Sorted_FromSlice(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + slice := make([]int64, size) + for i := 0; i < size; i++ { + slice[i] = int64(i) + } + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + _ = Int64SortedFromSlice(slice) + } + }) + } +} + +func TestUint64_RoundTrip(t *testing.T) { + set := make(Uint64) + set[0] = struct{}{} + set[1] = struct{}{} + set[2] = struct{}{} + set[3] = struct{}{} + set[4] = struct{}{} + + // Test EncodeMsg/DecodeMsg + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + err := set.EncodeMsg(writer) + if err != nil { + t.Fatalf("EncodeMsg failed: %v", err) + } + writer.Flush() + + reader := msgp.NewReader(&buf) + var decoded Uint64 + err = decoded.DecodeMsg(reader) + if err != nil { + t.Fatalf("DecodeMsg failed: %v", err) + } + + if len(set) != len(decoded) { + t.Fatalf("length mismatch: expected %d, got %d", len(set), len(decoded)) + } + + for k := range set { + if _, ok := decoded[k]; !ok { + t.Fatalf("missing key: %v", k) + } + } + + // Test MarshalMsg/UnmarshalMsg + data, err := set.MarshalMsg(nil) + if err != nil { + t.Fatalf("MarshalMsg failed: %v", err) + } + + var unmarshaled Uint64 + _, err = unmarshaled.UnmarshalMsg(data) + if err != nil { + t.Fatalf("UnmarshalMsg failed: %v", err) + } + + if len(set) != len(unmarshaled) { + t.Fatalf("length mismatch: expected %d, got %d", len(set), len(unmarshaled)) + } + + for k := range set { + if _, ok := unmarshaled[k]; !ok { + t.Fatalf("missing key: %v", k) + } + } +} + +func TestUint64_AsSlice(t *testing.T) { + set := make(Uint64) + set[0] = struct{}{} + set[1] = struct{}{} + set[2] = struct{}{} + set[3] = struct{}{} + set[4] = struct{}{} + + slice := set.AsSlice() + if len(slice) != len(set) { + t.Fatalf("length mismatch: expected %d, got %d", len(set), len(slice)) + } + + found := make(map[uint64]bool) + for _, v := range slice { + found[v] = true + } + + for k := range set { + if !found[k] { + t.Fatalf("missing key in slice: %v", k) + } + } +} + +func TestUint64_FromSlice(t *testing.T) { + slice := []uint64{0, 1, 2, 3, 4} + set := Uint64FromSlice(slice) + + if len(set) != len(slice) { + t.Fatalf("length mismatch: expected %d, got %d", len(slice), len(set)) + } + + for _, v := range slice { + if _, ok := set[v]; !ok { + t.Fatalf("missing key: %v", v) + } + } +} + +func TestUint64_NilHandling(t *testing.T) { + var nilSet Uint64 + + // Test nil encoding + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + err := nilSet.EncodeMsg(writer) + if err != nil { + t.Fatalf("EncodeMsg failed for nil: %v", err) + } + writer.Flush() + + // Test nil decoding + reader := msgp.NewReader(&buf) + var decoded Uint64 + err = decoded.DecodeMsg(reader) + if err != nil { + t.Fatalf("DecodeMsg failed for nil: %v", err) + } + + if decoded != nil { + t.Fatal("expected nil, got non-nil") + } + + // Test nil marshaling + data, err := nilSet.MarshalMsg(nil) + if err != nil { + t.Fatalf("MarshalMsg failed for nil: %v", err) + } + + // Test nil unmarshaling + var unmarshaled Uint64 + _, err = unmarshaled.UnmarshalMsg(data) + if err != nil { + t.Fatalf("UnmarshalMsg failed for nil: %v", err) + } + + if unmarshaled != nil { + t.Fatal("expected nil, got non-nil") + } + + // Test AsSlice on nil + slice := nilSet.AsSlice() + if slice != nil { + t.Fatal("expected nil slice, got non-nil") + } + + // Test FromSlice with nil + fromNilSlice := Uint64FromSlice(nil) + if fromNilSlice != nil { + t.Fatal("expected nil from nil slice, got non-nil") + } +} + +func TestUint64_EmptySet(t *testing.T) { + set := make(Uint64) + + // Test empty set encoding + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + err := set.EncodeMsg(writer) + if err != nil { + t.Fatalf("EncodeMsg failed for empty: %v", err) + } + writer.Flush() + + // Test empty set decoding + reader := msgp.NewReader(&buf) + var decoded Uint64 + err = decoded.DecodeMsg(reader) + if err != nil { + t.Fatalf("DecodeMsg failed for empty: %v", err) + } + + if len(decoded) != 0 { + t.Fatalf("expected empty set, got length %d", len(decoded)) + } + + // Test empty set marshaling + data, err := set.MarshalMsg(nil) + if err != nil { + t.Fatalf("MarshalMsg failed for empty: %v", err) + } + + // Test empty set unmarshaling + var unmarshaled Uint64 + _, err = unmarshaled.UnmarshalMsg(data) + if err != nil { + t.Fatalf("UnmarshalMsg failed for empty: %v", err) + } + + if len(unmarshaled) != 0 { + t.Fatalf("expected empty set, got length %d", len(unmarshaled)) + } +} + +func TestUint64Sorted_RoundTrip(t *testing.T) { + set := make(Uint64Sorted) + set[0] = struct{}{} + set[1] = struct{}{} + set[2] = struct{}{} + set[3] = struct{}{} + set[4] = struct{}{} + + // Test EncodeMsg/DecodeMsg + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + err := set.EncodeMsg(writer) + if err != nil { + t.Fatalf("EncodeMsg failed: %v", err) + } + writer.Flush() + + reader := msgp.NewReader(&buf) + var decoded Uint64Sorted + err = decoded.DecodeMsg(reader) + if err != nil { + t.Fatalf("DecodeMsg failed: %v", err) + } + + if len(set) != len(decoded) { + t.Fatalf("length mismatch: expected %d, got %d", len(set), len(decoded)) + } + + for k := range set { + if _, ok := decoded[k]; !ok { + t.Fatalf("missing key: %v", k) + } + } + + // Test MarshalMsg/UnmarshalMsg + data, err := set.MarshalMsg(nil) + if err != nil { + t.Fatalf("MarshalMsg failed: %v", err) + } + + var unmarshaled Uint64Sorted + _, err = unmarshaled.UnmarshalMsg(data) + if err != nil { + t.Fatalf("UnmarshalMsg failed: %v", err) + } + + if len(set) != len(unmarshaled) { + t.Fatalf("length mismatch: expected %d, got %d", len(set), len(unmarshaled)) + } + + for k := range set { + if _, ok := unmarshaled[k]; !ok { + t.Fatalf("missing key: %v", k) + } + } +} + +func TestUint64Sorted_AsSlice(t *testing.T) { + set := make(Uint64Sorted) + set[0] = struct{}{} + set[1] = struct{}{} + set[2] = struct{}{} + set[3] = struct{}{} + set[4] = struct{}{} + + slice := set.AsSlice() + if len(slice) != len(set) { + t.Fatalf("length mismatch: expected %d, got %d", len(set), len(slice)) + } + + found := make(map[uint64]bool) + for _, v := range slice { + found[v] = true + } + + for k := range set { + if !found[k] { + t.Fatalf("missing key in slice: %v", k) + } + } +} + +func TestUint64Sorted_FromSlice(t *testing.T) { + slice := []uint64{0, 1, 2, 3, 4} + set := Uint64SortedFromSlice(slice) + + if len(set) != len(slice) { + t.Fatalf("length mismatch: expected %d, got %d", len(slice), len(set)) + } + + for _, v := range slice { + if _, ok := set[v]; !ok { + t.Fatalf("missing key: %v", v) + } + } +} + +func TestUint64Sorted_NilHandling(t *testing.T) { + var nilSet Uint64Sorted + + // Test nil encoding + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + err := nilSet.EncodeMsg(writer) + if err != nil { + t.Fatalf("EncodeMsg failed for nil: %v", err) + } + writer.Flush() + + // Test nil decoding + reader := msgp.NewReader(&buf) + var decoded Uint64Sorted + err = decoded.DecodeMsg(reader) + if err != nil { + t.Fatalf("DecodeMsg failed for nil: %v", err) + } + + if decoded != nil { + t.Fatal("expected nil, got non-nil") + } + + // Test nil marshaling + data, err := nilSet.MarshalMsg(nil) + if err != nil { + t.Fatalf("MarshalMsg failed for nil: %v", err) + } + + // Test nil unmarshaling + var unmarshaled Uint64Sorted + _, err = unmarshaled.UnmarshalMsg(data) + if err != nil { + t.Fatalf("UnmarshalMsg failed for nil: %v", err) + } + + if unmarshaled != nil { + t.Fatal("expected nil, got non-nil") + } + + // Test AsSlice on nil + slice := nilSet.AsSlice() + if slice != nil { + t.Fatal("expected nil slice, got non-nil") + } + + // Test FromSlice with nil + fromNilSlice := Uint64SortedFromSlice(nil) + if fromNilSlice != nil { + t.Fatal("expected nil from nil slice, got non-nil") + } +} + +func TestUint64Sorted_EmptySet(t *testing.T) { + set := make(Uint64Sorted) + + // Test empty set encoding + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + err := set.EncodeMsg(writer) + if err != nil { + t.Fatalf("EncodeMsg failed for empty: %v", err) + } + writer.Flush() + + // Test empty set decoding + reader := msgp.NewReader(&buf) + var decoded Uint64Sorted + err = decoded.DecodeMsg(reader) + if err != nil { + t.Fatalf("DecodeMsg failed for empty: %v", err) + } + + if len(decoded) != 0 { + t.Fatalf("expected empty set, got length %d", len(decoded)) + } + + // Test empty set marshaling + data, err := set.MarshalMsg(nil) + if err != nil { + t.Fatalf("MarshalMsg failed for empty: %v", err) + } + + // Test empty set unmarshaling + var unmarshaled Uint64Sorted + _, err = unmarshaled.UnmarshalMsg(data) + if err != nil { + t.Fatalf("UnmarshalMsg failed for empty: %v", err) + } + + if len(unmarshaled) != 0 { + t.Fatalf("expected empty set, got length %d", len(unmarshaled)) + } +} + +func BenchmarkUint64_EncodeMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Uint64) + for i := 0; i < size; i++ { + set[uint64(i)] = struct{}{} + } + + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + buf.Reset() + writer.Reset(&buf) + set.EncodeMsg(writer) + writer.Flush() + } + }) + } +} + +func BenchmarkUint64_DecodeMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Uint64) + for i := 0; i < size; i++ { + set[uint64(i)] = struct{}{} + } + + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + set.EncodeMsg(writer) + writer.Flush() + encoded := buf.Bytes() + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + reader := msgp.NewReader(bytes.NewReader(encoded)) + var decoded Uint64 + decoded.DecodeMsg(reader) + } + }) + } +} + +func BenchmarkUint64_MarshalMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Uint64) + for i := 0; i < size; i++ { + set[uint64(i)] = struct{}{} + } + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + _, err := set.MarshalMsg(nil) + if err != nil { + b.Fatal(err) + } + } + }) + } +} + +func BenchmarkUint64_UnmarshalMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Uint64) + for i := 0; i < size; i++ { + set[uint64(i)] = struct{}{} + } + + data, _ := set.MarshalMsg(nil) + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + var decoded Uint64 + _, err := decoded.UnmarshalMsg(data) + if err != nil { + b.Fatal(err) + } + } + }) + } +} + +func BenchmarkUint64_AsSlice(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Uint64) + for i := 0; i < size; i++ { + set[uint64(i)] = struct{}{} + } + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + _ = set.AsSlice() + } + }) + } +} + +func BenchmarkUint64_FromSlice(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + slice := make([]uint64, size) + for i := 0; i < size; i++ { + slice[i] = uint64(i) + } + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + _ = Uint64FromSlice(slice) + } + }) + } +} + +func BenchmarkUint64Sorted_EncodeMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Uint64Sorted) + for i := 0; i < size; i++ { + set[uint64(i)] = struct{}{} + } + + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + buf.Reset() + writer.Reset(&buf) + set.EncodeMsg(writer) + writer.Flush() + } + }) + } +} + +func BenchmarkUint64Sorted_DecodeMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Uint64Sorted) + for i := 0; i < size; i++ { + set[uint64(i)] = struct{}{} + } + + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + set.EncodeMsg(writer) + writer.Flush() + encoded := buf.Bytes() + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + reader := msgp.NewReader(bytes.NewReader(encoded)) + var decoded Uint64Sorted + decoded.DecodeMsg(reader) + } + }) + } +} + +func BenchmarkUint64Sorted_MarshalMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Uint64Sorted) + for i := 0; i < size; i++ { + set[uint64(i)] = struct{}{} + } + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + _, err := set.MarshalMsg(nil) + if err != nil { + b.Fatal(err) + } + } + }) + } +} + +func BenchmarkUint64Sorted_UnmarshalMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Uint64Sorted) + for i := 0; i < size; i++ { + set[uint64(i)] = struct{}{} + } + + data, _ := set.MarshalMsg(nil) + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + var decoded Uint64Sorted + _, err := decoded.UnmarshalMsg(data) + if err != nil { + b.Fatal(err) + } + } + }) + } +} + +func BenchmarkUint64Sorted_AsSlice(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Uint64Sorted) + for i := 0; i < size; i++ { + set[uint64(i)] = struct{}{} + } + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + _ = set.AsSlice() + } + }) + } +} + +func BenchmarkUint64Sorted_FromSlice(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + slice := make([]uint64, size) + for i := 0; i < size; i++ { + slice[i] = uint64(i) + } + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + _ = Uint64SortedFromSlice(slice) + } + }) + } +} + +func TestFloat64_RoundTrip(t *testing.T) { + set := make(Float64) + set[0.0] = struct{}{} + set[1.0] = struct{}{} + set[2.0] = struct{}{} + set[3.0] = struct{}{} + set[4.0] = struct{}{} + + // Test EncodeMsg/DecodeMsg + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + err := set.EncodeMsg(writer) + if err != nil { + t.Fatalf("EncodeMsg failed: %v", err) + } + writer.Flush() + + reader := msgp.NewReader(&buf) + var decoded Float64 + err = decoded.DecodeMsg(reader) + if err != nil { + t.Fatalf("DecodeMsg failed: %v", err) + } + + if len(set) != len(decoded) { + t.Fatalf("length mismatch: expected %d, got %d", len(set), len(decoded)) + } + + for k := range set { + if _, ok := decoded[k]; !ok { + t.Fatalf("missing key: %v", k) + } + } + + // Test MarshalMsg/UnmarshalMsg + data, err := set.MarshalMsg(nil) + if err != nil { + t.Fatalf("MarshalMsg failed: %v", err) + } + + var unmarshaled Float64 + _, err = unmarshaled.UnmarshalMsg(data) + if err != nil { + t.Fatalf("UnmarshalMsg failed: %v", err) + } + + if len(set) != len(unmarshaled) { + t.Fatalf("length mismatch: expected %d, got %d", len(set), len(unmarshaled)) + } + + for k := range set { + if _, ok := unmarshaled[k]; !ok { + t.Fatalf("missing key: %v", k) + } + } +} + +func TestFloat64_AsSlice(t *testing.T) { + set := make(Float64) + set[0.0] = struct{}{} + set[1.0] = struct{}{} + set[2.0] = struct{}{} + set[3.0] = struct{}{} + set[4.0] = struct{}{} + + slice := set.AsSlice() + if len(slice) != len(set) { + t.Fatalf("length mismatch: expected %d, got %d", len(set), len(slice)) + } + + found := make(map[float64]bool) + for _, v := range slice { + found[v] = true + } + + for k := range set { + if !found[k] { + t.Fatalf("missing key in slice: %v", k) + } + } +} + +func TestFloat64_FromSlice(t *testing.T) { + slice := []float64{0.0, 1.0, 2.0, 3.0, 4.0} + set := Float64FromSlice(slice) + + if len(set) != len(slice) { + t.Fatalf("length mismatch: expected %d, got %d", len(slice), len(set)) + } + + for _, v := range slice { + if _, ok := set[v]; !ok { + t.Fatalf("missing key: %v", v) + } + } +} + +func TestFloat64_NilHandling(t *testing.T) { + var nilSet Float64 + + // Test nil encoding + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + err := nilSet.EncodeMsg(writer) + if err != nil { + t.Fatalf("EncodeMsg failed for nil: %v", err) + } + writer.Flush() + + // Test nil decoding + reader := msgp.NewReader(&buf) + var decoded Float64 + err = decoded.DecodeMsg(reader) + if err != nil { + t.Fatalf("DecodeMsg failed for nil: %v", err) + } + + if decoded != nil { + t.Fatal("expected nil, got non-nil") + } + + // Test nil marshaling + data, err := nilSet.MarshalMsg(nil) + if err != nil { + t.Fatalf("MarshalMsg failed for nil: %v", err) + } + + // Test nil unmarshaling + var unmarshaled Float64 + _, err = unmarshaled.UnmarshalMsg(data) + if err != nil { + t.Fatalf("UnmarshalMsg failed for nil: %v", err) + } + + if unmarshaled != nil { + t.Fatal("expected nil, got non-nil") + } + + // Test AsSlice on nil + slice := nilSet.AsSlice() + if slice != nil { + t.Fatal("expected nil slice, got non-nil") + } + + // Test FromSlice with nil + fromNilSlice := Float64FromSlice(nil) + if fromNilSlice != nil { + t.Fatal("expected nil from nil slice, got non-nil") + } +} + +func TestFloat64_EmptySet(t *testing.T) { + set := make(Float64) + + // Test empty set encoding + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + err := set.EncodeMsg(writer) + if err != nil { + t.Fatalf("EncodeMsg failed for empty: %v", err) + } + writer.Flush() + + // Test empty set decoding + reader := msgp.NewReader(&buf) + var decoded Float64 + err = decoded.DecodeMsg(reader) + if err != nil { + t.Fatalf("DecodeMsg failed for empty: %v", err) + } + + if len(decoded) != 0 { + t.Fatalf("expected empty set, got length %d", len(decoded)) + } + + // Test empty set marshaling + data, err := set.MarshalMsg(nil) + if err != nil { + t.Fatalf("MarshalMsg failed for empty: %v", err) + } + + // Test empty set unmarshaling + var unmarshaled Float64 + _, err = unmarshaled.UnmarshalMsg(data) + if err != nil { + t.Fatalf("UnmarshalMsg failed for empty: %v", err) + } + + if len(unmarshaled) != 0 { + t.Fatalf("expected empty set, got length %d", len(unmarshaled)) + } +} + +func TestFloat64Sorted_RoundTrip(t *testing.T) { + set := make(Float64Sorted) + set[0.0] = struct{}{} + set[1.0] = struct{}{} + set[2.0] = struct{}{} + set[3.0] = struct{}{} + set[4.0] = struct{}{} + + // Test EncodeMsg/DecodeMsg + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + err := set.EncodeMsg(writer) + if err != nil { + t.Fatalf("EncodeMsg failed: %v", err) + } + writer.Flush() + + reader := msgp.NewReader(&buf) + var decoded Float64Sorted + err = decoded.DecodeMsg(reader) + if err != nil { + t.Fatalf("DecodeMsg failed: %v", err) + } + + if len(set) != len(decoded) { + t.Fatalf("length mismatch: expected %d, got %d", len(set), len(decoded)) + } + + for k := range set { + if _, ok := decoded[k]; !ok { + t.Fatalf("missing key: %v", k) + } + } + + // Test MarshalMsg/UnmarshalMsg + data, err := set.MarshalMsg(nil) + if err != nil { + t.Fatalf("MarshalMsg failed: %v", err) + } + + var unmarshaled Float64Sorted + _, err = unmarshaled.UnmarshalMsg(data) + if err != nil { + t.Fatalf("UnmarshalMsg failed: %v", err) + } + + if len(set) != len(unmarshaled) { + t.Fatalf("length mismatch: expected %d, got %d", len(set), len(unmarshaled)) + } + + for k := range set { + if _, ok := unmarshaled[k]; !ok { + t.Fatalf("missing key: %v", k) + } + } +} + +func TestFloat64Sorted_AsSlice(t *testing.T) { + set := make(Float64Sorted) + set[0.0] = struct{}{} + set[1.0] = struct{}{} + set[2.0] = struct{}{} + set[3.0] = struct{}{} + set[4.0] = struct{}{} + + slice := set.AsSlice() + if len(slice) != len(set) { + t.Fatalf("length mismatch: expected %d, got %d", len(set), len(slice)) + } + + found := make(map[float64]bool) + for _, v := range slice { + found[v] = true + } + + for k := range set { + if !found[k] { + t.Fatalf("missing key in slice: %v", k) + } + } +} + +func TestFloat64Sorted_FromSlice(t *testing.T) { + slice := []float64{0.0, 1.0, 2.0, 3.0, 4.0} + set := Float64SortedFromSlice(slice) + + if len(set) != len(slice) { + t.Fatalf("length mismatch: expected %d, got %d", len(slice), len(set)) + } + + for _, v := range slice { + if _, ok := set[v]; !ok { + t.Fatalf("missing key: %v", v) + } + } +} + +func TestFloat64Sorted_NilHandling(t *testing.T) { + var nilSet Float64Sorted + + // Test nil encoding + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + err := nilSet.EncodeMsg(writer) + if err != nil { + t.Fatalf("EncodeMsg failed for nil: %v", err) + } + writer.Flush() + + // Test nil decoding + reader := msgp.NewReader(&buf) + var decoded Float64Sorted + err = decoded.DecodeMsg(reader) + if err != nil { + t.Fatalf("DecodeMsg failed for nil: %v", err) + } + + if decoded != nil { + t.Fatal("expected nil, got non-nil") + } + + // Test nil marshaling + data, err := nilSet.MarshalMsg(nil) + if err != nil { + t.Fatalf("MarshalMsg failed for nil: %v", err) + } + + // Test nil unmarshaling + var unmarshaled Float64Sorted + _, err = unmarshaled.UnmarshalMsg(data) + if err != nil { + t.Fatalf("UnmarshalMsg failed for nil: %v", err) + } + + if unmarshaled != nil { + t.Fatal("expected nil, got non-nil") + } + + // Test AsSlice on nil + slice := nilSet.AsSlice() + if slice != nil { + t.Fatal("expected nil slice, got non-nil") + } + + // Test FromSlice with nil + fromNilSlice := Float64SortedFromSlice(nil) + if fromNilSlice != nil { + t.Fatal("expected nil from nil slice, got non-nil") + } +} + +func TestFloat64Sorted_EmptySet(t *testing.T) { + set := make(Float64Sorted) + + // Test empty set encoding + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + err := set.EncodeMsg(writer) + if err != nil { + t.Fatalf("EncodeMsg failed for empty: %v", err) + } + writer.Flush() + + // Test empty set decoding + reader := msgp.NewReader(&buf) + var decoded Float64Sorted + err = decoded.DecodeMsg(reader) + if err != nil { + t.Fatalf("DecodeMsg failed for empty: %v", err) + } + + if len(decoded) != 0 { + t.Fatalf("expected empty set, got length %d", len(decoded)) + } + + // Test empty set marshaling + data, err := set.MarshalMsg(nil) + if err != nil { + t.Fatalf("MarshalMsg failed for empty: %v", err) + } + + // Test empty set unmarshaling + var unmarshaled Float64Sorted + _, err = unmarshaled.UnmarshalMsg(data) + if err != nil { + t.Fatalf("UnmarshalMsg failed for empty: %v", err) + } + + if len(unmarshaled) != 0 { + t.Fatalf("expected empty set, got length %d", len(unmarshaled)) + } +} + +func BenchmarkFloat64_EncodeMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Float64) + for i := 0; i < size; i++ { + set[float64(i)] = struct{}{} + } + + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + buf.Reset() + writer.Reset(&buf) + set.EncodeMsg(writer) + writer.Flush() + } + }) + } +} + +func BenchmarkFloat64_DecodeMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Float64) + for i := 0; i < size; i++ { + set[float64(i)] = struct{}{} + } + + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + set.EncodeMsg(writer) + writer.Flush() + encoded := buf.Bytes() + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + reader := msgp.NewReader(bytes.NewReader(encoded)) + var decoded Float64 + decoded.DecodeMsg(reader) + } + }) + } +} + +func BenchmarkFloat64_MarshalMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Float64) + for i := 0; i < size; i++ { + set[float64(i)] = struct{}{} + } + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + _, err := set.MarshalMsg(nil) + if err != nil { + b.Fatal(err) + } + } + }) + } +} + +func BenchmarkFloat64_UnmarshalMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Float64) + for i := 0; i < size; i++ { + set[float64(i)] = struct{}{} + } + + data, _ := set.MarshalMsg(nil) + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + var decoded Float64 + _, err := decoded.UnmarshalMsg(data) + if err != nil { + b.Fatal(err) + } + } + }) + } +} + +func BenchmarkFloat64_AsSlice(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Float64) + for i := 0; i < size; i++ { + set[float64(i)] = struct{}{} + } + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + _ = set.AsSlice() + } + }) + } +} + +func BenchmarkFloat64_FromSlice(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + slice := make([]float64, size) + for i := 0; i < size; i++ { + slice[i] = float64(i) + } + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + _ = Float64FromSlice(slice) + } + }) + } +} + +func BenchmarkFloat64Sorted_EncodeMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Float64Sorted) + for i := 0; i < size; i++ { + set[float64(i)] = struct{}{} + } + + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + buf.Reset() + writer.Reset(&buf) + set.EncodeMsg(writer) + writer.Flush() + } + }) + } +} + +func BenchmarkFloat64Sorted_DecodeMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Float64Sorted) + for i := 0; i < size; i++ { + set[float64(i)] = struct{}{} + } + + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + set.EncodeMsg(writer) + writer.Flush() + encoded := buf.Bytes() + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + reader := msgp.NewReader(bytes.NewReader(encoded)) + var decoded Float64Sorted + decoded.DecodeMsg(reader) + } + }) + } +} + +func BenchmarkFloat64Sorted_MarshalMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Float64Sorted) + for i := 0; i < size; i++ { + set[float64(i)] = struct{}{} + } + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + _, err := set.MarshalMsg(nil) + if err != nil { + b.Fatal(err) + } + } + }) + } +} + +func BenchmarkFloat64Sorted_UnmarshalMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Float64Sorted) + for i := 0; i < size; i++ { + set[float64(i)] = struct{}{} + } + + data, _ := set.MarshalMsg(nil) + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + var decoded Float64Sorted + _, err := decoded.UnmarshalMsg(data) + if err != nil { + b.Fatal(err) + } + } + }) + } +} + +func BenchmarkFloat64Sorted_AsSlice(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Float64Sorted) + for i := 0; i < size; i++ { + set[float64(i)] = struct{}{} + } + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + _ = set.AsSlice() + } + }) + } +} + +func BenchmarkFloat64Sorted_FromSlice(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + slice := make([]float64, size) + for i := 0; i < size; i++ { + slice[i] = float64(i) + } + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + _ = Float64SortedFromSlice(slice) + } + }) + } +} + +func TestFloat32_RoundTrip(t *testing.T) { + set := make(Float32) + set[0.0] = struct{}{} + set[1.0] = struct{}{} + set[2.0] = struct{}{} + set[3.0] = struct{}{} + set[4.0] = struct{}{} + + // Test EncodeMsg/DecodeMsg + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + err := set.EncodeMsg(writer) + if err != nil { + t.Fatalf("EncodeMsg failed: %v", err) + } + writer.Flush() + + reader := msgp.NewReader(&buf) + var decoded Float32 + err = decoded.DecodeMsg(reader) + if err != nil { + t.Fatalf("DecodeMsg failed: %v", err) + } + + if len(set) != len(decoded) { + t.Fatalf("length mismatch: expected %d, got %d", len(set), len(decoded)) + } + + for k := range set { + if _, ok := decoded[k]; !ok { + t.Fatalf("missing key: %v", k) + } + } + + // Test MarshalMsg/UnmarshalMsg + data, err := set.MarshalMsg(nil) + if err != nil { + t.Fatalf("MarshalMsg failed: %v", err) + } + + var unmarshaled Float32 + _, err = unmarshaled.UnmarshalMsg(data) + if err != nil { + t.Fatalf("UnmarshalMsg failed: %v", err) + } + + if len(set) != len(unmarshaled) { + t.Fatalf("length mismatch: expected %d, got %d", len(set), len(unmarshaled)) + } + + for k := range set { + if _, ok := unmarshaled[k]; !ok { + t.Fatalf("missing key: %v", k) + } + } +} + +func TestFloat32_AsSlice(t *testing.T) { + set := make(Float32) + set[0.0] = struct{}{} + set[1.0] = struct{}{} + set[2.0] = struct{}{} + set[3.0] = struct{}{} + set[4.0] = struct{}{} + + slice := set.AsSlice() + if len(slice) != len(set) { + t.Fatalf("length mismatch: expected %d, got %d", len(set), len(slice)) + } + + found := make(map[float32]bool) + for _, v := range slice { + found[v] = true + } + + for k := range set { + if !found[k] { + t.Fatalf("missing key in slice: %v", k) + } + } +} + +func TestFloat32_FromSlice(t *testing.T) { + slice := []float32{0.0, 1.0, 2.0, 3.0, 4.0} + set := Float32FromSlice(slice) + + if len(set) != len(slice) { + t.Fatalf("length mismatch: expected %d, got %d", len(slice), len(set)) + } + + for _, v := range slice { + if _, ok := set[v]; !ok { + t.Fatalf("missing key: %v", v) + } + } +} + +func TestFloat32_NilHandling(t *testing.T) { + var nilSet Float32 + + // Test nil encoding + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + err := nilSet.EncodeMsg(writer) + if err != nil { + t.Fatalf("EncodeMsg failed for nil: %v", err) + } + writer.Flush() + + // Test nil decoding + reader := msgp.NewReader(&buf) + var decoded Float32 + err = decoded.DecodeMsg(reader) + if err != nil { + t.Fatalf("DecodeMsg failed for nil: %v", err) + } + + if decoded != nil { + t.Fatal("expected nil, got non-nil") + } + + // Test nil marshaling + data, err := nilSet.MarshalMsg(nil) + if err != nil { + t.Fatalf("MarshalMsg failed for nil: %v", err) + } + + // Test nil unmarshaling + var unmarshaled Float32 + _, err = unmarshaled.UnmarshalMsg(data) + if err != nil { + t.Fatalf("UnmarshalMsg failed for nil: %v", err) + } + + if unmarshaled != nil { + t.Fatal("expected nil, got non-nil") + } + + // Test AsSlice on nil + slice := nilSet.AsSlice() + if slice != nil { + t.Fatal("expected nil slice, got non-nil") + } + + // Test FromSlice with nil + fromNilSlice := Float32FromSlice(nil) + if fromNilSlice != nil { + t.Fatal("expected nil from nil slice, got non-nil") + } +} + +func TestFloat32_EmptySet(t *testing.T) { + set := make(Float32) + + // Test empty set encoding + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + err := set.EncodeMsg(writer) + if err != nil { + t.Fatalf("EncodeMsg failed for empty: %v", err) + } + writer.Flush() + + // Test empty set decoding + reader := msgp.NewReader(&buf) + var decoded Float32 + err = decoded.DecodeMsg(reader) + if err != nil { + t.Fatalf("DecodeMsg failed for empty: %v", err) + } + + if len(decoded) != 0 { + t.Fatalf("expected empty set, got length %d", len(decoded)) + } + + // Test empty set marshaling + data, err := set.MarshalMsg(nil) + if err != nil { + t.Fatalf("MarshalMsg failed for empty: %v", err) + } + + // Test empty set unmarshaling + var unmarshaled Float32 + _, err = unmarshaled.UnmarshalMsg(data) + if err != nil { + t.Fatalf("UnmarshalMsg failed for empty: %v", err) + } + + if len(unmarshaled) != 0 { + t.Fatalf("expected empty set, got length %d", len(unmarshaled)) + } +} + +func TestFloat32Sorted_RoundTrip(t *testing.T) { + set := make(Float32Sorted) + set[0.0] = struct{}{} + set[1.0] = struct{}{} + set[2.0] = struct{}{} + set[3.0] = struct{}{} + set[4.0] = struct{}{} + + // Test EncodeMsg/DecodeMsg + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + err := set.EncodeMsg(writer) + if err != nil { + t.Fatalf("EncodeMsg failed: %v", err) + } + writer.Flush() + + reader := msgp.NewReader(&buf) + var decoded Float32Sorted + err = decoded.DecodeMsg(reader) + if err != nil { + t.Fatalf("DecodeMsg failed: %v", err) + } + + if len(set) != len(decoded) { + t.Fatalf("length mismatch: expected %d, got %d", len(set), len(decoded)) + } + + for k := range set { + if _, ok := decoded[k]; !ok { + t.Fatalf("missing key: %v", k) + } + } + + // Test MarshalMsg/UnmarshalMsg + data, err := set.MarshalMsg(nil) + if err != nil { + t.Fatalf("MarshalMsg failed: %v", err) + } + + var unmarshaled Float32Sorted + _, err = unmarshaled.UnmarshalMsg(data) + if err != nil { + t.Fatalf("UnmarshalMsg failed: %v", err) + } + + if len(set) != len(unmarshaled) { + t.Fatalf("length mismatch: expected %d, got %d", len(set), len(unmarshaled)) + } + + for k := range set { + if _, ok := unmarshaled[k]; !ok { + t.Fatalf("missing key: %v", k) + } + } +} + +func TestFloat32Sorted_AsSlice(t *testing.T) { + set := make(Float32Sorted) + set[0.0] = struct{}{} + set[1.0] = struct{}{} + set[2.0] = struct{}{} + set[3.0] = struct{}{} + set[4.0] = struct{}{} + + slice := set.AsSlice() + if len(slice) != len(set) { + t.Fatalf("length mismatch: expected %d, got %d", len(set), len(slice)) + } + + found := make(map[float32]bool) + for _, v := range slice { + found[v] = true + } + + for k := range set { + if !found[k] { + t.Fatalf("missing key in slice: %v", k) + } + } +} + +func TestFloat32Sorted_FromSlice(t *testing.T) { + slice := []float32{0.0, 1.0, 2.0, 3.0, 4.0} + set := Float32SortedFromSlice(slice) + + if len(set) != len(slice) { + t.Fatalf("length mismatch: expected %d, got %d", len(slice), len(set)) + } + + for _, v := range slice { + if _, ok := set[v]; !ok { + t.Fatalf("missing key: %v", v) + } + } +} + +func TestFloat32Sorted_NilHandling(t *testing.T) { + var nilSet Float32Sorted + + // Test nil encoding + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + err := nilSet.EncodeMsg(writer) + if err != nil { + t.Fatalf("EncodeMsg failed for nil: %v", err) + } + writer.Flush() + + // Test nil decoding + reader := msgp.NewReader(&buf) + var decoded Float32Sorted + err = decoded.DecodeMsg(reader) + if err != nil { + t.Fatalf("DecodeMsg failed for nil: %v", err) + } + + if decoded != nil { + t.Fatal("expected nil, got non-nil") + } + + // Test nil marshaling + data, err := nilSet.MarshalMsg(nil) + if err != nil { + t.Fatalf("MarshalMsg failed for nil: %v", err) + } + + // Test nil unmarshaling + var unmarshaled Float32Sorted + _, err = unmarshaled.UnmarshalMsg(data) + if err != nil { + t.Fatalf("UnmarshalMsg failed for nil: %v", err) + } + + if unmarshaled != nil { + t.Fatal("expected nil, got non-nil") + } + + // Test AsSlice on nil + slice := nilSet.AsSlice() + if slice != nil { + t.Fatal("expected nil slice, got non-nil") + } + + // Test FromSlice with nil + fromNilSlice := Float32SortedFromSlice(nil) + if fromNilSlice != nil { + t.Fatal("expected nil from nil slice, got non-nil") + } +} + +func TestFloat32Sorted_EmptySet(t *testing.T) { + set := make(Float32Sorted) + + // Test empty set encoding + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + err := set.EncodeMsg(writer) + if err != nil { + t.Fatalf("EncodeMsg failed for empty: %v", err) + } + writer.Flush() + + // Test empty set decoding + reader := msgp.NewReader(&buf) + var decoded Float32Sorted + err = decoded.DecodeMsg(reader) + if err != nil { + t.Fatalf("DecodeMsg failed for empty: %v", err) + } + + if len(decoded) != 0 { + t.Fatalf("expected empty set, got length %d", len(decoded)) + } + + // Test empty set marshaling + data, err := set.MarshalMsg(nil) + if err != nil { + t.Fatalf("MarshalMsg failed for empty: %v", err) + } + + // Test empty set unmarshaling + var unmarshaled Float32Sorted + _, err = unmarshaled.UnmarshalMsg(data) + if err != nil { + t.Fatalf("UnmarshalMsg failed for empty: %v", err) + } + + if len(unmarshaled) != 0 { + t.Fatalf("expected empty set, got length %d", len(unmarshaled)) + } +} + +func BenchmarkFloat32_EncodeMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Float32) + for i := 0; i < size; i++ { + set[float32(i)] = struct{}{} + } + + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + buf.Reset() + writer.Reset(&buf) + set.EncodeMsg(writer) + writer.Flush() + } + }) + } +} + +func BenchmarkFloat32_DecodeMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Float32) + for i := 0; i < size; i++ { + set[float32(i)] = struct{}{} + } + + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + set.EncodeMsg(writer) + writer.Flush() + encoded := buf.Bytes() + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + reader := msgp.NewReader(bytes.NewReader(encoded)) + var decoded Float32 + decoded.DecodeMsg(reader) + } + }) + } +} + +func BenchmarkFloat32_MarshalMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Float32) + for i := 0; i < size; i++ { + set[float32(i)] = struct{}{} + } + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + _, err := set.MarshalMsg(nil) + if err != nil { + b.Fatal(err) + } + } + }) + } +} + +func BenchmarkFloat32_UnmarshalMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Float32) + for i := 0; i < size; i++ { + set[float32(i)] = struct{}{} + } + + data, _ := set.MarshalMsg(nil) + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + var decoded Float32 + _, err := decoded.UnmarshalMsg(data) + if err != nil { + b.Fatal(err) + } + } + }) + } +} + +func BenchmarkFloat32_AsSlice(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Float32) + for i := 0; i < size; i++ { + set[float32(i)] = struct{}{} + } + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + _ = set.AsSlice() + } + }) + } +} + +func BenchmarkFloat32_FromSlice(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + slice := make([]float32, size) + for i := 0; i < size; i++ { + slice[i] = float32(i) + } + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + _ = Float32FromSlice(slice) + } + }) + } +} + +func BenchmarkFloat32Sorted_EncodeMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Float32Sorted) + for i := 0; i < size; i++ { + set[float32(i)] = struct{}{} + } + + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + buf.Reset() + writer.Reset(&buf) + set.EncodeMsg(writer) + writer.Flush() + } + }) + } +} + +func BenchmarkFloat32Sorted_DecodeMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Float32Sorted) + for i := 0; i < size; i++ { + set[float32(i)] = struct{}{} + } + + var buf bytes.Buffer + writer := msgp.NewWriter(&buf) + set.EncodeMsg(writer) + writer.Flush() + encoded := buf.Bytes() + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + reader := msgp.NewReader(bytes.NewReader(encoded)) + var decoded Float32Sorted + decoded.DecodeMsg(reader) + } + }) + } +} + +func BenchmarkFloat32Sorted_MarshalMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Float32Sorted) + for i := 0; i < size; i++ { + set[float32(i)] = struct{}{} + } + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + _, err := set.MarshalMsg(nil) + if err != nil { + b.Fatal(err) + } + } + }) + } +} + +func BenchmarkFloat32Sorted_UnmarshalMsg(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Float32Sorted) + for i := 0; i < size; i++ { + set[float32(i)] = struct{}{} + } + + data, _ := set.MarshalMsg(nil) + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + var decoded Float32Sorted + _, err := decoded.UnmarshalMsg(data) + if err != nil { + b.Fatal(err) + } + } + }) + } +} + +func BenchmarkFloat32Sorted_AsSlice(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + set := make(Float32Sorted) + for i := 0; i < size; i++ { + set[float32(i)] = struct{}{} + } + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + _ = set.AsSlice() + } + }) + } +} + +func BenchmarkFloat32Sorted_FromSlice(b *testing.B) { + sizes := []int{10, 100, 1000} + + for _, size := range sizes { + b.Run(fmt.Sprintf("%d", size), func(b *testing.B) { + slice := make([]float32, size) + for i := 0; i < size; i++ { + slice[i] = float32(i) + } + + b.ReportAllocs() + b.ResetTimer() + for i := 0; i < b.N; i++ { + _ = Float32SortedFromSlice(slice) + } + }) + } +} diff --git a/msgp/setof/setof.go b/msgp/setof/setof.go index f76c5d18..6e82c18c 100644 --- a/msgp/setof/setof.go +++ b/msgp/setof/setof.go @@ -5,3 +5,15 @@ // A deterministic, sorted version is available, with slightly lower performance. package setof + +// ensure 'sz' extra bytes in 'b' can be appended without reallocating +func ensure(b []byte, sz int) []byte { + l := len(b) + c := cap(b) + if c-l < sz { + o := make([]byte, l, l+sz) + copy(o, b) + return o + } + return b +}