More tests!

ml-proto/TestingTodo.md

@@ -49,8 +49,8 @@ Floating point semantics:
  - ~~test that nearestint doesn't do JS-style Math.round or C-style round(3) rounding~~
  - ~~test that signalling NaN doesn't cause weirdness~~
  - ~~test that signalling/quiet NaNs can have sign bits and payloads in literals~~
- - test that conversion from int32/int64 to float32 rounds correctly
- - test that [relaxed optimizations](https://gcc.gnu.org/wiki/FloatingPointMath) are not done
+ - ~~test that conversion from int32/int64 to float32 rounds correctly~~
+ - ~~test that [relaxed optimizations](https://gcc.gnu.org/wiki/FloatingPointMath) are not done~~
 
 Linear memory semantics:
  - test that loading from null works
@@ -82,13 +82,14 @@ Expression optimizer bait:
  - ~~test that floating-point division by immediate 0 and -0 is defined~~
  - ~~test that floating-point (x*y)/y isn't folded to x~~
  - ~~test that floating-point (x+y)-y isn't folded to x~~
- - test that ult/ugt/etc (formed with a not operator) aren't folded to oge/ole/etc.
+ - ~~test that ult/ugt/etc (formed with a not operator) aren't folded to oge/ole/etc.~~
  - ~~test that floating point add/mul aren't reassociated even when tempting~~
  - ~~test that floating point mul+add isn't folded to fma even when tempting~~
  - ~~test that floating point sqrt(x*x+y*y) isn't folded to hypot even when tempting~~
  - ~~test that 1/x isn't translated into reciprocal-approximate~~
  - ~~test that 1/sqrt(x) isn't approximated either~~
  - ~~test that fp division by non-power-2 constant gets full precision (isn't a multiply-by-reciprocal deal)?~~
+ - ~~test that x<y?x:y is not folded to min, etc.~~
 
 Misc optimizer bait:
  - ~~test that the impl doesn't constant-fold away or DCE away or speculate operations that should trap, such as `1/0u`, `1/0`, `1%0u`, `1%0, convertToInt(NaN)`, `INT_MIN/-1` and so on.~~
@@ -109,11 +110,6 @@ Misc x87-isms:
  - ~~test for evaluating intermediate results at greater precision~~
  - ~~test for loading and storing NaNs~~
 
-Control flow:
- - test that continue goes to the right place in `do_while` and `forever`
- - test that break goes to the right place in all cases where it can appear
- - test devious switch case patterns
-
 Validation errors:
  - load/store or variables with type void/bool/funcptr/etc.
  - sign-extend load from int64 to int32 etc.

ml-proto/test/conversions.wast

@@ -268,13 +268,23 @@
 (assert_return (invoke "f32.convert_s_i32" (i32.const 2147483647)) (f32.const 2147483648))
 (assert_return (invoke "f32.convert_s_i32" (i32.const -2147483648)) (f32.const -2147483648))
 (assert_return (invoke "f32.convert_s_i32" (i32.const 1234567890)) (f32.const 0x1.26580cp+30))
+;; Test rounding directions.
+(assert_return (invoke "f32.convert_s_i32" (i32.const 16777217)) (f32.const 16777216.0))
+(assert_return (invoke "f32.convert_s_i32" (i32.const -16777217)) (f32.const -16777216.0))
+(assert_return (invoke "f32.convert_s_i32" (i32.const 16777219)) (f32.const 16777220.0))
+(assert_return (invoke "f32.convert_s_i32" (i32.const -16777219)) (f32.const -16777220.0))
 
 (assert_return (invoke "f32.convert_s_i64" (i64.const 1)) (f32.const 1.0))
 (assert_return (invoke "f32.convert_s_i64" (i64.const -1)) (f32.const -1.0))
 (assert_return (invoke "f32.convert_s_i64" (i64.const 0)) (f32.const 0.0))
 (assert_return (invoke "f32.convert_s_i64" (i64.const 9223372036854775807)) (f32.const 9223372036854775807))
 (assert_return (invoke "f32.convert_s_i64" (i64.const -9223372036854775808)) (f32.const -9223372036854775808))
 (assert_return (invoke "f32.convert_s_i64" (i64.const 314159265358979)) (f32.const 0x1.1db9e8p+48)) ;; PI
+;; Test rounding directions.
+(assert_return (invoke "f32.convert_s_i64" (i64.const 16777217)) (f32.const 16777216.0))
+(assert_return (invoke "f32.convert_s_i64" (i64.const -16777217)) (f32.const -16777216.0))
+(assert_return (invoke "f32.convert_s_i64" (i64.const 16777219)) (f32.const 16777220.0))
+(assert_return (invoke "f32.convert_s_i64" (i64.const -16777219)) (f32.const -16777220.0))
 
 (assert_return (invoke "f64.convert_s_i32" (i32.const 1)) (f64.const 1.0))
 (assert_return (invoke "f64.convert_s_i32" (i32.const -1)) (f64.const -1.0))
@@ -289,19 +299,30 @@
 (assert_return (invoke "f64.convert_s_i64" (i64.const 9223372036854775807)) (f64.const 9223372036854775807))
 (assert_return (invoke "f64.convert_s_i64" (i64.const -9223372036854775808)) (f64.const -9223372036854775808))
 (assert_return (invoke "f64.convert_s_i64" (i64.const 4669201609102990)) (f64.const 4669201609102990)) ;; Feigenbaum
+;; Test rounding directions.
+(assert_return (invoke "f64.convert_s_i64" (i64.const 9007199254740993)) (f64.const 9007199254740992))
+(assert_return (invoke "f64.convert_s_i64" (i64.const -9007199254740993)) (f64.const -9007199254740992))
+(assert_return (invoke "f64.convert_s_i64" (i64.const 9007199254740995)) (f64.const 9007199254740996))
+(assert_return (invoke "f64.convert_s_i64" (i64.const -9007199254740995)) (f64.const -9007199254740996))
 
 (assert_return (invoke "f32.convert_u_i32" (i32.const 1)) (f32.const 1.0))
 (assert_return (invoke "f32.convert_u_i32" (i32.const 0)) (f32.const 0.0))
 (assert_return (invoke "f32.convert_u_i32" (i32.const 2147483647)) (f32.const 2147483648))
 (assert_return (invoke "f32.convert_u_i32" (i32.const -2147483648)) (f32.const 2147483648))
 (assert_return (invoke "f32.convert_u_i32" (i32.const 0x12345678)) (f32.const 0x1.234568p+28))
 (assert_return (invoke "f32.convert_u_i32" (i32.const 0xffffffff)) (f32.const 4294967296.0))
+;; Test rounding directions.
+(assert_return (invoke "f32.convert_u_i32" (i32.const 16777217)) (f32.const 16777216.0))
+(assert_return (invoke "f32.convert_u_i32" (i32.const 16777219)) (f32.const 16777220.0))
 
 (assert_return (invoke "f32.convert_u_i64" (i64.const 1)) (f32.const 1.0))
 (assert_return (invoke "f32.convert_u_i64" (i64.const 0)) (f32.const 0.0))
 (assert_return (invoke "f32.convert_u_i64" (i64.const 9223372036854775807)) (f32.const 9223372036854775807))
 (assert_return (invoke "f32.convert_u_i64" (i64.const -9223372036854775808)) (f32.const 9223372036854775808))
 (assert_return (invoke "f32.convert_u_i64" (i64.const 0xffffffffffffffff)) (f32.const 18446744073709551616.0))
+;; Test rounding directions.
+(assert_return (invoke "f32.convert_u_i64" (i64.const 16777217)) (f32.const 16777216.0))
+(assert_return (invoke "f32.convert_u_i64" (i64.const 16777219)) (f32.const 16777220.0))
 
 (assert_return (invoke "f64.convert_u_i32" (i32.const 1)) (f64.const 1.0))
 (assert_return (invoke "f64.convert_u_i32" (i32.const 0)) (f64.const 0.0))
@@ -314,6 +335,9 @@
 (assert_return (invoke "f64.convert_u_i64" (i64.const 9223372036854775807)) (f64.const 9223372036854775807))
 (assert_return (invoke "f64.convert_u_i64" (i64.const -9223372036854775808)) (f64.const 9223372036854775808))
 (assert_return (invoke "f64.convert_u_i64" (i64.const 0xffffffffffffffff)) (f64.const 18446744073709551616.0))
+;; Test rounding directions.
+(assert_return (invoke "f64.convert_u_i64" (i64.const 9007199254740993)) (f64.const 9007199254740992))
+(assert_return (invoke "f64.convert_u_i64" (i64.const 9007199254740995)) (f64.const 9007199254740996))
 
 (assert_return (invoke "f64.promote_f32" (f32.const 0.0)) (f64.const 0.0))
 (assert_return (invoke "f64.promote_f32" (f32.const -0.0)) (f64.const -0.0))

ml-proto/test/f32.wast

@@ -1,3 +1,6 @@
+;; Test all the f32 operators on major boundary values and all special
+;; values (except comparison operators, which are tested in f32_cmp.wast).
+
 (module
   (func $add (param $x f32) (param $y f32) (result f32) (f32.add (get_local $x) (get_local $y)))
   (func $sub (param $x f32) (param $y f32) (result f32) (f32.sub (get_local $x) (get_local $y)))

ml-proto/test/f32_cmp.wast

@@ -1,3 +1,6 @@
+;; Test all the f32 comparison operators on major boundary values and all
+;; special values.
+
 (module
   (func $eq (param $x f32) (param $y f32) (result i32) (f32.eq (get_local $x) (get_local $y)))
   (func $ne (param $x f32) (param $y f32) (result i32) (f32.ne (get_local $x) (get_local $y)))

ml-proto/test/f64.wast

@@ -1,3 +1,6 @@
+;; Test all the f64 operators on major boundary values and all special
+;; values (except comparison operators, which are tested in f64_cmp.wast).
+
 (module
   (func $add (param $x f64) (param $y f64) (result f64) (f64.add (get_local $x) (get_local $y)))
   (func $sub (param $x f64) (param $y f64) (result f64) (f64.sub (get_local $x) (get_local $y)))

ml-proto/test/f64_cmp.wast

@@ -1,3 +1,6 @@
+;; Test all the f64 comparison operators on major boundary values and all
+;; special values.
+
 (module
   (func $eq (param $x f64) (param $y f64) (result i32) (f64.eq (get_local $x) (get_local $y)))
   (func $ne (param $x f64) (param $y f64) (result i32) (f64.ne (get_local $x) (get_local $y)))