From e8ea1a41db241dd98a76885786de4c660e52a934 Mon Sep 17 00:00:00 2001 From: Klaus Post Date: Sat, 15 Nov 2025 12:40:00 +0100 Subject: [PATCH 1/2] setof speed improvement and tests * Add tests/benchmarks * Use `slices.SortFunc` - slightly faster on non-strings. * Ensure MarshalMsg output can hold the output. * Minor cleanups. ``` benchmark old ns/op new ns/op delta BenchmarkStringSorted_EncodeMsg/10-32 212 203 -4.39% BenchmarkStringSorted_EncodeMsg/100-32 3893 3863 -0.77% BenchmarkStringSorted_EncodeMsg/1000-32 65046 64905 -0.22% BenchmarkStringSorted_DecodeMsg/10-32 617 628 +1.75% BenchmarkStringSorted_DecodeMsg/100-32 2996 3011 +0.50% BenchmarkStringSorted_DecodeMsg/1000-32 29909 30096 +0.63% BenchmarkStringSorted_MarshalMsg/10-32 246 269 +9.05% BenchmarkStringSorted_MarshalMsg/100-32 3991 4295 +7.62% BenchmarkStringSorted_MarshalMsg/1000-32 65655 69870 +6.42% BenchmarkStringSorted_UnmarshalMsg/10-32 290 290 +0.17% BenchmarkStringSorted_UnmarshalMsg/100-32 2522 2521 -0.04% BenchmarkStringSorted_UnmarshalMsg/1000-32 28134 27928 -0.73% BenchmarkStringSorted_AsSlice/10-32 233 163 -30.09% BenchmarkStringSorted_AsSlice/100-32 4318 3357 -22.26% BenchmarkStringSorted_AsSlice/1000-32 73060 61074 -16.41% BenchmarkStringSorted_FromSlice/10-32 158 160 +1.26% BenchmarkStringSorted_FromSlice/100-32 1083 1109 +2.40% BenchmarkStringSorted_FromSlice/1000-32 12169 12340 +1.41% BenchmarkIntSorted_EncodeMsg/10-32 192 143 -25.50% BenchmarkIntSorted_EncodeMsg/100-32 2705 2471 -8.65% BenchmarkIntSorted_EncodeMsg/1000-32 51959 47962 -7.69% BenchmarkIntSorted_DecodeMsg/10-32 548 526 -3.96% BenchmarkIntSorted_DecodeMsg/100-32 1492 1496 +0.27% BenchmarkIntSorted_DecodeMsg/1000-32 12371 12324 -0.38% BenchmarkIntSorted_MarshalMsg/10-32 205 150 -26.99% BenchmarkIntSorted_MarshalMsg/100-32 2662 2461 -7.55% BenchmarkIntSorted_MarshalMsg/1000-32 52221 48179 -7.74% BenchmarkIntSorted_UnmarshalMsg/10-32 153 156 +1.97% BenchmarkIntSorted_UnmarshalMsg/100-32 977 987 +1.01% BenchmarkIntSorted_UnmarshalMsg/1000-32 10424 10462 +0.36% BenchmarkIntSorted_AsSlice/10-32 170 119 -30.09% BenchmarkIntSorted_AsSlice/100-32 2472 2199 -11.04% BenchmarkIntSorted_AsSlice/1000-32 49548 46049 -7.06% BenchmarkIntSorted_FromSlice/10-32 140 138 -1.29% BenchmarkIntSorted_FromSlice/100-32 926 932 +0.69% BenchmarkIntSorted_FromSlice/1000-32 9589 9478 -1.16% BenchmarkUintSorted_EncodeMsg/10-32 190 129 -32.23% BenchmarkUintSorted_EncodeMsg/100-32 2591 2340 -9.69% BenchmarkUintSorted_EncodeMsg/1000-32 52587 48173 -8.39% BenchmarkUintSorted_DecodeMsg/10-32 534 536 +0.26% BenchmarkUintSorted_DecodeMsg/100-32 1482 1492 +0.67% BenchmarkUintSorted_DecodeMsg/1000-32 12374 12417 +0.35% BenchmarkUintSorted_MarshalMsg/10-32 192 140 -27.14% BenchmarkUintSorted_MarshalMsg/100-32 2695 2440 -9.46% BenchmarkUintSorted_MarshalMsg/1000-32 52282 47950 -8.29% BenchmarkUintSorted_UnmarshalMsg/10-32 151 153 +1.46% BenchmarkUintSorted_UnmarshalMsg/100-32 976 987 +1.07% BenchmarkUintSorted_UnmarshalMsg/1000-32 10355 10982 +6.06% BenchmarkUintSorted_AsSlice/10-32 163 119 -26.81% BenchmarkUintSorted_AsSlice/100-32 2396 2189 -8.64% BenchmarkUintSorted_AsSlice/1000-32 49923 46339 -7.18% BenchmarkUintSorted_FromSlice/10-32 138 141 +2.32% BenchmarkUintSorted_FromSlice/100-32 918 975 +6.29% BenchmarkUintSorted_FromSlice/1000-32 9445 9947 +5.31% BenchmarkByteSorted_EncodeMsg/10-32 174 122 -30.29% BenchmarkByteSorted_EncodeMsg/100-32 2565 2297 -10.45% BenchmarkByteSorted_EncodeMsg/1000-32 10087 9210 -8.69% BenchmarkByteSorted_DecodeMsg/10-32 556 568 +2.27% BenchmarkByteSorted_DecodeMsg/100-32 2183 2195 +0.55% BenchmarkByteSorted_DecodeMsg/1000-32 4792 4835 +0.90% BenchmarkByteSorted_MarshalMsg/10-32 178 120 -32.71% BenchmarkByteSorted_MarshalMsg/100-32 2552 2211 -13.36% BenchmarkByteSorted_MarshalMsg/1000-32 10094 8908 -11.75% BenchmarkByteSorted_UnmarshalMsg/10-32 212 212 -0.33% BenchmarkByteSorted_UnmarshalMsg/100-32 1751 1757 +0.34% BenchmarkByteSorted_UnmarshalMsg/1000-32 4247 4257 +0.24% BenchmarkByteSorted_AsSlice/10-32 147 101 -31.61% BenchmarkByteSorted_AsSlice/100-32 2298 2062 -10.27% BenchmarkByteSorted_AsSlice/1000-32 9505 8617 -9.34% BenchmarkByteSorted_FromSlice/10-32 189 191 +1.27% BenchmarkByteSorted_FromSlice/100-32 1710 1705 -0.29% BenchmarkByteSorted_FromSlice/1000-32 15630 15669 +0.25% BenchmarkInt8Sorted_EncodeMsg/10-32 176 124 -29.61% BenchmarkInt8Sorted_EncodeMsg/100-32 2576 2299 -10.75% BenchmarkInt8Sorted_EncodeMsg/1000-32 9862 9153 -7.19% BenchmarkInt8Sorted_DecodeMsg/10-32 556 563 +1.17% BenchmarkInt8Sorted_DecodeMsg/100-32 2138 2148 +0.47% BenchmarkInt8Sorted_DecodeMsg/1000-32 4798 4815 +0.35% BenchmarkInt8Sorted_MarshalMsg/10-32 197 128 -35.28% BenchmarkInt8Sorted_MarshalMsg/100-32 2578 2292 -11.09% BenchmarkInt8Sorted_MarshalMsg/1000-32 10138 9234 -8.92% BenchmarkInt8Sorted_UnmarshalMsg/10-32 213 213 +0.00% BenchmarkInt8Sorted_UnmarshalMsg/100-32 1756 1762 +0.34% BenchmarkInt8Sorted_UnmarshalMsg/1000-32 4319 4316 -0.07% BenchmarkInt8Sorted_AsSlice/10-32 142 105 -26.07% BenchmarkInt8Sorted_AsSlice/100-32 2415 2062 -14.62% BenchmarkInt8Sorted_AsSlice/1000-32 9573 8741 -8.69% BenchmarkInt8Sorted_FromSlice/10-32 190 190 +0.00% BenchmarkInt8Sorted_FromSlice/100-32 1711 1700 -0.64% BenchmarkInt8Sorted_FromSlice/1000-32 15669 15624 -0.29% BenchmarkUint8Sorted_EncodeMsg/10-32 176 114 -35.09% BenchmarkUint8Sorted_EncodeMsg/100-32 2553 2212 -13.36% BenchmarkUint8Sorted_EncodeMsg/1000-32 9998 9314 -6.84% BenchmarkUint8Sorted_DecodeMsg/10-32 552 563 +1.86% BenchmarkUint8Sorted_DecodeMsg/100-32 2181 2200 +0.87% BenchmarkUint8Sorted_DecodeMsg/1000-32 4792 4801 +0.19% BenchmarkUint8Sorted_MarshalMsg/10-32 187 107 -42.85% BenchmarkUint8Sorted_MarshalMsg/100-32 2640 2194 -16.89% BenchmarkUint8Sorted_MarshalMsg/1000-32 10076 9210 -8.59% BenchmarkUint8Sorted_UnmarshalMsg/10-32 215 215 +0.05% BenchmarkUint8Sorted_UnmarshalMsg/100-32 1803 1808 +0.28% BenchmarkUint8Sorted_UnmarshalMsg/1000-32 4394 4413 +0.43% BenchmarkUint8Sorted_AsSlice/10-32 147 92.5 -36.92% BenchmarkUint8Sorted_AsSlice/100-32 2340 2085 -10.90% BenchmarkUint8Sorted_AsSlice/1000-32 9405 8631 -8.23% BenchmarkUint8Sorted_FromSlice/10-32 189 189 +0.32% BenchmarkUint8Sorted_FromSlice/100-32 1710 1710 +0.00% BenchmarkUint8Sorted_FromSlice/1000-32 15675 15674 -0.01% BenchmarkInt16Sorted_EncodeMsg/10-32 179 132 -26.20% BenchmarkInt16Sorted_EncodeMsg/100-32 2701 2365 -12.44% BenchmarkInt16Sorted_EncodeMsg/1000-32 51059 48068 -5.86% BenchmarkInt16Sorted_DecodeMsg/10-32 561 566 +0.86% BenchmarkInt16Sorted_DecodeMsg/100-32 2164 2167 +0.14% BenchmarkInt16Sorted_DecodeMsg/1000-32 19649 19796 +0.75% BenchmarkInt16Sorted_MarshalMsg/10-32 208 132 -36.66% BenchmarkInt16Sorted_MarshalMsg/100-32 2684 2338 -12.89% BenchmarkInt16Sorted_MarshalMsg/1000-32 51687 47348 -8.39% BenchmarkInt16Sorted_UnmarshalMsg/10-32 217 216 -0.41% BenchmarkInt16Sorted_UnmarshalMsg/100-32 1806 1816 +0.55% BenchmarkInt16Sorted_UnmarshalMsg/1000-32 18727 18555 -0.92% BenchmarkInt16Sorted_AsSlice/10-32 155 115 -25.92% BenchmarkInt16Sorted_AsSlice/100-32 2401 2148 -10.54% BenchmarkInt16Sorted_AsSlice/1000-32 49032 45245 -7.72% BenchmarkInt16Sorted_FromSlice/10-32 141 143 +1.21% BenchmarkInt16Sorted_FromSlice/100-32 1099 1108 +0.82% BenchmarkInt16Sorted_FromSlice/1000-32 10972 11142 +1.55% BenchmarkUint16Sorted_EncodeMsg/10-32 180 119 -33.59% BenchmarkUint16Sorted_EncodeMsg/100-32 2572 2363 -8.13% BenchmarkUint16Sorted_EncodeMsg/1000-32 51598 47780 -7.40% BenchmarkUint16Sorted_DecodeMsg/10-32 572 568 -0.68% BenchmarkUint16Sorted_DecodeMsg/100-32 2241 2233 -0.36% BenchmarkUint16Sorted_DecodeMsg/1000-32 20000 20276 +1.38% BenchmarkUint16Sorted_MarshalMsg/10-32 188 125 -33.74% BenchmarkUint16Sorted_MarshalMsg/100-32 2543 2330 -8.38% BenchmarkUint16Sorted_MarshalMsg/1000-32 51485 47576 -7.59% BenchmarkUint16Sorted_UnmarshalMsg/10-32 218 218 +0.00% BenchmarkUint16Sorted_UnmarshalMsg/100-32 1826 1839 +0.71% BenchmarkUint16Sorted_UnmarshalMsg/1000-32 18716 18768 +0.28% BenchmarkUint16Sorted_AsSlice/10-32 151 107 -29.59% BenchmarkUint16Sorted_AsSlice/100-32 2349 2116 -9.92% BenchmarkUint16Sorted_AsSlice/1000-32 49028 45539 -7.12% BenchmarkUint16Sorted_FromSlice/10-32 142 143 +0.56% BenchmarkUint16Sorted_FromSlice/100-32 1098 1102 +0.36% BenchmarkUint16Sorted_FromSlice/1000-32 11103 11145 +0.38% BenchmarkInt32Sorted_EncodeMsg/10-32 193 145 -24.88% BenchmarkInt32Sorted_EncodeMsg/100-32 2678 2344 -12.47% BenchmarkInt32Sorted_EncodeMsg/1000-32 51852 47827 -7.76% BenchmarkInt32Sorted_DecodeMsg/10-32 524 532 +1.59% BenchmarkInt32Sorted_DecodeMsg/100-32 1391 1419 +2.01% BenchmarkInt32Sorted_DecodeMsg/1000-32 11500 11323 -1.54% BenchmarkInt32Sorted_MarshalMsg/10-32 199 144 -27.62% BenchmarkInt32Sorted_MarshalMsg/100-32 2597 2340 -9.90% BenchmarkInt32Sorted_MarshalMsg/1000-32 52071 47451 -8.87% BenchmarkInt32Sorted_UnmarshalMsg/10-32 143 143 +0.35% BenchmarkInt32Sorted_UnmarshalMsg/100-32 946 952 +0.62% BenchmarkInt32Sorted_UnmarshalMsg/1000-32 9359 9423 +0.68% BenchmarkInt32Sorted_AsSlice/10-32 165 113 -31.55% BenchmarkInt32Sorted_AsSlice/100-32 2395 2132 -10.98% BenchmarkInt32Sorted_AsSlice/1000-32 49651 45541 -8.28% BenchmarkInt32Sorted_FromSlice/10-32 124 126 +1.61% BenchmarkInt32Sorted_FromSlice/100-32 862 862 +0.06% BenchmarkInt32Sorted_FromSlice/1000-32 8227 8159 -0.83% BenchmarkUint32Sorted_EncodeMsg/10-32 176 142 -19.01% BenchmarkUint32Sorted_EncodeMsg/100-32 2632 2273 -13.64% BenchmarkUint32Sorted_EncodeMsg/1000-32 51857 47461 -8.48% BenchmarkUint32Sorted_DecodeMsg/10-32 533 533 +0.04% BenchmarkUint32Sorted_DecodeMsg/100-32 1409 1417 +0.57% BenchmarkUint32Sorted_DecodeMsg/1000-32 11482 11210 -2.37% BenchmarkUint32Sorted_MarshalMsg/10-32 198 142 -28.20% BenchmarkUint32Sorted_MarshalMsg/100-32 2575 2319 -9.94% BenchmarkUint32Sorted_MarshalMsg/1000-32 52352 47407 -9.45% BenchmarkUint32Sorted_UnmarshalMsg/10-32 158 144 -8.62% BenchmarkUint32Sorted_UnmarshalMsg/100-32 1107 956 -13.60% BenchmarkUint32Sorted_UnmarshalMsg/1000-32 10596 10779 +1.73% BenchmarkUint32Sorted_AsSlice/10-32 175 116 -33.58% BenchmarkUint32Sorted_AsSlice/100-32 2469 2212 -10.41% BenchmarkUint32Sorted_AsSlice/1000-32 50517 47107 -6.75% BenchmarkUint32Sorted_FromSlice/10-32 135 137 +1.18% BenchmarkUint32Sorted_FromSlice/100-32 923 935 +1.30% BenchmarkUint32Sorted_FromSlice/1000-32 8905 9101 +2.20% BenchmarkInt64Sorted_EncodeMsg/10-32 207 156 -24.46% BenchmarkInt64Sorted_EncodeMsg/100-32 2833 2658 -6.18% BenchmarkInt64Sorted_EncodeMsg/1000-32 57355 50588 -11.80% BenchmarkInt64Sorted_DecodeMsg/10-32 615 624 +1.43% BenchmarkInt64Sorted_DecodeMsg/100-32 1693 1710 +1.00% BenchmarkInt64Sorted_DecodeMsg/1000-32 13748 13940 +1.40% BenchmarkInt64Sorted_MarshalMsg/10-32 216 164 -23.75% BenchmarkInt64Sorted_MarshalMsg/100-32 2804 2724 -2.85% BenchmarkInt64Sorted_MarshalMsg/1000-32 54654 53007 -3.01% BenchmarkInt64Sorted_UnmarshalMsg/10-32 174 178 +2.59% BenchmarkInt64Sorted_UnmarshalMsg/100-32 1100 1116 +1.45% BenchmarkInt64Sorted_UnmarshalMsg/1000-32 12255 12185 -0.57% BenchmarkInt64Sorted_AsSlice/10-32 173 122 -29.59% BenchmarkInt64Sorted_AsSlice/100-32 2720 2408 -11.47% BenchmarkInt64Sorted_AsSlice/1000-32 51257 48403 -5.57% BenchmarkInt64Sorted_FromSlice/10-32 155 157 +1.23% BenchmarkInt64Sorted_FromSlice/100-32 1044 1051 +0.67% BenchmarkInt64Sorted_FromSlice/1000-32 11198 11641 +3.96% BenchmarkUint64Sorted_EncodeMsg/10-32 207 159 -23.37% BenchmarkUint64Sorted_EncodeMsg/100-32 2793 2770 -0.82% BenchmarkUint64Sorted_EncodeMsg/1000-32 53759 50802 -5.50% BenchmarkUint64Sorted_DecodeMsg/10-32 660 676 +2.39% BenchmarkUint64Sorted_DecodeMsg/100-32 1776 1782 +0.34% BenchmarkUint64Sorted_DecodeMsg/1000-32 14571 14678 +0.73% BenchmarkUint64Sorted_MarshalMsg/10-32 212 164 -22.91% BenchmarkUint64Sorted_MarshalMsg/100-32 2889 2665 -7.75% BenchmarkUint64Sorted_MarshalMsg/1000-32 54186 50858 -6.14% BenchmarkUint64Sorted_UnmarshalMsg/10-32 177 179 +0.96% BenchmarkUint64Sorted_UnmarshalMsg/100-32 1124 1143 +1.69% BenchmarkUint64Sorted_UnmarshalMsg/1000-32 12460 12793 +2.67% BenchmarkUint64Sorted_AsSlice/10-32 186 119 -36.25% BenchmarkUint64Sorted_AsSlice/100-32 2607 2368 -9.17% BenchmarkUint64Sorted_AsSlice/1000-32 51618 48003 -7.00% BenchmarkUint64Sorted_FromSlice/10-32 158 160 +1.39% BenchmarkUint64Sorted_FromSlice/100-32 1073 1069 -0.37% BenchmarkUint64Sorted_FromSlice/1000-32 11172 11630 +4.10% BenchmarkFloat64Sorted_EncodeMsg/10-32 199 150 -24.22% BenchmarkFloat64Sorted_EncodeMsg/100-32 2940 2760 -6.12% BenchmarkFloat64Sorted_EncodeMsg/1000-32 57184 55369 -3.17% BenchmarkFloat64Sorted_DecodeMsg/10-32 760 793 +4.32% BenchmarkFloat64Sorted_DecodeMsg/100-32 2873 2913 +1.39% BenchmarkFloat64Sorted_DecodeMsg/1000-32 27272 27727 +1.67% BenchmarkFloat64Sorted_MarshalMsg/10-32 274 172 -37.11% BenchmarkFloat64Sorted_MarshalMsg/100-32 3191 3010 -5.67% BenchmarkFloat64Sorted_MarshalMsg/1000-32 60777 56777 -6.58% BenchmarkFloat64Sorted_UnmarshalMsg/10-32 259 262 +1.08% BenchmarkFloat64Sorted_UnmarshalMsg/100-32 2131 2176 +2.11% BenchmarkFloat64Sorted_UnmarshalMsg/1000-32 22264 22952 +3.09% BenchmarkFloat64Sorted_AsSlice/10-32 171 123 -28.10% BenchmarkFloat64Sorted_AsSlice/100-32 2712 2561 -5.57% BenchmarkFloat64Sorted_AsSlice/1000-32 54985 53087 -3.45% BenchmarkFloat64Sorted_FromSlice/10-32 222 237 +7.04% BenchmarkFloat64Sorted_FromSlice/100-32 1913 1942 +1.52% BenchmarkFloat64Sorted_FromSlice/1000-32 22761 23455 +3.05% BenchmarkFloat32Sorted_EncodeMsg/10-32 193 135 -29.96% BenchmarkFloat32Sorted_EncodeMsg/100-32 2890 2624 -9.20% BenchmarkFloat32Sorted_EncodeMsg/1000-32 56231 53821 -4.29% BenchmarkFloat32Sorted_DecodeMsg/10-32 715 736 +2.87% BenchmarkFloat32Sorted_DecodeMsg/100-32 2527 2542 +0.59% BenchmarkFloat32Sorted_DecodeMsg/1000-32 22848 23154 +1.34% BenchmarkFloat32Sorted_MarshalMsg/10-32 260 151 -42.08% BenchmarkFloat32Sorted_MarshalMsg/100-32 3029 2848 -5.98% BenchmarkFloat32Sorted_MarshalMsg/1000-32 58618 54510 -7.01% BenchmarkFloat32Sorted_UnmarshalMsg/10-32 237 241 +1.43% BenchmarkFloat32Sorted_UnmarshalMsg/100-32 1976 1989 +0.66% BenchmarkFloat32Sorted_UnmarshalMsg/1000-32 20990 21158 +0.80% BenchmarkFloat32Sorted_AsSlice/10-32 168 114 -31.93% BenchmarkFloat32Sorted_AsSlice/100-32 2621 2506 -4.39% BenchmarkFloat32Sorted_AsSlice/1000-32 54476 52322 -3.95% BenchmarkFloat32Sorted_FromSlice/10-32 202 205 +1.58% BenchmarkFloat32Sorted_FromSlice/100-32 1797 1830 +1.84% BenchmarkFloat32Sorted_FromSlice/1000-32 21163 21556 +1.86% ``` --- msgp/setof/_gen/main.go | 605 ++- msgp/setof/generated.go | 584 ++- msgp/setof/generated_test.go | 9251 ++++++++++++++++++++++++++++++++++ msgp/setof/setof.go | 12 + 4 files changed, 10214 insertions(+), 238 deletions(-) create mode 100644 msgp/setof/generated_test.go 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..15377109 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, len(b), (2*c)+sz) // exponential growth + copy(o, b) + return o + } + return b +} From 2d29dbbacc3397373627873393de6663848289ae Mon Sep 17 00:00:00 2001 From: Klaus Post Date: Sat, 15 Nov 2025 15:53:02 +0100 Subject: [PATCH 2/2] Don't over-alloc --- msgp/setof/setof.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/msgp/setof/setof.go b/msgp/setof/setof.go index 15377109..6e82c18c 100644 --- a/msgp/setof/setof.go +++ b/msgp/setof/setof.go @@ -11,7 +11,7 @@ func ensure(b []byte, sz int) []byte { l := len(b) c := cap(b) if c-l < sz { - o := make([]byte, len(b), (2*c)+sz) // exponential growth + o := make([]byte, l, l+sz) copy(o, b) return o }