Refactor kafka to pure Go (franz-go), fix DBC stubs, update Dockerfile

pkg/can-go/internal/reinterpret/reinterpret.go

@@ -0,0 +1,50 @@
+// Package reinterpret provides primitives for reinterpreting arbitrary-length values as signed or unsigned.
+package reinterpret
+
+// AsSigned reinterprets the provided unsigned value as a signed value.
+func AsSigned(unsigned uint64, bits uint8) int64 {
+	switch bits {
+	case 8:
+		return int64(int8(uint8(unsigned)))
+	case 16:
+		return int64(int16(uint16(unsigned)))
+	case 32:
+		return int64(int32(uint32(unsigned)))
+	case 64:
+		return int64(unsigned)
+	default:
+		// calculate bit mask for sign bit
+		signBitMask := uint64(1 << (bits - 1))
+		// check if sign bit is set
+		isNegative := unsigned&signBitMask > 0
+		if !isNegative {
+			// sign bit not set means we can reinterpret the value as-is
+			return int64(unsigned)
+		}
+		// calculate bit mask for extracting value bits (all bits except the sign bit)
+		valueBitMask := signBitMask - 1
+		// calculate two's complement of the value bits
+		value := ((^unsigned) & valueBitMask) + 1
+		// result is the negative value of the two's complement
+		return -1 * int64(value)
+	}
+}
+
+// AsUnsigned reinterprets the provided signed value as an unsigned value.
+func AsUnsigned(signed int64, bits uint8) uint64 {
+	switch bits {
+	case 8:
+		return uint64(uint8(int8(signed)))
+	case 16:
+		return uint64(uint16(int16(signed)))
+	case 32:
+		return uint64(uint32(int32(signed)))
+	case 64:
+		return uint64(signed)
+	default:
+		// calculate bit mask for extracting relevant bits
+		valueBitMask := uint64(1<<bits) - 1
+		// extract relevant bits
+		return uint64(signed) & valueBitMask
+	}
+}

pkg/can-go/internal/reinterpret/reinterpret_test.go

@@ -0,0 +1,68 @@
+package reinterpret
+
+import (
+	"fmt"
+	"testing"
+
+	"gotest.tools/v3/assert"
+)
+
+func TestReinterpretSign(t *testing.T) {
+	for _, tt := range []struct {
+		unsigned uint64
+		length   uint8
+		signed   int64
+	}{
+		// -1, byte aligned
+		{unsigned: 0xf, length: 4, signed: -1},
+		{unsigned: 0xff, length: 8, signed: -1},
+		{unsigned: 0xfff, length: 12, signed: -1},
+		{unsigned: 0xffff, length: 16, signed: -1},
+		{unsigned: 0xfffff, length: 20, signed: -1},
+		{unsigned: 0xffffff, length: 24, signed: -1},
+		{unsigned: 0xfffffff, length: 28, signed: -1},
+		{unsigned: 0xffffffff, length: 32, signed: -1},
+		{unsigned: 0xfffffffff, length: 36, signed: -1},
+		{unsigned: 0xffffffffff, length: 40, signed: -1},
+		{unsigned: 0xfffffffffff, length: 44, signed: -1},
+		{unsigned: 0xffffffffffff, length: 48, signed: -1},
+		{unsigned: 0xfffffffffffff, length: 52, signed: -1},
+		{unsigned: 0xffffffffffffff, length: 56, signed: -1},
+		{unsigned: 0xfffffffffffffff, length: 60, signed: -1},
+		{unsigned: 0xffffffffffffffff, length: 64, signed: -1},
+		// 3 bits
+		{unsigned: 0x0, length: 3, signed: 0},
+		{unsigned: 0x1, length: 3, signed: 1},
+		{unsigned: 0x2, length: 3, signed: 2},
+		{unsigned: 0x3, length: 3, signed: 3},
+		{unsigned: 0x4, length: 3, signed: -4},
+		{unsigned: 0x5, length: 3, signed: -3},
+		{unsigned: 0x6, length: 3, signed: -2},
+		{unsigned: 0x7, length: 3, signed: -1},
+		// 4 bits
+		{unsigned: 0x0, length: 4, signed: 0},
+		{unsigned: 0x1, length: 4, signed: 1},
+		{unsigned: 0x2, length: 4, signed: 2},
+		{unsigned: 0x3, length: 4, signed: 3},
+		{unsigned: 0x4, length: 4, signed: 4},
+		{unsigned: 0x5, length: 4, signed: 5},
+		{unsigned: 0x6, length: 4, signed: 6},
+		{unsigned: 0x7, length: 4, signed: 7},
+		{unsigned: 0x8, length: 4, signed: -8},
+		{unsigned: 0x9, length: 4, signed: -7},
+		{unsigned: 0xa, length: 4, signed: -6},
+		{unsigned: 0xb, length: 4, signed: -5},
+		{unsigned: 0xc, length: 4, signed: -4},
+		{unsigned: 0xd, length: 4, signed: -3},
+		{unsigned: 0xe, length: 4, signed: -2},
+		{unsigned: 0xf, length: 4, signed: -1},
+	} {
+		tt := tt
+		t.Run(fmt.Sprintf("%+v", tt), func(t *testing.T) {
+			assert.Equal(t, tt.signed, AsSigned(tt.unsigned, tt.length))
+			assert.Equal(t, tt.unsigned, AsUnsigned(tt.signed, tt.length))
+			assert.Equal(t, tt.signed, AsSigned(AsUnsigned(tt.signed, tt.length), tt.length))
+			assert.Equal(t, tt.unsigned, AsUnsigned(AsSigned(tt.unsigned, tt.length), tt.length))
+		})
+	}
+}