629 lines
22 KiB
Go
629 lines
22 KiB
Go
package spectest
|
|
|
|
import (
|
|
"encoding/json"
|
|
"math"
|
|
"testing"
|
|
|
|
"github.com/tetratelabs/wazero/internal/moremath"
|
|
"github.com/tetratelabs/wazero/internal/testing/require"
|
|
"github.com/tetratelabs/wazero/internal/wasm"
|
|
)
|
|
|
|
func Test_f32Equal(t *testing.T) {
|
|
tests := []struct {
|
|
f1, f2 float32
|
|
exp bool
|
|
}{
|
|
{f1: 1.1, f2: 1.1, exp: true},
|
|
{f1: float32(math.NaN()), f2: float32(math.NaN()), exp: true},
|
|
{f1: float32(math.Inf(1)), f2: float32(math.Inf(1)), exp: true},
|
|
{f1: float32(math.Inf(-1)), f2: float32(math.Inf(-1)), exp: true},
|
|
{f1: 1.1, f2: -1.1, exp: false},
|
|
{f1: float32(math.NaN()), f2: -1.1, exp: false},
|
|
{f1: -1.1, f2: float32(math.NaN()), exp: false},
|
|
{f1: float32(math.NaN()), f2: float32(math.Inf(1)), exp: false},
|
|
{f1: float32(math.Inf(1)), f2: float32(math.NaN()), exp: false},
|
|
{f1: float32(math.NaN()), f2: float32(math.Inf(-1)), exp: false},
|
|
{f1: float32(math.Inf(-1)), f2: float32(math.NaN()), exp: false},
|
|
{
|
|
f1: math.Float32frombits(moremath.F32CanonicalNaNBits),
|
|
f2: math.Float32frombits(moremath.F32CanonicalNaNBits),
|
|
exp: true,
|
|
},
|
|
{
|
|
f1: math.Float32frombits(moremath.F32CanonicalNaNBits),
|
|
f2: math.Float32frombits(moremath.F32ArithmeticNaNBits),
|
|
exp: false,
|
|
},
|
|
{
|
|
f1: math.Float32frombits(moremath.F32ArithmeticNaNBits),
|
|
f2: math.Float32frombits(moremath.F32ArithmeticNaNBits),
|
|
exp: true,
|
|
},
|
|
{
|
|
f1: math.Float32frombits(moremath.F32ArithmeticNaNBits),
|
|
f2: math.Float32frombits(moremath.F32ArithmeticNaNBits | 1<<2),
|
|
// The Wasm spec doesn't differentiate different arithmetic nans.
|
|
exp: true,
|
|
},
|
|
{
|
|
f1: math.Float32frombits(moremath.F32CanonicalNaNBits),
|
|
f2: math.Float32frombits(moremath.F32CanonicalNaNBits | 1<<2),
|
|
// Canonical NaN is unique.
|
|
exp: false,
|
|
},
|
|
}
|
|
|
|
for i, tc := range tests {
|
|
require.Equal(t, tc.exp, f32Equal(tc.f1, tc.f2), i)
|
|
}
|
|
}
|
|
|
|
func Test_f64Equal(t *testing.T) {
|
|
tests := []struct {
|
|
f1, f2 float64
|
|
exp bool
|
|
}{
|
|
{f1: 1.1, f2: 1.1, exp: true},
|
|
{f1: math.NaN(), f2: math.NaN(), exp: true},
|
|
{f1: math.Inf(1), f2: math.Inf(1), exp: true},
|
|
{f1: math.Inf(-1), f2: math.Inf(-1), exp: true},
|
|
{f1: 1.1, f2: -1.1, exp: false},
|
|
{f1: math.NaN(), f2: -1.1, exp: false},
|
|
{f1: -1.1, f2: math.NaN(), exp: false},
|
|
{f1: math.NaN(), f2: math.Inf(1), exp: false},
|
|
{f1: math.Inf(1), f2: math.NaN(), exp: false},
|
|
{f1: math.NaN(), f2: math.Inf(-1), exp: false},
|
|
{f1: math.Inf(-1), f2: math.NaN(), exp: false},
|
|
{
|
|
f1: math.Float64frombits(moremath.F64CanonicalNaNBits),
|
|
f2: math.Float64frombits(moremath.F64CanonicalNaNBits),
|
|
exp: true,
|
|
},
|
|
{
|
|
f1: math.Float64frombits(moremath.F64CanonicalNaNBits),
|
|
f2: math.Float64frombits(moremath.F64ArithmeticNaNBits),
|
|
exp: false,
|
|
},
|
|
{
|
|
f1: math.Float64frombits(moremath.F64ArithmeticNaNBits),
|
|
f2: math.Float64frombits(moremath.F64ArithmeticNaNBits),
|
|
exp: true,
|
|
},
|
|
{
|
|
f1: math.Float64frombits(moremath.F64ArithmeticNaNBits),
|
|
f2: math.Float64frombits(moremath.F64ArithmeticNaNBits | 1<<2),
|
|
// The Wasm spec doesn't differentiate different arithmetic nans.
|
|
exp: true,
|
|
},
|
|
{
|
|
f1: math.Float64frombits(moremath.F64CanonicalNaNBits),
|
|
f2: math.Float64frombits(moremath.F64CanonicalNaNBits | 1<<2),
|
|
// Canonical NaN is unique.
|
|
exp: false,
|
|
},
|
|
}
|
|
|
|
for i, tc := range tests {
|
|
require.Equal(t, tc.exp, f64Equal(tc.f1, tc.f2), i)
|
|
}
|
|
}
|
|
|
|
func Test_valuesEq(t *testing.T) {
|
|
i32, i64, f32, f64, v128 := wasm.ValueTypeI32, wasm.ValueTypeI64, wasm.ValueTypeF32, wasm.ValueTypeF64, wasm.ValueTypeV128
|
|
tests := []struct {
|
|
name string
|
|
exps, actual []uint64
|
|
valueTypes []wasm.ValueType
|
|
laneTypes map[int]laneType
|
|
expMatched bool
|
|
expValuesMsg string
|
|
}{
|
|
{
|
|
name: "matched/i32",
|
|
exps: []uint64{0},
|
|
actual: []uint64{0},
|
|
valueTypes: []wasm.ValueType{i32},
|
|
expMatched: true,
|
|
},
|
|
{
|
|
name: "unmatched/i32",
|
|
exps: []uint64{1},
|
|
actual: []uint64{0},
|
|
valueTypes: []wasm.ValueType{i32},
|
|
expMatched: false,
|
|
expValuesMsg: ` have [0]
|
|
want [1]`,
|
|
},
|
|
{
|
|
name: "unmatched/i32",
|
|
exps: []uint64{math.MaxUint32},
|
|
actual: []uint64{1123},
|
|
valueTypes: []wasm.ValueType{i32},
|
|
expMatched: false,
|
|
expValuesMsg: ` have [1123]
|
|
want [4294967295]`,
|
|
},
|
|
{
|
|
name: "matched/i64",
|
|
exps: []uint64{0},
|
|
actual: []uint64{0},
|
|
valueTypes: []wasm.ValueType{i64},
|
|
expMatched: true,
|
|
},
|
|
{
|
|
name: "unmatched/i64",
|
|
exps: []uint64{1},
|
|
actual: []uint64{0},
|
|
valueTypes: []wasm.ValueType{i64},
|
|
expMatched: false,
|
|
expValuesMsg: ` have [0]
|
|
want [1]`,
|
|
},
|
|
{
|
|
name: "unmatched/i64",
|
|
exps: []uint64{math.MaxUint64},
|
|
actual: []uint64{1123},
|
|
valueTypes: []wasm.ValueType{i64},
|
|
expMatched: false,
|
|
expValuesMsg: ` have [1123]
|
|
want [18446744073709551615]`,
|
|
},
|
|
{
|
|
name: "matched/f32",
|
|
exps: []uint64{0},
|
|
actual: []uint64{0},
|
|
valueTypes: []wasm.ValueType{f32},
|
|
expMatched: true,
|
|
},
|
|
{
|
|
name: "unmatched/f32",
|
|
exps: []uint64{uint64(math.Float32bits(-13123.1))},
|
|
actual: []uint64{0},
|
|
valueTypes: []wasm.ValueType{f32},
|
|
expMatched: false,
|
|
expValuesMsg: ` have [0.000000]
|
|
want [-13123.099609]`,
|
|
},
|
|
{
|
|
name: "matched/f64",
|
|
exps: []uint64{0},
|
|
actual: []uint64{0},
|
|
valueTypes: []wasm.ValueType{f64},
|
|
expMatched: true,
|
|
},
|
|
{
|
|
name: "unmatched/f64",
|
|
exps: []uint64{math.Float64bits(1.0)},
|
|
actual: []uint64{0},
|
|
valueTypes: []wasm.ValueType{f64},
|
|
expMatched: false,
|
|
expValuesMsg: ` have [0.000000]
|
|
want [1.000000]`,
|
|
},
|
|
{
|
|
name: "unmatched/f64",
|
|
actual: []uint64{math.Float64bits(-1231231.0)},
|
|
exps: []uint64{0},
|
|
valueTypes: []wasm.ValueType{f64},
|
|
expMatched: false,
|
|
expValuesMsg: ` have [-1231231.000000]
|
|
want [0.000000]`,
|
|
},
|
|
{
|
|
name: "matched/i8x16",
|
|
exps: []uint64{math.MaxUint64, 123},
|
|
actual: []uint64{math.MaxUint64, 123},
|
|
laneTypes: map[int]laneType{0: laneTypeI8},
|
|
valueTypes: []wasm.ValueType{v128},
|
|
expMatched: true,
|
|
},
|
|
{
|
|
name: "unmatched/i8x16",
|
|
exps: []uint64{0, 0xff<<56 | 0xaa},
|
|
actual: []uint64{math.MaxUint64, 0xff<<48 | 0xcc},
|
|
laneTypes: map[int]laneType{0: laneTypeI8},
|
|
valueTypes: []wasm.ValueType{v128},
|
|
expMatched: false,
|
|
expValuesMsg: ` have [i8x16(0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xcc, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0)]
|
|
want [i8x16(0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaa, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff)]`,
|
|
},
|
|
{
|
|
name: "matched/i16x8",
|
|
exps: []uint64{math.MaxUint64, 123},
|
|
actual: []uint64{math.MaxUint64, 123},
|
|
laneTypes: map[int]laneType{0: laneTypeI16},
|
|
valueTypes: []wasm.ValueType{v128},
|
|
expMatched: true,
|
|
},
|
|
{
|
|
name: "unmatched/i16x8",
|
|
exps: []uint64{0xffff << 32, 0},
|
|
actual: []uint64{0xaabb << 16, ^uint64(0)},
|
|
laneTypes: map[int]laneType{0: laneTypeI16},
|
|
valueTypes: []wasm.ValueType{v128},
|
|
expMatched: false,
|
|
expValuesMsg: ` have [i16x8(0x0, 0xaabb, 0x0, 0x0, 0xffff, 0xffff, 0xffff, 0xffff)]
|
|
want [i16x8(0x0, 0x0, 0xffff, 0x0, 0x0, 0x0, 0x0, 0x0)]`,
|
|
},
|
|
{
|
|
name: "matched/i32x4",
|
|
exps: []uint64{math.MaxUint64, 123},
|
|
actual: []uint64{math.MaxUint64, 123},
|
|
laneTypes: map[int]laneType{0: laneTypeI32},
|
|
valueTypes: []wasm.ValueType{v128},
|
|
expMatched: true,
|
|
},
|
|
{
|
|
name: "matched/i32x4",
|
|
exps: []uint64{0xffff_ffff<<32 | 0xa, 123},
|
|
actual: []uint64{0x1a1a_1a1a<<32 | 0xa, 123},
|
|
laneTypes: map[int]laneType{0: laneTypeI32},
|
|
valueTypes: []wasm.ValueType{v128},
|
|
expMatched: false,
|
|
expValuesMsg: ` have [i32x4(0xa, 0x1a1a1a1a, 0x7b, 0x0)]
|
|
want [i32x4(0xa, 0xffffffff, 0x7b, 0x0)]`,
|
|
},
|
|
{
|
|
name: "matched/i64x2",
|
|
exps: []uint64{math.MaxUint64, 123},
|
|
actual: []uint64{math.MaxUint64, 123},
|
|
laneTypes: map[int]laneType{0: laneTypeI64},
|
|
valueTypes: []wasm.ValueType{v128},
|
|
expMatched: true,
|
|
},
|
|
{
|
|
name: "unmatched/i64x2",
|
|
exps: []uint64{math.MaxUint64, 123},
|
|
actual: []uint64{math.MaxUint64, 0},
|
|
laneTypes: map[int]laneType{0: laneTypeI64},
|
|
valueTypes: []wasm.ValueType{v128},
|
|
expMatched: false,
|
|
expValuesMsg: ` have [i64x2(0xffffffffffffffff, 0x0)]
|
|
want [i64x2(0xffffffffffffffff, 0x7b)]`,
|
|
},
|
|
{
|
|
name: "matched/f32x4",
|
|
exps: []uint64{
|
|
(uint64(math.Float32bits(float32(math.NaN()))) << 32) | uint64(math.Float32bits(float32(math.NaN()))),
|
|
(uint64(math.Float32bits(float32(math.NaN()))) << 32) | uint64(math.Float32bits(float32(math.NaN()))),
|
|
},
|
|
actual: []uint64{
|
|
(uint64(math.Float32bits(float32(math.NaN()))) << 32) | uint64(math.Float32bits(float32(math.NaN()))),
|
|
(uint64(math.Float32bits(float32(math.NaN()))) << 32) | uint64(math.Float32bits(float32(math.NaN()))),
|
|
},
|
|
valueTypes: []wasm.ValueType{v128},
|
|
laneTypes: map[int]laneType{0: laneTypeF32},
|
|
expMatched: true,
|
|
},
|
|
{
|
|
name: "unmatched/f32x4",
|
|
exps: []uint64{
|
|
(uint64(math.Float32bits(float32(1.213))) << 32) | uint64(math.Float32bits(float32(math.NaN()))),
|
|
(uint64(math.Float32bits(float32(math.NaN()))) << 32) | uint64(math.Float32bits(float32(math.NaN()))),
|
|
},
|
|
actual: []uint64{
|
|
(uint64(math.Float32bits(float32(math.NaN()))) << 32) | uint64(math.Float32bits(float32(math.Inf(1)))),
|
|
(uint64(math.Float32bits(float32(math.Inf(-1)))) << 32) | uint64(math.Float32bits(float32(math.NaN()))),
|
|
},
|
|
valueTypes: []wasm.ValueType{v128},
|
|
laneTypes: map[int]laneType{0: laneTypeF32},
|
|
expMatched: false,
|
|
expValuesMsg: ` have [f32x4(+Inf, NaN, NaN, -Inf)]
|
|
want [f32x4(NaN, 1.213000, NaN, NaN)]`,
|
|
},
|
|
{
|
|
name: "matched/f64x2",
|
|
exps: []uint64{math.Float64bits(1.0), math.Float64bits(math.NaN())},
|
|
actual: []uint64{math.Float64bits(1.0), math.Float64bits(math.NaN())},
|
|
valueTypes: []wasm.ValueType{v128},
|
|
laneTypes: map[int]laneType{0: laneTypeF64},
|
|
expMatched: true,
|
|
},
|
|
{
|
|
name: "unmatched/f64x2",
|
|
exps: []uint64{math.Float64bits(1.0), math.Float64bits(math.NaN())},
|
|
actual: []uint64{math.Float64bits(-1.0), math.Float64bits(math.Inf(1))},
|
|
valueTypes: []wasm.ValueType{v128},
|
|
laneTypes: map[int]laneType{0: laneTypeF64},
|
|
expMatched: false,
|
|
expValuesMsg: ` have [f64x2(-1.000000, +Inf)]
|
|
want [f64x2(1.000000, NaN)]`,
|
|
},
|
|
{
|
|
name: "unmatched/f64x2",
|
|
exps: []uint64{math.Float64bits(math.Inf(1)), math.Float64bits(math.NaN())},
|
|
actual: []uint64{math.Float64bits(math.Inf(-1)), math.Float64bits(math.NaN())},
|
|
valueTypes: []wasm.ValueType{v128},
|
|
laneTypes: map[int]laneType{0: laneTypeF64},
|
|
expMatched: false,
|
|
expValuesMsg: ` have [f64x2(-Inf, NaN)]
|
|
want [f64x2(+Inf, NaN)]`,
|
|
},
|
|
{
|
|
name: "matched/[i32,f64x2]",
|
|
exps: []uint64{1, math.Float64bits(1.0), math.Float64bits(math.NaN())},
|
|
actual: []uint64{1, math.Float64bits(1.0), math.Float64bits(math.NaN())},
|
|
valueTypes: []wasm.ValueType{i32, v128},
|
|
laneTypes: map[int]laneType{1: laneTypeF64},
|
|
expMatched: true,
|
|
},
|
|
{
|
|
name: "unmatched/[i32,f64x2]",
|
|
exps: []uint64{123, math.Float64bits(math.Inf(1)), math.Float64bits(math.NaN())},
|
|
actual: []uint64{123, math.Float64bits(math.Inf(-1)), math.Float64bits(math.NaN())},
|
|
valueTypes: []wasm.ValueType{i32, v128},
|
|
laneTypes: map[int]laneType{1: laneTypeF64},
|
|
expMatched: false,
|
|
expValuesMsg: ` have [123, f64x2(-Inf, NaN)]
|
|
want [123, f64x2(+Inf, NaN)]`,
|
|
},
|
|
{
|
|
name: "matched/[i32,f64x2]",
|
|
exps: []uint64{math.Float64bits(1.0), math.Float64bits(math.NaN()), 1},
|
|
actual: []uint64{math.Float64bits(1.0), math.Float64bits(math.NaN()), 1},
|
|
valueTypes: []wasm.ValueType{v128, i32},
|
|
laneTypes: map[int]laneType{0: laneTypeF64},
|
|
expMatched: true,
|
|
},
|
|
{
|
|
name: "unmatched/[f64x2,i32]",
|
|
exps: []uint64{math.Float64bits(math.Inf(1)), math.Float64bits(math.NaN()), 123},
|
|
actual: []uint64{math.Float64bits(math.Inf(-1)), math.Float64bits(math.NaN()), 123},
|
|
valueTypes: []wasm.ValueType{v128, i32},
|
|
laneTypes: map[int]laneType{0: laneTypeF64},
|
|
expMatched: false,
|
|
expValuesMsg: ` have [f64x2(-Inf, NaN), 123]
|
|
want [f64x2(+Inf, NaN), 123]`,
|
|
},
|
|
{
|
|
name: "matched/[f32,i32,f64x2]",
|
|
exps: []uint64{uint64(math.Float32bits(float32(math.NaN()))), math.Float64bits(1.0), math.Float64bits(math.NaN()), 1},
|
|
actual: []uint64{uint64(math.Float32bits(float32(math.NaN()))), math.Float64bits(1.0), math.Float64bits(math.NaN()), 1},
|
|
valueTypes: []wasm.ValueType{f32, v128, i32},
|
|
laneTypes: map[int]laneType{1: laneTypeF64},
|
|
expMatched: true,
|
|
},
|
|
{
|
|
name: "unmatched/[f32,f64x2,i32]",
|
|
exps: []uint64{uint64(math.Float32bits(1.0)), math.Float64bits(math.Inf(1)), math.Float64bits(math.NaN()), 123},
|
|
actual: []uint64{uint64(math.Float32bits(1.0)), math.Float64bits(math.Inf(-1)), math.Float64bits(math.NaN()), 123},
|
|
valueTypes: []wasm.ValueType{f32, v128, i32},
|
|
laneTypes: map[int]laneType{1: laneTypeF64},
|
|
expMatched: false,
|
|
expValuesMsg: ` have [1.000000, f64x2(-Inf, NaN), 123]
|
|
want [1.000000, f64x2(+Inf, NaN), 123]`,
|
|
},
|
|
{
|
|
name: "matched/[i8x16,f64x2]",
|
|
exps: []uint64{0, 0, math.Float64bits(1.0), math.Float64bits(math.NaN())},
|
|
actual: []uint64{0, 0, math.Float64bits(1.0), math.Float64bits(math.NaN())},
|
|
valueTypes: []wasm.ValueType{v128, v128},
|
|
laneTypes: map[int]laneType{0: laneTypeI8, 1: laneTypeF64},
|
|
expMatched: true,
|
|
},
|
|
{
|
|
name: "unmatched/[i8x16,f64x2]",
|
|
exps: []uint64{0, 0xff << 56, math.Float64bits(1.0), math.Float64bits(math.NaN())},
|
|
actual: []uint64{0, 0xaa << 56, math.Float64bits(1.0), math.Float64bits(math.NaN())},
|
|
valueTypes: []wasm.ValueType{v128, v128},
|
|
laneTypes: map[int]laneType{0: laneTypeI8, 1: laneTypeF64},
|
|
expMatched: false,
|
|
expValuesMsg: ` have [i8x16(0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xaa), f64x2(1.000000, NaN)]
|
|
want [i8x16(0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff), f64x2(1.000000, NaN)]`,
|
|
},
|
|
{
|
|
name: "unmatched/[i8x16,f64x2]",
|
|
exps: []uint64{0, 0xff << 56, math.Float64bits(1.0), math.Float64bits(math.NaN())},
|
|
actual: []uint64{0, 0xff << 56, math.Float64bits(1.0), math.Float64bits(math.Inf(1))},
|
|
valueTypes: []wasm.ValueType{v128, v128},
|
|
laneTypes: map[int]laneType{0: laneTypeI8, 1: laneTypeF64},
|
|
expMatched: false,
|
|
expValuesMsg: ` have [i8x16(0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff), f64x2(1.000000, +Inf)]
|
|
want [i8x16(0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff), f64x2(1.000000, NaN)]`,
|
|
},
|
|
{
|
|
name: "matched/[i8x16,i32,f64x2]",
|
|
exps: []uint64{0, 0, math.MaxUint32, math.Float64bits(1.0), math.Float64bits(math.NaN())},
|
|
actual: []uint64{0, 0, math.MaxUint32, math.Float64bits(1.0), math.Float64bits(math.NaN())},
|
|
valueTypes: []wasm.ValueType{v128, i32, v128},
|
|
laneTypes: map[int]laneType{0: laneTypeI8, 2: laneTypeF64},
|
|
expMatched: true,
|
|
},
|
|
{
|
|
name: "matched/[i8x16,i32,f64x2]",
|
|
exps: []uint64{0, 0, math.MaxUint32, math.Float64bits(1.0), math.Float64bits(math.NaN())},
|
|
actual: []uint64{0, 0, math.MaxUint32 - 1, math.Float64bits(1.0), math.Float64bits(math.NaN())},
|
|
valueTypes: []wasm.ValueType{v128, i32, v128},
|
|
laneTypes: map[int]laneType{0: laneTypeI8, 2: laneTypeF64},
|
|
expMatched: false,
|
|
expValuesMsg: ` have [i8x16(0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0), 4294967294, f64x2(1.000000, NaN)]
|
|
want [i8x16(0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0), 4294967295, f64x2(1.000000, NaN)]`,
|
|
},
|
|
{
|
|
name: "matched/[i8x16,i32,f64x2]",
|
|
exps: []uint64{0, 0, math.MaxUint32, math.Float64bits(1.0), math.Float64bits(math.NaN())},
|
|
actual: []uint64{0, 0xff << 16, math.MaxUint32, math.Float64bits(1.0), math.Float64bits(math.NaN())},
|
|
valueTypes: []wasm.ValueType{v128, i32, v128},
|
|
laneTypes: map[int]laneType{0: laneTypeI8, 2: laneTypeF64},
|
|
expMatched: false,
|
|
expValuesMsg: ` have [i8x16(0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0), 4294967295, f64x2(1.000000, NaN)]
|
|
want [i8x16(0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0), 4294967295, f64x2(1.000000, NaN)]`,
|
|
},
|
|
}
|
|
|
|
for _, tc := range tests {
|
|
tc := tc
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
actualMatched, actualValuesMsg := valuesEq(tc.actual, tc.exps, tc.valueTypes, tc.laneTypes)
|
|
require.Equal(t, tc.expMatched, actualMatched)
|
|
require.Equal(t, tc.expValuesMsg, actualValuesMsg)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCommandActionVal_toUint64s(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
rawCommandActionVal string
|
|
exp []uint64
|
|
}{
|
|
{
|
|
name: "i32",
|
|
rawCommandActionVal: `{"type": "i32", "value": "0"}`,
|
|
exp: []uint64{0},
|
|
},
|
|
{
|
|
name: "i32",
|
|
rawCommandActionVal: `{"type": "i32", "value": "4294967295"}`,
|
|
exp: []uint64{4294967295},
|
|
},
|
|
{
|
|
name: "i64",
|
|
rawCommandActionVal: `{"type": "i64", "value": "0"}`,
|
|
exp: []uint64{0},
|
|
},
|
|
{
|
|
name: "i64",
|
|
rawCommandActionVal: `{"type": "i64", "value": "7034535277573963776"}`,
|
|
exp: []uint64{7034535277573963776},
|
|
},
|
|
{
|
|
name: "f32",
|
|
rawCommandActionVal: `{"type": "f32", "value": "0"}`,
|
|
exp: []uint64{0},
|
|
},
|
|
{
|
|
name: "f32",
|
|
rawCommandActionVal: `{"type": "f32", "value": "2147483648"}`,
|
|
exp: []uint64{2147483648},
|
|
},
|
|
{
|
|
name: "f64",
|
|
rawCommandActionVal: `{"type": "f64", "value": "0"}`,
|
|
exp: []uint64{0},
|
|
},
|
|
{
|
|
name: "f64",
|
|
rawCommandActionVal: `{"type": "f64", "value": "4616189618054758400"}`,
|
|
exp: []uint64{4616189618054758400},
|
|
},
|
|
{
|
|
name: "f32x4",
|
|
rawCommandActionVal: `{"type": "v128", "lane_type": "f32", "value": ["645922816", "645922816", "645922816", "645922816"]}`,
|
|
exp: []uint64{645922816<<32 | 645922816, 645922816<<32 | 645922816},
|
|
},
|
|
{
|
|
name: "f32x4",
|
|
rawCommandActionVal: `{"type": "v128", "lane_type": "f32", "value": ["nan:canonical", "nan:arithmetic", "nan:canonical", "nan:arithmetic"]}`,
|
|
exp: []uint64{
|
|
uint64(moremath.F32CanonicalNaNBits) | (uint64(moremath.F32ArithmeticNaNBits) << 32),
|
|
uint64(moremath.F32CanonicalNaNBits) | (uint64(moremath.F32ArithmeticNaNBits) << 32),
|
|
},
|
|
},
|
|
{
|
|
name: "f64x2",
|
|
rawCommandActionVal: `{"type": "v128", "lane_type": "f64", "value": ["9223372036854775808", "9223372036854775808"]}`,
|
|
exp: []uint64{9223372036854775808, 9223372036854775808},
|
|
},
|
|
{
|
|
name: "f64x2",
|
|
rawCommandActionVal: `{"type": "v128", "lane_type": "f64", "value": ["nan:canonical", "nan:arithmetic"]}`,
|
|
exp: []uint64{moremath.F64CanonicalNaNBits, moremath.F64ArithmeticNaNBits},
|
|
},
|
|
{
|
|
name: "i8x16",
|
|
rawCommandActionVal: `{"type": "v128", "lane_type": "i8", "value": ["128", "129", "130", "131", "253", "254", "255", "0", "0", "1", "2", "127", "128", "253", "254", "255"]}`,
|
|
exp: []uint64{
|
|
128 | (129 << 8) | (130 << 16) | (131 << 24) | (253 << 32) | (254 << 40) | (255 << 48),
|
|
1<<8 | 2<<16 | 127<<24 | 128<<32 | 253<<40 | 254<<48 | 255<<56,
|
|
},
|
|
},
|
|
{
|
|
name: "i16x8",
|
|
rawCommandActionVal: `{"type": "v128", "lane_type": "i16", "value": ["256", "770", "1284", "1798", "2312", "2826", "3340", "3854"]}`,
|
|
exp: []uint64{
|
|
256 | 770<<16 | 1284<<32 | 1798<<48,
|
|
2312 | 2826<<16 | 3340<<32 | 3854<<48,
|
|
},
|
|
},
|
|
{
|
|
name: "i32x4",
|
|
rawCommandActionVal: `{"type": "v128", "lane_type": "i32", "value": ["123", "32766", "32766", "40000"]}`,
|
|
exp: []uint64{
|
|
123 | 32766<<32,
|
|
32766 | 40000<<32,
|
|
},
|
|
},
|
|
{
|
|
name: "i64x2",
|
|
rawCommandActionVal: `{"type": "v128", "lane_type": "i64", "value": ["18446744073709551615", "123124"]}`,
|
|
exp: []uint64{
|
|
18446744073709551615,
|
|
123124,
|
|
},
|
|
},
|
|
}
|
|
|
|
for _, tc := range tests {
|
|
tc := tc
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
var c commandActionVal
|
|
err := json.Unmarshal([]byte(tc.rawCommandActionVal), &c)
|
|
require.NoError(t, err)
|
|
actual := c.toUint64s()
|
|
require.Equal(t, tc.exp, actual)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCommand_getAssertReturnArgsExps(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
rawCommand string
|
|
args, exps []uint64
|
|
}{
|
|
{
|
|
name: "1",
|
|
rawCommand: `
|
|
{
|
|
"type": "assert_return",
|
|
"line": 148,
|
|
"action": {
|
|
"type": "invoke", "field": "f32x4.min",
|
|
"args": [
|
|
{"type": "v128", "lane_type": "f32", "value": ["2147483648", "123", "2147483648", "1"]},
|
|
{"type": "v128", "lane_type": "i8", "value": ["128", "129", "130", "131", "253", "254", "255", "0", "0", "1", "2", "127", "128", "253", "254", "255"]}
|
|
]
|
|
},
|
|
"expected": [
|
|
{"type": "v128", "lane_type": "f32", "value": ["2147483648", "0", "0", "2147483648"]}
|
|
]
|
|
}`,
|
|
args: []uint64{
|
|
123<<32 | 2147483648,
|
|
1<<32 | 2147483648,
|
|
128 | (129 << 8) | (130 << 16) | (131 << 24) | (253 << 32) | (254 << 40) | (255 << 48),
|
|
1<<8 | 2<<16 | 127<<24 | 128<<32 | 253<<40 | 254<<48 | 255<<56,
|
|
},
|
|
exps: []uint64{
|
|
2147483648,
|
|
2147483648 << 32,
|
|
},
|
|
},
|
|
}
|
|
|
|
for _, tc := range tests {
|
|
tc := tc
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
var c command
|
|
err := json.Unmarshal([]byte(tc.rawCommand), &c)
|
|
require.NoError(t, err)
|
|
actualArgs, actualExps := c.getAssertReturnArgsExps()
|
|
require.Equal(t, tc.args, actualArgs)
|
|
require.Equal(t, tc.exps, actualExps)
|
|
})
|
|
}
|
|
}
|