Implement floating-point values

Author: oxzi

.travis.yml

@@ -3,6 +3,7 @@ language: go
 go:
   - 1.11.x
   - 1.12.x
+  - 1.13.x
 
 env:
   - GO111MODULE=on

README.md

@@ -10,6 +10,7 @@ developed to be used in [`dtn7-go`][dtn7-go], an implementation of the
 
 - Supports a selected subset of [CBOR's][cbor] features:
     - Unsigned Integer
+    - Floating-point values
     - Byte and Text String
     - Arrays, both of definite and indefinite length
     - Maps of definite length
@@ -20,6 +21,6 @@ developed to be used in [`dtn7-go`][dtn7-go], an implementation of the
 - Surprisingly fast
 
 
-[bpbis]: https://tools.ietf.org/html/draft-ietf-dtn-bpbis-13
+[bpbis]: https://tools.ietf.org/html/draft-ietf-dtn-bpbis-14
 [cbor]: https://tools.ietf.org/html/rfc7049
 [dtn7-go]: https://github.com/dtn7/dtn7-go

simple.go

@@ -3,6 +3,7 @@ package cboring
 import (
 	"fmt"
 	"io"
+	"math"
 )
 
 const (
@@ -51,3 +52,37 @@ func WriteBoolean(b bool, w io.Writer) (err error) {
 
 	return
 }
+
+// ReadFloat32 reads a float32 value from the Reader.
+func ReadFloat32(r io.Reader) (f float32, err error) {
+	if fbits, fbitsErr := ReadExpectMajors(SimpleData, r); fbitsErr != nil {
+		err = fbitsErr
+	} else {
+		f = math.Float32frombits(uint32(fbits))
+	}
+
+	return
+}
+
+// WriteFloat32 writes a float32 into the Writer.
+func WriteFloat32(f float32, w io.Writer) (err error) {
+	fbits := math.Float32bits(f)
+	return WriteMajors(SimpleData, uint64(fbits), w)
+}
+
+// ReadFloat64 reads a float64 value from the Reader.
+func ReadFloat64(r io.Reader) (f float64, err error) {
+	if fbits, fbitsErr := ReadExpectMajors(SimpleData, r); fbitsErr != nil {
+		err = fbitsErr
+	} else {
+		f = math.Float64frombits(fbits)
+	}
+
+	return
+}
+
+// WriteFloat64 writes a float64 into the Writer.
+func WriteFloat64(f float64, w io.Writer) (err error) {
+	fbits := math.Float64bits(f)
+	return WriteMajors(SimpleData, fbits, w)
+}

simple_test.go

@@ -35,3 +35,64 @@ func TestBoolean(t *testing.T) {
 		}
 	}
 }
+
+func TestFloat32(t *testing.T) {
+	tests := []struct {
+		data []byte
+		f    float32
+	}{
+		{[]byte{0xfa, 0x47, 0xc3, 0x50, 0x00}, 100000.0},
+		{[]byte{0xfa, 0x7f, 0x7f, 0xff, 0xff}, 3.4028234663852886e+38},
+	}
+
+	for _, test := range tests {
+		// Read
+		buff := bytes.NewBuffer(test.data)
+		if f, err := ReadFloat32(buff); err != nil {
+			t.Fatal(err)
+		} else if f != test.f {
+			t.Fatalf("Resulting float %f is not %f", f, test.f)
+		}
+
+		// Write
+		buff.Reset()
+		if err := WriteFloat32(test.f, buff); err != nil {
+			t.Fatal(err)
+		}
+
+		if bb := buff.Bytes(); !reflect.DeepEqual(bb, test.data) {
+			t.Fatalf("Serialized data mismatches: %x != %x", bb, test.data)
+		}
+	}
+}
+
+func TestFloat64(t *testing.T) {
+	tests := []struct {
+		data []byte
+		f    float64
+	}{
+		{[]byte{0xfb, 0x3f, 0xf1, 0x99, 0x99, 0x99, 0x99, 0x99, 0x9a}, 1.1},
+		{[]byte{0xfb, 0x7e, 0x37, 0xe4, 0x3c, 0x88, 0x00, 0x75, 0x9c}, 1.0e+300},
+		{[]byte{0xfb, 0xc0, 0x10, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66}, -4.1},
+	}
+
+	for _, test := range tests {
+		// Read
+		buff := bytes.NewBuffer(test.data)
+		if f, err := ReadFloat64(buff); err != nil {
+			t.Fatal(err)
+		} else if f != test.f {
+			t.Fatalf("Resulting float %f is not %f", f, test.f)
+		}
+
+		// Write
+		buff.Reset()
+		if err := WriteFloat64(test.f, buff); err != nil {
+			t.Fatal(err)
+		}
+
+		if bb := buff.Bytes(); !reflect.DeepEqual(bb, test.data) {
+			t.Fatalf("Serialized data mismatches: %x != %x", bb, test.data)
+		}
+	}
+}