mirror of
https://github.com/IBM/fp-go.git
synced 2025-11-23 22:14:53 +02:00
529 lines
12 KiB
Go
529 lines
12 KiB
Go
// Copyright (c) 2023 - 2025 IBM Corp.
|
|
// All rights reserved.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
package bytes
|
|
|
|
import (
|
|
"testing"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
)
|
|
|
|
func TestEmpty(t *testing.T) {
|
|
t.Run("returns empty byte slice", func(t *testing.T) {
|
|
result := Empty()
|
|
assert.NotNil(t, result)
|
|
assert.Equal(t, 0, len(result))
|
|
})
|
|
|
|
t.Run("is identity for Monoid", func(t *testing.T) {
|
|
data := []byte("test")
|
|
|
|
// Left identity: empty + data = data
|
|
left := Monoid.Concat(Empty(), data)
|
|
assert.Equal(t, data, left)
|
|
|
|
// Right identity: data + empty = data
|
|
right := Monoid.Concat(data, Empty())
|
|
assert.Equal(t, data, right)
|
|
})
|
|
}
|
|
|
|
func TestToString(t *testing.T) {
|
|
t.Run("converts byte slice to string", func(t *testing.T) {
|
|
result := ToString([]byte("hello"))
|
|
assert.Equal(t, "hello", result)
|
|
})
|
|
|
|
t.Run("handles empty byte slice", func(t *testing.T) {
|
|
result := ToString([]byte{})
|
|
assert.Equal(t, "", result)
|
|
})
|
|
|
|
t.Run("handles binary data", func(t *testing.T) {
|
|
data := []byte{0x48, 0x65, 0x6c, 0x6c, 0x6f} // "Hello"
|
|
result := ToString(data)
|
|
assert.Equal(t, "Hello", result)
|
|
})
|
|
}
|
|
|
|
func TestSize(t *testing.T) {
|
|
t.Run("returns size of byte slice", func(t *testing.T) {
|
|
assert.Equal(t, 0, Size([]byte{}))
|
|
assert.Equal(t, 5, Size([]byte("hello")))
|
|
assert.Equal(t, 10, Size([]byte("0123456789")))
|
|
})
|
|
|
|
t.Run("handles binary data", func(t *testing.T) {
|
|
data := []byte{0x00, 0x01, 0x02, 0x03}
|
|
assert.Equal(t, 4, Size(data))
|
|
})
|
|
}
|
|
|
|
func TestMonoidConcat(t *testing.T) {
|
|
t.Run("concatenates two byte slices", func(t *testing.T) {
|
|
result := Monoid.Concat([]byte("Hello"), []byte(" World"))
|
|
assert.Equal(t, []byte("Hello World"), result)
|
|
})
|
|
|
|
t.Run("handles empty slices", func(t *testing.T) {
|
|
result1 := Monoid.Concat([]byte{}, []byte("test"))
|
|
assert.Equal(t, []byte("test"), result1)
|
|
|
|
result2 := Monoid.Concat([]byte("test"), []byte{})
|
|
assert.Equal(t, []byte("test"), result2)
|
|
|
|
result3 := Monoid.Concat([]byte{}, []byte{})
|
|
assert.Equal(t, []byte{}, result3)
|
|
})
|
|
|
|
t.Run("associativity: (a + b) + c = a + (b + c)", func(t *testing.T) {
|
|
a := []byte("a")
|
|
b := []byte("b")
|
|
c := []byte("c")
|
|
|
|
left := Monoid.Concat(Monoid.Concat(a, b), c)
|
|
right := Monoid.Concat(a, Monoid.Concat(b, c))
|
|
|
|
assert.Equal(t, left, right)
|
|
})
|
|
}
|
|
|
|
func TestConcatAll(t *testing.T) {
|
|
t.Run("concatenates multiple byte slices", func(t *testing.T) {
|
|
result := ConcatAll(
|
|
[]byte("Hello"),
|
|
[]byte(" "),
|
|
[]byte("World"),
|
|
[]byte("!"),
|
|
)
|
|
assert.Equal(t, []byte("Hello World!"), result)
|
|
})
|
|
|
|
t.Run("handles empty input", func(t *testing.T) {
|
|
result := ConcatAll()
|
|
assert.Equal(t, []byte{}, result)
|
|
})
|
|
|
|
t.Run("handles single slice", func(t *testing.T) {
|
|
result := ConcatAll([]byte("test"))
|
|
assert.Equal(t, []byte("test"), result)
|
|
})
|
|
|
|
t.Run("handles slices with empty elements", func(t *testing.T) {
|
|
result := ConcatAll(
|
|
[]byte("a"),
|
|
[]byte{},
|
|
[]byte("b"),
|
|
[]byte{},
|
|
[]byte("c"),
|
|
)
|
|
assert.Equal(t, []byte("abc"), result)
|
|
})
|
|
|
|
t.Run("handles binary data", func(t *testing.T) {
|
|
result := ConcatAll(
|
|
[]byte{0x01, 0x02},
|
|
[]byte{0x03, 0x04},
|
|
[]byte{0x05},
|
|
)
|
|
assert.Equal(t, []byte{0x01, 0x02, 0x03, 0x04, 0x05}, result)
|
|
})
|
|
}
|
|
|
|
func TestOrd(t *testing.T) {
|
|
t.Run("compares byte slices lexicographically", func(t *testing.T) {
|
|
// "abc" < "abd"
|
|
assert.Equal(t, -1, Ord.Compare([]byte("abc"), []byte("abd")))
|
|
|
|
// "abd" > "abc"
|
|
assert.Equal(t, 1, Ord.Compare([]byte("abd"), []byte("abc")))
|
|
|
|
// "abc" == "abc"
|
|
assert.Equal(t, 0, Ord.Compare([]byte("abc"), []byte("abc")))
|
|
})
|
|
|
|
t.Run("handles different lengths", func(t *testing.T) {
|
|
// "ab" < "abc"
|
|
assert.Equal(t, -1, Ord.Compare([]byte("ab"), []byte("abc")))
|
|
|
|
// "abc" > "ab"
|
|
assert.Equal(t, 1, Ord.Compare([]byte("abc"), []byte("ab")))
|
|
})
|
|
|
|
t.Run("handles empty slices", func(t *testing.T) {
|
|
// "" < "a"
|
|
assert.Equal(t, -1, Ord.Compare([]byte{}, []byte("a")))
|
|
|
|
// "a" > ""
|
|
assert.Equal(t, 1, Ord.Compare([]byte("a"), []byte{}))
|
|
|
|
// "" == ""
|
|
assert.Equal(t, 0, Ord.Compare([]byte{}, []byte{}))
|
|
})
|
|
|
|
t.Run("Equals method works", func(t *testing.T) {
|
|
assert.True(t, Ord.Equals([]byte("test"), []byte("test")))
|
|
assert.False(t, Ord.Equals([]byte("test"), []byte("Test")))
|
|
assert.True(t, Ord.Equals([]byte{}, []byte{}))
|
|
})
|
|
|
|
t.Run("handles binary data", func(t *testing.T) {
|
|
assert.Equal(t, -1, Ord.Compare([]byte{0x01}, []byte{0x02}))
|
|
assert.Equal(t, 1, Ord.Compare([]byte{0x02}, []byte{0x01}))
|
|
assert.Equal(t, 0, Ord.Compare([]byte{0x01, 0x02}, []byte{0x01, 0x02}))
|
|
})
|
|
}
|
|
|
|
// TestOrdProperties tests mathematical properties of Ord
|
|
func TestOrdProperties(t *testing.T) {
|
|
t.Run("reflexivity: x == x", func(t *testing.T) {
|
|
testCases := [][]byte{
|
|
[]byte{},
|
|
[]byte("a"),
|
|
[]byte("test"),
|
|
[]byte{0x01, 0x02, 0x03},
|
|
}
|
|
|
|
for _, tc := range testCases {
|
|
assert.Equal(t, 0, Ord.Compare(tc, tc),
|
|
"Compare(%v, %v) should be 0", tc, tc)
|
|
assert.True(t, Ord.Equals(tc, tc),
|
|
"Equals(%v, %v) should be true", tc, tc)
|
|
}
|
|
})
|
|
|
|
t.Run("antisymmetry: if x <= y and y <= x then x == y", func(t *testing.T) {
|
|
testCases := []struct {
|
|
a, b []byte
|
|
}{
|
|
{[]byte("abc"), []byte("abc")},
|
|
{[]byte{}, []byte{}},
|
|
{[]byte{0x01}, []byte{0x01}},
|
|
}
|
|
|
|
for _, tc := range testCases {
|
|
cmp1 := Ord.Compare(tc.a, tc.b)
|
|
cmp2 := Ord.Compare(tc.b, tc.a)
|
|
|
|
if cmp1 <= 0 && cmp2 <= 0 {
|
|
assert.True(t, Ord.Equals(tc.a, tc.b),
|
|
"If %v <= %v and %v <= %v, they should be equal", tc.a, tc.b, tc.b, tc.a)
|
|
}
|
|
}
|
|
})
|
|
|
|
t.Run("transitivity: if x <= y and y <= z then x <= z", func(t *testing.T) {
|
|
x := []byte("a")
|
|
y := []byte("b")
|
|
z := []byte("c")
|
|
|
|
cmpXY := Ord.Compare(x, y)
|
|
cmpYZ := Ord.Compare(y, z)
|
|
cmpXZ := Ord.Compare(x, z)
|
|
|
|
if cmpXY <= 0 && cmpYZ <= 0 {
|
|
assert.True(t, cmpXZ <= 0,
|
|
"If %v <= %v and %v <= %v, then %v <= %v", x, y, y, z, x, z)
|
|
}
|
|
})
|
|
|
|
t.Run("totality: either x <= y or y <= x", func(t *testing.T) {
|
|
testCases := []struct {
|
|
a, b []byte
|
|
}{
|
|
{[]byte("abc"), []byte("abd")},
|
|
{[]byte("xyz"), []byte("abc")},
|
|
{[]byte{}, []byte("a")},
|
|
{[]byte{0x01}, []byte{0x02}},
|
|
}
|
|
|
|
for _, tc := range testCases {
|
|
cmp1 := Ord.Compare(tc.a, tc.b)
|
|
cmp2 := Ord.Compare(tc.b, tc.a)
|
|
|
|
assert.True(t, cmp1 <= 0 || cmp2 <= 0,
|
|
"Either %v <= %v or %v <= %v must be true", tc.a, tc.b, tc.b, tc.a)
|
|
}
|
|
})
|
|
}
|
|
|
|
// TestEdgeCases tests edge cases and boundary conditions
|
|
func TestEdgeCases(t *testing.T) {
|
|
t.Run("very large byte slices", func(t *testing.T) {
|
|
large := make([]byte, 1000000)
|
|
for i := range large {
|
|
large[i] = byte(i % 256)
|
|
}
|
|
|
|
size := Size(large)
|
|
assert.Equal(t, 1000000, size)
|
|
|
|
str := ToString(large)
|
|
assert.Equal(t, 1000000, len(str))
|
|
})
|
|
|
|
t.Run("concatenating many slices", func(t *testing.T) {
|
|
slices := make([][]byte, 100)
|
|
for i := range slices {
|
|
slices[i] = []byte{byte(i)}
|
|
}
|
|
|
|
result := ConcatAll(slices...)
|
|
assert.Equal(t, 100, Size(result))
|
|
})
|
|
|
|
t.Run("null bytes in slice", func(t *testing.T) {
|
|
data := []byte{0x00, 0x01, 0x00, 0x02}
|
|
size := Size(data)
|
|
assert.Equal(t, 4, size)
|
|
|
|
str := ToString(data)
|
|
assert.Equal(t, 4, len(str))
|
|
})
|
|
|
|
t.Run("comparing slices with null bytes", func(t *testing.T) {
|
|
a := []byte{0x00, 0x01}
|
|
b := []byte{0x00, 0x02}
|
|
assert.Equal(t, -1, Ord.Compare(a, b))
|
|
})
|
|
}
|
|
|
|
// TestMonoidConcatPerformance tests concatenation performance characteristics
|
|
func TestMonoidConcatPerformance(t *testing.T) {
|
|
t.Run("ConcatAll vs repeated Concat", func(t *testing.T) {
|
|
slices := [][]byte{
|
|
[]byte("a"),
|
|
[]byte("b"),
|
|
[]byte("c"),
|
|
[]byte("d"),
|
|
[]byte("e"),
|
|
}
|
|
|
|
// Using ConcatAll
|
|
result1 := ConcatAll(slices...)
|
|
|
|
// Using repeated Concat
|
|
result2 := Monoid.Empty()
|
|
for _, s := range slices {
|
|
result2 = Monoid.Concat(result2, s)
|
|
}
|
|
|
|
assert.Equal(t, result1, result2)
|
|
assert.Equal(t, []byte("abcde"), result1)
|
|
})
|
|
}
|
|
|
|
// TestRoundTrip tests round-trip conversions
|
|
func TestRoundTrip(t *testing.T) {
|
|
t.Run("string to bytes to string", func(t *testing.T) {
|
|
original := "Hello, World! 世界"
|
|
bytes := []byte(original)
|
|
result := ToString(bytes)
|
|
assert.Equal(t, original, result)
|
|
})
|
|
|
|
t.Run("bytes to string to bytes", func(t *testing.T) {
|
|
original := []byte{0x48, 0x65, 0x6c, 0x6c, 0x6f}
|
|
str := ToString(original)
|
|
result := []byte(str)
|
|
assert.Equal(t, original, result)
|
|
})
|
|
}
|
|
|
|
// TestConcatAllVariadic tests ConcatAll with various argument counts
|
|
func TestConcatAllVariadic(t *testing.T) {
|
|
t.Run("zero arguments", func(t *testing.T) {
|
|
result := ConcatAll()
|
|
assert.Equal(t, []byte{}, result)
|
|
})
|
|
|
|
t.Run("one argument", func(t *testing.T) {
|
|
result := ConcatAll([]byte("test"))
|
|
assert.Equal(t, []byte("test"), result)
|
|
})
|
|
|
|
t.Run("two arguments", func(t *testing.T) {
|
|
result := ConcatAll([]byte("hello"), []byte("world"))
|
|
assert.Equal(t, []byte("helloworld"), result)
|
|
})
|
|
|
|
t.Run("many arguments", func(t *testing.T) {
|
|
result := ConcatAll(
|
|
[]byte("a"),
|
|
[]byte("b"),
|
|
[]byte("c"),
|
|
[]byte("d"),
|
|
[]byte("e"),
|
|
[]byte("f"),
|
|
[]byte("g"),
|
|
[]byte("h"),
|
|
[]byte("i"),
|
|
[]byte("j"),
|
|
)
|
|
assert.Equal(t, []byte("abcdefghij"), result)
|
|
})
|
|
}
|
|
|
|
// Benchmark tests
|
|
func BenchmarkToString(b *testing.B) {
|
|
data := []byte("Hello, World!")
|
|
|
|
b.Run("small", func(b *testing.B) {
|
|
for b.Loop() {
|
|
_ = ToString(data)
|
|
}
|
|
})
|
|
|
|
b.Run("large", func(b *testing.B) {
|
|
large := make([]byte, 10000)
|
|
for i := range large {
|
|
large[i] = byte(i % 256)
|
|
}
|
|
b.ResetTimer()
|
|
for b.Loop() {
|
|
_ = ToString(large)
|
|
}
|
|
})
|
|
}
|
|
|
|
func BenchmarkSize(b *testing.B) {
|
|
data := []byte("Hello, World!")
|
|
|
|
for b.Loop() {
|
|
_ = Size(data)
|
|
}
|
|
}
|
|
|
|
func BenchmarkMonoidConcat(b *testing.B) {
|
|
a := []byte("Hello")
|
|
c := []byte(" World")
|
|
|
|
b.Run("small slices", func(b *testing.B) {
|
|
for b.Loop() {
|
|
_ = Monoid.Concat(a, c)
|
|
}
|
|
})
|
|
|
|
b.Run("large slices", func(b *testing.B) {
|
|
large1 := make([]byte, 10000)
|
|
large2 := make([]byte, 10000)
|
|
b.ResetTimer()
|
|
for b.Loop() {
|
|
_ = Monoid.Concat(large1, large2)
|
|
}
|
|
})
|
|
}
|
|
|
|
func BenchmarkConcatAll(b *testing.B) {
|
|
slices := [][]byte{
|
|
[]byte("Hello"),
|
|
[]byte(" "),
|
|
[]byte("World"),
|
|
[]byte("!"),
|
|
}
|
|
|
|
b.Run("few slices", func(b *testing.B) {
|
|
for b.Loop() {
|
|
_ = ConcatAll(slices...)
|
|
}
|
|
})
|
|
|
|
b.Run("many slices", func(b *testing.B) {
|
|
many := make([][]byte, 100)
|
|
for i := range many {
|
|
many[i] = []byte{byte(i)}
|
|
}
|
|
b.ResetTimer()
|
|
for b.Loop() {
|
|
_ = ConcatAll(many...)
|
|
}
|
|
})
|
|
}
|
|
|
|
func BenchmarkOrdCompare(b *testing.B) {
|
|
a := []byte("abc")
|
|
c := []byte("abd")
|
|
|
|
b.Run("equal", func(b *testing.B) {
|
|
for b.Loop() {
|
|
_ = Ord.Compare(a, a)
|
|
}
|
|
})
|
|
|
|
b.Run("different", func(b *testing.B) {
|
|
for b.Loop() {
|
|
_ = Ord.Compare(a, c)
|
|
}
|
|
})
|
|
|
|
b.Run("large slices", func(b *testing.B) {
|
|
large1 := make([]byte, 10000)
|
|
large2 := make([]byte, 10000)
|
|
large2[9999] = 1
|
|
b.ResetTimer()
|
|
for b.Loop() {
|
|
_ = Ord.Compare(large1, large2)
|
|
}
|
|
})
|
|
}
|
|
|
|
// Example tests
|
|
func ExampleEmpty() {
|
|
empty := Empty()
|
|
println(len(empty)) // 0
|
|
|
|
// Output:
|
|
}
|
|
|
|
func ExampleToString() {
|
|
str := ToString([]byte("hello"))
|
|
println(str) // hello
|
|
|
|
// Output:
|
|
}
|
|
|
|
func ExampleSize() {
|
|
size := Size([]byte("hello"))
|
|
println(size) // 5
|
|
|
|
// Output:
|
|
}
|
|
|
|
func ExampleConcatAll() {
|
|
result := ConcatAll(
|
|
[]byte("Hello"),
|
|
[]byte(" "),
|
|
[]byte("World"),
|
|
)
|
|
println(string(result)) // Hello World
|
|
|
|
// Output:
|
|
}
|
|
|
|
func ExampleMonoid_concat() {
|
|
result := Monoid.Concat([]byte("Hello"), []byte(" World"))
|
|
println(string(result)) // Hello World
|
|
|
|
// Output:
|
|
}
|
|
|
|
func ExampleOrd_compare() {
|
|
cmp := Ord.Compare([]byte("abc"), []byte("abd"))
|
|
println(cmp) // -1 (abc < abd)
|
|
|
|
// Output:
|
|
}
|