apd: add ARM 32-bit and 64-bit testing to CI

Author: nvb

.github/workflows/go.yml

@@ -14,6 +14,10 @@ jobs:
 
     strategy:
       matrix:
+        arch:
+          - x64
+          - armv7
+          - aarch64
         go:
           - '1.13'
           - '1.14'
@@ -30,27 +34,58 @@ jobs:
           go-version: '${{ matrix.go }}'
 
       - name: 'Build'
+        if: ${{ matrix.arch == 'x64' }}
         run: go build -v ./...
 
       - name: 'Test'
+        if: ${{ matrix.arch == 'x64' }}
         run: go test -v ./...
 
       - name: 'TestRace'
+        if: ${{ matrix.arch == 'x64' }}
         run: go test -race -v ./...
 
       - name: 'Bench'
+        if: ${{ matrix.arch == 'x64' }}
         run: go test -run=- -bench=. -benchtime=1x -v ./...
 
       - name: 'BenchRace'
+        if: ${{ matrix.arch == 'x64' }}
         run: go test -run=- -bench=. -benchtime=1x -race -v ./...
 
       - name: 'Vet'
+        if: ${{ matrix.arch == 'x64' }}
         # -unsafeptr=false is needed because of the noescape function in bigint.go.
         run: go vet -unsafeptr=false ./...
 
       - name: 'Staticcheck'
         # staticcheck requires go1.14.
-        if: ${{ matrix.go != '1.13' }}
+        if: ${{ matrix.arch == 'x64' && matrix.go != '1.13' }}
         run: |
           go get honnef.co/go/tools/cmd/staticcheck
           staticcheck ./...
+
+      - name: 'BuildTest for armv7'
+        if: ${{ matrix.arch == 'armv7' }}
+        env:
+          GOARCH: arm
+          GOARM: 7
+        run: go test -c ./...
+
+      - name: 'BuildTest for aarch64'
+        if: ${{ matrix.arch == 'aarch64' }}
+        env:
+          GOARCH: arm64
+        run: go test -c ./...
+
+      - name: 'Test and Bench on ${{ matrix.arch }}'
+        # arch != 'x64': we already tested on x86 above.
+        # go != '1.13': go1.13 + arm is significantly slower, so don't run test suite.
+        if: ${{ matrix.arch != 'x64' && matrix.go != '1.13' }}
+        uses: uraimo/[email protected]
+        with:
+          arch: ${{ matrix.arch }}
+          distro: ubuntu20.04
+          dockerRunArgs: --mount type=bind,source="$(pwd)",target=/checkout,readonly
+          run: |
+            find /checkout -name '*.test' -type f -executable -print0 | xargs -0 -I '{}' sh -c '{} -test.run=. -test.bench=. -test.benchtime=1x -test.v'

decimal_test.go

@@ -18,6 +18,7 @@ import (
 	"encoding/json"
 	"fmt"
 	"math"
+	"math/bits"
 	"testing"
 	"unsafe"
 )
@@ -787,16 +788,30 @@ func TestReduce(t *testing.T) {
 // TestSizeof is meant to catch changes that unexpectedly increase
 // the size of the BigInt, Decimal, and Context structs.
 func TestSizeof(t *testing.T) {
+	// map[uint_size][type]sizeof
+	exp := map[int]map[string]uintptr{
+		32: {
+			"BigInt":  20,
+			"Decimal": 28,
+			"Context": 24,
+		},
+		64: {
+			"BigInt":  24,
+			"Decimal": 32,
+			"Context": 32,
+		},
+	}[bits.UintSize]
+
 	var b BigInt
-	if s := unsafe.Sizeof(b); s != 24 {
+	if s := unsafe.Sizeof(b); s != exp["BigInt"] {
 		t.Errorf("sizeof(BigInt) changed: %d", s)
 	}
 	var d Decimal
-	if s := unsafe.Sizeof(d); s != 32 {
+	if s := unsafe.Sizeof(d); s != exp["Decimal"] {
 		t.Errorf("sizeof(Decimal) changed: %d", s)
 	}
 	var c Context
-	if s := unsafe.Sizeof(c); s != 32 {
+	if s := unsafe.Sizeof(c); s != exp["Context"] {
 		t.Errorf("sizeof(Context) changed: %d", s)
 	}
 }
@@ -805,19 +820,43 @@ func TestSizeof(t *testing.T) {
 // returns the shallow size of the structs, the Size method reports the total
 // memory footprint of each struct and all referenced objects.
 func TestSize(t *testing.T) {
+	// map[uint_size][is_inline][type]size
+	exp := map[int]map[bool]map[string]uintptr{
+		32: {
+			true: {
+				"BigInt":  20,
+				"Decimal": 28,
+			},
+			false: {
+				"BigInt":  72,
+				"Decimal": 80,
+			},
+		},
+		64: {
+			true: {
+				"BigInt":  24,
+				"Decimal": 32,
+			},
+			false: {
+				"BigInt":  112,
+				"Decimal": 120,
+			},
+		},
+	}[bits.UintSize]
+
 	var d Decimal
-	if e, s := uintptr(32), d.Size(); e != s {
+	if e, s := exp[true]["Decimal"], d.Size(); e != s {
 		t.Errorf("(*Decimal).Size() != %d: %d", e, s)
 	}
-	if e, s := uintptr(24), d.Coeff.Size(); e != s {
+	if e, s := exp[true]["BigInt"], d.Coeff.Size(); e != s {
 		t.Errorf("(*BigInt).Size() != %d: %d", e, s)
 	}
 	// Set to an inlinable value.
 	d.SetInt64(1234)
-	if e, s := uintptr(32), d.Size(); e != s {
+	if e, s := exp[true]["Decimal"], d.Size(); e != s {
 		t.Errorf("(*Decimal).Size() != %d: %d", e, s)
 	}
-	if e, s := uintptr(24), d.Coeff.Size(); e != s {
+	if e, s := exp[true]["BigInt"], d.Coeff.Size(); e != s {
 		t.Errorf("(*BigInt).Size() != %d: %d", e, s)
 	}
 	// Set to a non-inlinable value.
@@ -828,10 +867,10 @@ func TestSize(t *testing.T) {
 		// Sanity-check, in case inlineWords changes.
 		t.Fatal("BigInt inlined large value. Did inlineWords change?")
 	}
-	if e, s := uintptr(120), d.Size(); e != s {
+	if e, s := exp[false]["Decimal"], d.Size(); e != s {
 		t.Errorf("(*Decimal).Size() != %d: %d", e, s)
 	}
-	if e, s := uintptr(112), d.Coeff.Size(); e != s {
+	if e, s := exp[false]["BigInt"], d.Coeff.Size(); e != s {
 		t.Errorf("(*BigInt).Size() != %d: %d", e, s)
 	}
 }

gda_test.go

@@ -532,7 +532,7 @@ func gdaTest(t *testing.T, path string, tcs []TestCase) {
 				if err != nil {
 					t.Fatal(err)
 				}
-			case <-time.After(time.Second * 5):
+			case <-time.After(time.Second * 20):
 				t.Fatalf("timeout")
 			}
 			if d.Coeff.Sign() < 0 {