122 lines
3.1 KiB
Go
122 lines
3.1 KiB
Go
package mem_test
|
|
|
|
import (
|
|
"testing"
|
|
"unsafe"
|
|
|
|
"git.brut.systems/judah/xx/mem"
|
|
"git.brut.systems/judah/xx/testx"
|
|
)
|
|
|
|
func TestBitCast(t *testing.T) {
|
|
a := uint32(0xFFFF_FFFF)
|
|
b := mem.BitCast[float32](&a)
|
|
c := mem.BitCast[uint32](&b)
|
|
if a != c {
|
|
t.Fail()
|
|
}
|
|
|
|
v := uint8(0xFF)
|
|
d := mem.BitCast[int8](&v)
|
|
if d != -1 {
|
|
t.Fail()
|
|
}
|
|
e := mem.BitCast[uint8](&d)
|
|
if e != 255 {
|
|
t.Fail()
|
|
}
|
|
}
|
|
|
|
func TestMemoryPrimitives(t *testing.T) {
|
|
t.Run("copy", func(t *testing.T) {
|
|
{ // non-overlapping
|
|
a := []int{1, 2, 3, 4, 5, 6}
|
|
b := make([]int, 3)
|
|
mem.Copy(unsafe.Pointer(&b[0]), unsafe.Pointer(&a[0]), uintptr(len(b))*unsafe.Sizeof(int(0)))
|
|
|
|
for i := range len(b) {
|
|
testx.Expect(t, a[i] == b[i], "%d != %d [%d]", a[i], b[i], i)
|
|
}
|
|
}
|
|
|
|
{ // overlapping
|
|
a := []int{1, 2, 3, 4, 5}
|
|
b := &a[0]
|
|
mem.Copy(unsafe.Pointer(b), unsafe.Pointer(&a[0]), uintptr(len(a))*unsafe.Sizeof(int(0)))
|
|
|
|
for i := range len(a) {
|
|
testx.Expect(t, a[i] == i+1, "[%d] %d != %d", i, a[i], i+1)
|
|
}
|
|
}
|
|
})
|
|
|
|
t.Run("clear", func(t *testing.T) {
|
|
{ // zero
|
|
v := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
|
|
mem.Clear(unsafe.Pointer(&v[0]), 0, uintptr(len(v))*unsafe.Sizeof(int(0)))
|
|
|
|
for i := range len(v) {
|
|
testx.Expect(t, v[i] == 0, "[%d] %d != 0", i, v[i])
|
|
}
|
|
}
|
|
|
|
{ // fill
|
|
v := []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
|
|
mem.Clear(unsafe.Pointer(&v[0]), 0xFF, uintptr(len(v))*unsafe.Sizeof(int(0)))
|
|
|
|
for i := range len(v) {
|
|
testx.Expect(t, v[i] == 0xFF, "[%d] %d != 0xFF", i, v[i])
|
|
}
|
|
}
|
|
})
|
|
}
|
|
|
|
func TestAllocationPrimitives(t *testing.T) {
|
|
t.Run("reserve, unreserve", func(t *testing.T) {
|
|
data, err := mem.Reserve(1 * mem.Gigabyte)
|
|
testx.Expect(t, err == nil, "mem.Reserve returned an error - %s", err)
|
|
|
|
testx.Expect(t, len(data) == 1*mem.Gigabyte, "len was %d", len(data))
|
|
testx.Expect(t, cap(data) == 1*mem.Gigabyte, "len was %d", cap(data))
|
|
|
|
err = mem.Release(data)
|
|
testx.Expect(t, err == nil, "mem.Unreserve returned an error - %s", err)
|
|
})
|
|
|
|
t.Run("commit", func(t *testing.T) {
|
|
data, err := mem.Reserve(1 * mem.Gigabyte)
|
|
testx.Expect(t, err == nil, "mem.Reserve returned an error - %s", err)
|
|
|
|
err = mem.Commit(data, mem.AccessRead|mem.AccessWrite)
|
|
testx.Expect(t, err == nil, "mem.Commit returned an error - %s", err)
|
|
|
|
for i := range data {
|
|
data[i] = byte(i * i)
|
|
}
|
|
})
|
|
|
|
t.Run("decommit", func(t *testing.T) {
|
|
data, err := mem.Reserve(1 * mem.Gigabyte)
|
|
testx.Expect(t, err == nil, "mem.Reserve returned an error - %s", err)
|
|
|
|
err = mem.Commit(data, mem.AccessRead|mem.AccessWrite)
|
|
testx.Expect(t, err == nil, "mem.Commit returned an error - %s", err)
|
|
|
|
before := uintptr(unsafe.Pointer(&data[0]))
|
|
|
|
err = mem.Decommit(data)
|
|
testx.Expect(t, err == nil, "mem.Decommit returned an error - %s", err)
|
|
|
|
// accessing data before recommitting it will fail
|
|
|
|
err = mem.Commit(data, mem.AccessRead|mem.AccessWrite)
|
|
testx.Expect(t, err == nil, "mem.Commit returned an error - %s", err)
|
|
|
|
after := uintptr(unsafe.Pointer(&data[0]))
|
|
testx.Expect(t, before == after, "base pointers did not match between after recommit %d != %d", before, after)
|
|
|
|
for i := range data {
|
|
data[i] = byte(i * i)
|
|
}
|
|
})
|
|
}
|