151 lines
3.2 KiB
Go
151 lines
3.2 KiB
Go
package utils
|
|
|
|
import (
|
|
"bytes"
|
|
"io"
|
|
|
|
. "github.com/onsi/ginkgo"
|
|
. "github.com/onsi/gomega"
|
|
)
|
|
|
|
var _ = Describe("float16", func() {
|
|
It("reads", func() {
|
|
testcases := []struct {
|
|
expected uint64
|
|
binary uint16
|
|
}{
|
|
// There are fewer decoding test cases because encoding truncates, and
|
|
// decoding returns the smallest expansion.
|
|
// Small numbers represent themselves.
|
|
{0, 0},
|
|
{1, 1},
|
|
{2, 2},
|
|
{3, 3},
|
|
{4, 4},
|
|
{5, 5},
|
|
{6, 6},
|
|
{7, 7},
|
|
{15, 15},
|
|
{31, 31},
|
|
{42, 42},
|
|
{123, 123},
|
|
{1234, 1234},
|
|
// Check transition through 2^11.
|
|
{2046, 2046},
|
|
{2047, 2047},
|
|
{2048, 2048},
|
|
{2049, 2049},
|
|
// Running out of mantissa at 2^12.
|
|
{4094, 4094},
|
|
{4095, 4095},
|
|
{4096, 4096},
|
|
{4098, 4097},
|
|
{4100, 4098},
|
|
// Check transition through 2^13.
|
|
{8190, 6143},
|
|
{8192, 6144},
|
|
{8196, 6145},
|
|
// Half-way through the exponents.
|
|
{0x7FF8000, 0x87FF},
|
|
{0x8000000, 0x8800},
|
|
{0xFFF0000, 0x8FFF},
|
|
{0x10000000, 0x9000},
|
|
// Transition into the largest exponent.
|
|
{0x1FFE0000000, 0xF7FF},
|
|
{0x20000000000, 0xF800},
|
|
{0x20040000000, 0xF801},
|
|
// Transition into the max value.
|
|
{0x3FF80000000, 0xFFFE},
|
|
{0x3FFC0000000, 0xFFFF},
|
|
}
|
|
for _, testcase := range testcases {
|
|
b := &bytes.Buffer{}
|
|
WriteUint16(b, testcase.binary)
|
|
val, err := ReadUfloat16(b)
|
|
Expect(err).NotTo(HaveOccurred())
|
|
Expect(val).To(Equal(testcase.expected))
|
|
}
|
|
})
|
|
|
|
It("errors on eof", func() {
|
|
_, err := ReadUfloat16(&bytes.Buffer{})
|
|
Expect(err).To(MatchError(io.EOF))
|
|
})
|
|
|
|
It("writes", func() {
|
|
testcases := []struct {
|
|
decoded uint64
|
|
encoded uint16
|
|
}{
|
|
// Small numbers represent themselves.
|
|
{0, 0},
|
|
{1, 1},
|
|
{2, 2},
|
|
{3, 3},
|
|
{4, 4},
|
|
{5, 5},
|
|
{6, 6},
|
|
{7, 7},
|
|
{15, 15},
|
|
{31, 31},
|
|
{42, 42},
|
|
{123, 123},
|
|
{1234, 1234},
|
|
// Check transition through 2^11.
|
|
{2046, 2046},
|
|
{2047, 2047},
|
|
{2048, 2048},
|
|
{2049, 2049},
|
|
// Running out of mantissa at 2^12.
|
|
{4094, 4094},
|
|
{4095, 4095},
|
|
{4096, 4096},
|
|
{4097, 4096},
|
|
{4098, 4097},
|
|
{4099, 4097},
|
|
{4100, 4098},
|
|
{4101, 4098},
|
|
// Check transition through 2^13.
|
|
{8190, 6143},
|
|
{8191, 6143},
|
|
{8192, 6144},
|
|
{8193, 6144},
|
|
{8194, 6144},
|
|
{8195, 6144},
|
|
{8196, 6145},
|
|
{8197, 6145},
|
|
// Half-way through the exponents.
|
|
{0x7FF8000, 0x87FF},
|
|
{0x7FFFFFF, 0x87FF},
|
|
{0x8000000, 0x8800},
|
|
{0xFFF0000, 0x8FFF},
|
|
{0xFFFFFFF, 0x8FFF},
|
|
{0x10000000, 0x9000},
|
|
// Transition into the largest exponent.
|
|
{0x1FFFFFFFFFE, 0xF7FF},
|
|
{0x1FFFFFFFFFF, 0xF7FF},
|
|
{0x20000000000, 0xF800},
|
|
{0x20000000001, 0xF800},
|
|
{0x2003FFFFFFE, 0xF800},
|
|
{0x2003FFFFFFF, 0xF800},
|
|
{0x20040000000, 0xF801},
|
|
{0x20040000001, 0xF801},
|
|
// Transition into the max value and clamping.
|
|
{0x3FF80000000, 0xFFFE},
|
|
{0x3FFBFFFFFFF, 0xFFFE},
|
|
{0x3FFC0000000, 0xFFFF},
|
|
{0x3FFC0000001, 0xFFFF},
|
|
{0x3FFFFFFFFFF, 0xFFFF},
|
|
{0x40000000000, 0xFFFF},
|
|
{0xFFFFFFFFFFFFFFFF, 0xFFFF},
|
|
}
|
|
for _, testcase := range testcases {
|
|
b := &bytes.Buffer{}
|
|
WriteUfloat16(b, testcase.decoded)
|
|
val, err := ReadUint16(b)
|
|
Expect(err).NotTo(HaveOccurred())
|
|
Expect(val).To(Equal(testcase.encoded))
|
|
}
|
|
})
|
|
})
|