init

Author: nikolaydubina

.github/workflows/test.yml

@@ -0,0 +1,33 @@
+name: test
+
+on: [push]
+
+permissions: read-all
+
+jobs:
+  build:
+    name: test
+    runs-on: ubuntu-latest
+    timeout-minutes: 5
+    steps:
+      - name: code
+        uses: actions/checkout@v4
+
+      - name: go
+        uses: actions/setup-go@v5
+        with:
+          go-version: ^1.23
+
+      - name: test
+        run: |
+          go get -v -t -d ./...
+          go test -short -cover -coverprofile=coverage.out -covermode=atomic ./...
+
+      - name: fuzz
+        run: go test -list . | grep Fuzz | xargs -P 8 -I {} go test -fuzz {} -fuzztime 5s ./base10quant
+
+      - name: codecov.io coverage
+        uses: codecov/[email protected]
+        with:
+          token: ${{ secrets.CODECOV_TOKEN }}
+          files: coverage.out

README.md

@@ -1 +1 @@
-# base10quant
+base10 encoding of primitive types

go.mod

@@ -0,0 +1,3 @@
+module github.com/ndx-technologies/base10quant
+
+go 1.23.0

l9.go

@@ -0,0 +1,63 @@
+package base10quant
+
+import (
+	"errors"
+)
+
+var ErrInvalidFormat = errors.New("invalid format")
+
+const MaxL9 = 999_999_999
+
+// L9 is base10 chars encoding least significant 9 decimals of uint32.
+type L9 struct{ v uint32 }
+
+func L9FromUint32(v uint32) L9 { return L9{v: v} }
+
+func L9FromString(s string) (L9, error) {
+	var v L9
+	err := (&v).UnmarshalText([]byte(s))
+	return v, err
+}
+
+func (s L9) UInt32() uint32 { return s.v }
+
+func (s L9) IsEmpty() bool { return s.v == 0 }
+
+func (s L9) AppendBytes(b []byte) {
+	v := s.v
+	v, b[8] = v/10, '0'+byte(v%10)
+	v, b[7] = v/10, '0'+byte(v%10)
+	v, b[6] = v/10, '0'+byte(v%10)
+	v, b[5] = v/10, '0'+byte(v%10)
+	v, b[4] = v/10, '0'+byte(v%10)
+	v, b[3] = v/10, '0'+byte(v%10)
+	v, b[2] = v/10, '0'+byte(v%10)
+	v, b[1] = v/10, '0'+byte(v%10)
+	_, b[0] = v/10, '0'+byte(v%10)
+}
+
+func (s L9) MarshalText() ([]byte, error) {
+	b := make([]byte, 9)
+	s.AppendBytes(b)
+	return b, nil
+}
+
+func (s *L9) UnmarshalText(b []byte) error {
+	if len(b) != 9 {
+		return ErrInvalidFormat
+	}
+	s.v = 0
+	for i := 0; i < 9; i++ {
+		if b[i] < '0' || b[i] > '9' {
+			return ErrInvalidFormat
+		}
+		s.v *= 10
+		s.v += uint32(b[i] - '0')
+	}
+	return nil
+}
+
+func (s L9) String() string {
+	b, _ := s.MarshalText()
+	return string(b)
+}

l9_test.go

@@ -0,0 +1,91 @@
+package base10quant_test
+
+import (
+	"testing"
+
+	"github.com/ndx-technologies/base10quant"
+)
+
+func TestL9(t *testing.T) {
+	t.Run("ok", func(t *testing.T) {
+		tests := []struct {
+			s string
+			v uint32
+		}{
+			{s: "999999999", v: 999_999_999},
+			{s: "123456789", v: 123_456_789},
+		}
+		for _, tc := range tests {
+			v := base10quant.L9FromUint32(tc.v)
+			if tc.s != v.String() {
+				t.Errorf("expected %s, got %s", tc.s, v.String())
+			}
+			if tc.v != v.UInt32() {
+				t.Errorf("expected %d, got %d", tc.v, v.UInt32())
+			}
+
+			x, err := base10quant.L9FromString(tc.s)
+			if err != nil {
+				t.Error(err)
+			}
+			if v != x {
+				t.Errorf("expected %v, got %v", v, x)
+			}
+		}
+	})
+
+	t.Run("error", func(t *testing.T) {
+		tests := []string{
+			"0123456789",
+			"a",
+			"",
+			"1234a6789",
+			"1234 6789",
+		}
+		for _, tc := range tests {
+			_, err := base10quant.L9FromString(tc)
+			if err == nil {
+				t.Errorf("expected error")
+			}
+		}
+	})
+}
+
+func FuzzL9(f *testing.F) {
+	f.Add(uint32(999_999_999))
+	f.Add(uint32(1))
+	f.Add(uint32(0))
+
+	f.Fuzz(func(t *testing.T, v uint32) {
+		v = v % 999_999_999
+
+		q := base10quant.L9FromUint32(v)
+		if v != q.UInt32() {
+			t.Errorf("expected %d, got %d", v, q.UInt32())
+		}
+
+		g, err := base10quant.L9FromString(q.String())
+		if err != nil {
+			t.Error(err)
+		}
+		if q != g {
+			t.Errorf("expected %v, got %v", q, g)
+		}
+
+		b, err := q.MarshalText()
+		if err != nil {
+			t.Errorf("unexpected error: %v", err)
+		}
+
+		var f base10quant.L9
+		if !f.IsEmpty() {
+			t.Errorf("expected empty")
+		}
+		if err := (f).UnmarshalText(b); err != nil {
+			t.Error(err)
+		}
+		if f != q {
+			t.Errorf("expected %v, got %v", q, f)
+		}
+	})
+}