decimal: add fuzzing test

Fuzzing tests in Golang, see [1] and [2], requires Go 1.18+. However in
CI we use Go 1.13 that fails on running fuzzing tests. To avoid this
fuzzing test has been moved to a separate file an marked with build tag.

1. https://go.dev/doc/tutorial/fuzz
2. https://go.dev/doc/fuzz/

Closes #96

Author: ligurio

.github/workflows/testing.yml

@@ -26,12 +26,23 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
+        golang:
+          - 1.13
         tarantool:
           - '1.10'
           - '2.8'
           - '2.9'
           - '2.x-latest'
         coveralls: [false]
+        fuzzing: [false]
+        include:
+          - tarantool: '2.x-latest'
+            coveralls: true
+            golang: 1.13
+          - tarantool: '2.x-latest'
+            fuzzing: true
+            golang: 1.18
+            coveralls: false
 
     steps:
       - name: Clone the connector
@@ -52,14 +63,18 @@ jobs:
       - name: Setup golang for the connector and tests
         uses: actions/setup-go@v2
         with:
-          go-version: 1.13
+          go-version: ${{ matrix.golang }}
 
       - name: Install test dependencies
         run: make deps
 
-      - name: Run tests
+      - name: Run regression tests
         run: make test
 
+      - name: Run fuzzing tests
+        if: ${{ matrix.fuzzing }}
+        run: make test-fuzzing
+
       - name: Run tests, collect code coverage data and send to Coveralls
         if: ${{ matrix.coveralls }}
         env:

Makefile

@@ -76,6 +76,12 @@ test-decimal:
 	go clean -testcache
 	go test ./decimal/ -v -p 1
 
+.PHONY: test-fuzzing
+test-fuzzing:
+	@echo "Running fuzzing tests"
+	go clean -testcache
+	go test ./... -run=^Fuzz -v -p 1 -tags fuzzing
+
 .PHONY: coverage
 coverage:
 	go clean -testcache

decimal/fuzzing_test.go

@@ -0,0 +1,46 @@
+//go:build fuzzing
+// +build fuzzing
+
+package decimal_test
+
+import (
+	"testing"
+
+	"github.com/shopspring/decimal"
+	. "github.com/tarantool/go-tarantool/decimal"
+)
+
+func strToDecimal(t *testing.T, buf string) decimal.Decimal {
+	decNum, err := decimal.NewFromString(buf)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return decNum
+}
+
+func FuzzEncodeDecodeBCD(f *testing.F) {
+	samples := append(correctnessSamples, benchmarkSamples...)
+	for _, testcase := range samples {
+		if len(testcase.numString) > 0 {
+			f.Add(testcase.numString) // Use f.Add to provide a seed corpus.
+		}
+	}
+	f.Fuzz(func(t *testing.T, orig string) {
+		if l := GetNumberLength(orig); l > DecimalPrecision {
+			t.Skip("max number length is exceeded")
+		}
+		bcdBuf, err := EncodeStringToBCD(orig)
+		if err != nil {
+			t.Skip("Only correct requests are interesting: %w", err)
+		}
+		var dec string
+		dec, err = DecodeStringFromBCD(bcdBuf)
+		if err != nil {
+			t.Fatalf("Failed to decode encoded value ('%s')", orig)
+		}
+
+		if !strToDecimal(t, dec).Equal(strToDecimal(t, orig)) {
+			t.Fatal("Decimal numbers are not equal")
+		}
+	})
+}