Timetag fix test (#22)

* Add Go modules to allow compiling

* Fix compilation issues

* Fix the timetag type

The lower 32-bits are fractions of a second. That is, each increment
increases the time by 1/(2^32) seconds, or 1e9/(2^32) ns ~ 0.233ns.
Previously, each increment was counted as a full nanosecond. That could
lead to errors of up to (2^32-1) ns - (2^32-1)*1e9/(2^32) ns ~= 3.3s!

Also, if only the first bit is set, the value should be interpreted in a
particular way. The choice made is to turn it into the zero time:
time.Time{}. It makes it easy to identify using time.Time.IsZero().

* add a TimeTag test

---------

Co-authored-by: tleb <[email protected]>

Author: briansorahan

timetag.go

@@ -10,8 +10,9 @@ import (
 
 const (
 	// SecondsFrom1900To1970 is exactly what it sounds like.
-	SecondsFrom1900To1970 = 2208988800
-	// SecondsFrom1900To1970 = 2207520000
+	SecondsFrom1900To1970 = 2208988800 // Source: RFC 868
+
+	nanosecondsPerFraction = float64(0.23283064365386962891) // 1e9/(2^32)
 
 	// TimetagSize is the number of 8-bit bytes in an OSC timetag.
 	TimetagSize = 8
@@ -43,30 +44,38 @@ func (tt Timetag) String() string {
 
 // Time converts an OSC timetag to a time.Time.
 func (tt Timetag) Time() time.Time {
-	secs := (uint64(tt) >> 32) - SecondsFrom1900To1970
-	return time.Unix(int64(secs), int64(tt)&0xFFFFFFFF).UTC()
+	t := uint64(tt)
+
+	if t == 1 {
+		// Means "immediately". It cannot occur otherwise as timetag == 0 gets
+		// converted to January 1, 1900 while time.Time{} means year 1 in Go.
+		// Use the time.Time.IsZero() method to detect it.
+		return time.Time{}
+	}
+
+	return time.Unix(
+		int64(t>>32)-SecondsFrom1900To1970,
+		int64(nanosecondsPerFraction*float64(t&(1<<32-1))),
+	).UTC()
 }
 
 // FromTime converts the given time to an OSC timetag.
 func FromTime(t time.Time) Timetag {
-	t = t.UTC()
-	secs := uint64((SecondsFrom1900To1970 + t.Unix()) << 32)
-	return Timetag(secs + uint64(uint32(t.Nanosecond())))
+	if t.IsZero() {
+		return 1
+	}
+
+	seconds := uint64(t.Unix() + SecondsFrom1900To1970)
+	secondFraction := float64(t.UTC().Nanosecond()) / nanosecondsPerFraction
+	return Timetag((seconds << 32) + uint64(uint32(secondFraction)))
 }
 
 // ReadTimetag parses a timetag from a byte slice.
 func ReadTimetag(data []byte) (Timetag, error) {
 	if len(data) < TimetagSize {
 		return Timetag(0), errors.New("timetags must be 64-bit")
 	}
-	zero := []byte{0, 0, 0, 0}
-	var (
-		L     = append(zero, data[:TimetagSize/2]...)
-		R     = append(zero, data[TimetagSize/2:]...)
-		secs  uint64
-		nsecs uint64
-	)
-	_ = binary.Read(bytes.NewReader(L), byteOrder, &secs)  // Never fails
-	_ = binary.Read(bytes.NewReader(R), byteOrder, &nsecs) // Never fails
-	return Timetag((secs << 32) + nsecs), nil
+	var tt uint64
+	_ = binary.Read(bytes.NewReader(data), binary.BigEndian, &tt)
+	return Timetag(tt), nil
 }

timetag_test.go

@@ -1,56 +1,48 @@
 package osc
 
 import (
-	"bytes"
 	"testing"
 	"time"
 
 	"github.com/pkg/errors"
 )
 
+func TestImmediately(t *testing.T) {
+	if !Immediately.Time().IsZero() {
+		t.Fatalf("expected Immediately to convert to the zero time")
+	}
+}
+
 func TestFromTime(t *testing.T) {
 	// Test converting to/from time.Time
 	for _, testcase := range []struct {
 		Input    Timetag
 		Expected time.Time
 	}{
-		{
-			Input:    FromTime(time.Unix(0, 0)),
-			Expected: time.Unix(0, 0),
-		},
+		{Input: FromTime(time.Unix(0, 0)), Expected: time.Unix(0, 0)},
+		{Input: FromTime(time.Time{}), Expected: time.Time{}},
 	} {
 		if expected, got := testcase.Expected, testcase.Input.Time(); !expected.Equal(got) {
 			t.Fatalf("expected %s, got %s", expected, got)
 		}
 	}
 }
 
-func TestTimetagBytes(t *testing.T) {
-	for _, testcase := range []struct {
-		Input    Timetag
-		Expected []byte
-	}{
-		{
-			Input:    Timetag(0),
-			Expected: []byte{0, 0, 0, 0, 0, 0, 0, 0},
-		},
-		{
-			Input:    Timetag(10),
-			Expected: []byte{0, 0, 0, 0, 0, 0, 0, 0x0A},
-		},
-	} {
-		if expected, got := testcase.Expected, testcase.Input.Bytes(); !bytes.Equal(expected, got) {
-			t.Fatalf("expected, %q, got %q", expected, got)
-		}
-	}
-}
-
 func TestTimetagString(t *testing.T) {
 	for _, testcase := range []struct {
 		Input    Timetag
 		Expected string
 	}{
-		{Input: Timetag(10), Expected: "1900-01-01T00:00:00Z"},
+		// 0s + 0 * 0.233ns
+		{Input: Timetag(0), Expected: "1900-01-01T00:00:00Z"},
+		// "immediately" special value
+		{Input: Timetag(1), Expected: "0001-01-01T00:00:00Z"},
+		// 0s + 2 * 0.233ns
+		{Input: Timetag(2), Expected: "1900-01-01T00:00:00Z"},
+		// 0s + (2^32-1)/(2^32) seconds
+		{Input: Timetag(0xFFFFFFFF), Expected: "1900-01-01T00:00:00Z"},
+		// 1s + 0 * 0.233ns
+		{Input: Timetag(0x100000000), Expected: "1900-01-01T00:00:01Z"},
 	} {
 		if expected, got := testcase.Expected, testcase.Input.String(); expected != got {
 			t.Fatalf("expected, %s, got %s", expected, got)