tests: use must-not-fail in some places

diff --git a/basis/cache/cache-tests.factor b/basis/cache/cache-tests.factor
index 1726dbcd8cb77a8d143920e4cc3285ecba6cb8ca..6e1dda3d98e8ab3c3efe3d5d02c5c4aeab0f6469 100644 (file)
--- a/basis/cache/cache-tests.factor
+++ b/basis/cache/cache-tests.factor
@@ -13,7 +13,7 @@ M: mock-disposable dispose* drop ;
 
 { 0 } [ "cache" get assoc-size ] unit-test
 
-{ } [ "cache" get 2 >>max-age drop ] unit-test
+[ "cache" get 2 >>max-age drop ] must-not-fail
 
 { } [ 1 <mock-disposable> dup "a" set 2 "cache" get set-at ] unit-test
 

diff --git a/basis/columns/columns-tests.factor b/basis/columns/columns-tests.factor
index 4bd8af976eb00e67e522a50587055c6584ef2c5d..855e100bbabedf72076b6587f1dabbbcdfd2b953 100644 (file)
--- a/basis/columns/columns-tests.factor
+++ b/basis/columns/columns-tests.factor
@@ -5,7 +5,7 @@ tools.test ;
 { { 1 2 3 } { 4 5 6 } { 7 8 9 } } [ clone ] map "seq" set
 
 { { 1 4 7 } } [ "seq" get 0 <column> >array ] unit-test
-{ } [ "seq" get 1 <column> [ sq ] map! drop ] unit-test
+[ "seq" get 1 <column> [ sq ] map! ] must-not-fail
 { { 4 25 64 } } [ "seq" get 1 <column> >array ] unit-test
 
 { { { 1 3 } { 2 4 } } } [ { { 1 2 } { 3 4 } } <flipped> [ >array ] map ] unit-test

diff --git a/basis/compiler/codegen/codegen-tests.factor b/basis/compiler/codegen/codegen-tests.factor
index d90c6bdda123f4c18fdf02ae9efe0e179ca54983..71fce2f3ee74239820cc3d8a86339c9a4923fde7 100644 (file)
--- a/basis/compiler/codegen/codegen-tests.factor
+++ b/basis/compiler/codegen/codegen-tests.factor
@@ -9,11 +9,11 @@ IN: compiler.codegen.tests
 ] unit-test
 
 
-{ } [ [ ] with-fixup drop ] unit-test
-{ } [ [ \ + %call ] with-fixup drop ] unit-test
+[ [ ] with-fixup ] must-not-fail
+[ [ \ + %call ] with-fixup ] must-not-fail
 
-{ } [ [ <label> dup define-label dup resolve-label %jump-label ] with-fixup drop ] unit-test
-{ } [ [ <label> dup define-label dup resolve-label B{ 0 0 0 0 } % rc-absolute-cell label-fixup ] with-fixup drop ] unit-test
+[ [ <label> dup define-label dup resolve-label %jump-label ] with-fixup ] must-not-fail
+[ [ <label> dup define-label dup resolve-label B{ 0 0 0 0 } % rc-absolute-cell label-fixup ] with-fixup ] must-not-fail
 
 ! Error checking
 [ [ <label> dup define-label %jump-label ] with-fixup ] must-fail

diff --git a/basis/compiler/tests/alien.factor b/basis/compiler/tests/alien.factor
index faea5a6fe63ccb3cd237255fbc51a8724b0994e0..bd476d31c4e0675480fa97fb0384f58a60d182a3 100644 (file)
--- a/basis/compiler/tests/alien.factor
+++ b/basis/compiler/tests/alien.factor
@@ -580,7 +580,7 @@ FUNCTION: test_struct_14 ffi_test_44 ( ) inline
 
 : stack-frame-bustage ( -- a b ) ffi_test_44 gc 3 ;
 
-[ ] [ stack-frame-bustage 2drop ] unit-test
+[ stack-frame-bustage ] must-not-fail
 
 ! C99 tests
 os windows? [

diff --git a/basis/compiler/tests/intrinsics.factor b/basis/compiler/tests/intrinsics.factor
index 54cb289e5ba55b998e018656ba70abb1158daa5b..41366e05e2777b1ae35479b0580d577c8f254e89 100644 (file)
--- a/basis/compiler/tests/intrinsics.factor
+++ b/basis/compiler/tests/intrinsics.factor
@@ -55,7 +55,7 @@ IN: compiler.tests.intrinsics
 [ 0x123456 ] [ 1 [ "a\u123456c" string-nth ] compile-call ] unit-test
 [ 0x123456 ] [ [ 1 "a\u123456c" string-nth ] compile-call ] unit-test
 
-[ ] [ [ 0 special-object ] compile-call drop ] unit-test
+[ [ 0 special-object ] compile-call ] must-not-fail
 [ ] [ 1 special-object [ 1 set-special-object ] compile-call ] unit-test
 
 [ ] [ 1 [ drop ] compile-call ] unit-test

diff --git a/basis/compiler/tests/optimizer.factor b/basis/compiler/tests/optimizer.factor
index ca3893933691a926d18ce280f123e812527590b0..f8e830db7831cfd390252567a6ad3e5b62bb1b1d 100644 (file)
--- a/basis/compiler/tests/optimizer.factor
+++ b/basis/compiler/tests/optimizer.factor
@@ -205,9 +205,9 @@ M: number detect-number ;
 
 [ t ] [ \ node-successor-f-bug word-optimized? ] unit-test
 
-[ ] [ [ new ] build-tree optimize-tree drop ] unit-test
+[ [ new ] build-tree optimize-tree ] must-not-fail
 
-[ ] [ [ <tuple> ] build-tree optimize-tree drop ] unit-test
+[ [ <tuple> ] build-tree optimize-tree ] must-not-fail
 
 ! Regression
 : lift-throw-tail-regression ( obj -- obj str )
@@ -277,7 +277,7 @@ HINTS: recursive-inline-hang-3 array ;
 : member-test ( obj -- ? ) { + - * / /i } member? ;
 
 \ member-test def>> must-infer
-[ ] [ \ member-test build-tree optimize-tree drop ] unit-test
+[ \ member-test build-tree optimize-tree ] must-not-fail
 [ t ] [ \ + member-test ] unit-test
 [ f ] [ \ append member-test ] unit-test
 

diff --git a/basis/compiler/tests/simple.factor b/basis/compiler/tests/simple.factor
index 1847c1a33d94c5301c35bf1e7cc0dc46387ef24b..9bb0cd42c0284253d5dafa720511a58a5c3dca5e 100644 (file)
--- a/basis/compiler/tests/simple.factor
+++ b/basis/compiler/tests/simple.factor
@@ -66,7 +66,7 @@ IN: compiler.tests.simple
 
 ! Regression
 
-[ ] [ [ get-callstack ] compile-call drop ] unit-test
+[ [ get-callstack ] compile-call ] must-not-fail
 
 ! Regression
 

diff --git a/basis/compiler/tree/dead-code/dead-code-tests.factor b/basis/compiler/tree/dead-code/dead-code-tests.factor
index 07394ecede394d8e9f85b54a01573716c120cefc..5e9f8027e08d4976fa24c5b33ddad124baeaa0fa 100644 (file)
--- a/basis/compiler/tree/dead-code/dead-code-tests.factor
+++ b/basis/compiler/tree/dead-code/dead-code-tests.factor
@@ -97,13 +97,13 @@ IN: compiler.tree.dead-code.tests
 
 { [ [ f ] [ f ] if ] } [ [ [ f ] [ f ] if ] optimize-quot ] unit-test
 
-{ } [ [ dup [ 3 throw ] [ ] if ] optimize-quot drop ] unit-test
+[ [ dup [ 3 throw ] [ ] if ] optimize-quot ] must-not-fail
 
 { [ [ . ] [ drop ] if ] } [ [ [ dup . ] [ ] if drop ] optimize-quot ] unit-test
 
 { [ f ] } [ [ f dup [ ] [ ] if ] optimize-quot ] unit-test
 
-{ } [ [ over [ ] [ dup [ "X" throw ] [ "X" throw ] if ] if ] optimize-quot drop ] unit-test
+[ [ over [ ] [ dup [ "X" throw ] [ "X" throw ] if ] if ] optimize-quot ] must-not-fail
 
 : boo ( a b -- c ) 2drop f ;
 
@@ -161,20 +161,20 @@ IN: compiler.tree.dead-code.tests
     [ call-recursive-dce-4 drop ] optimize-quot squish
 ] unit-test
 
-{ } [ [ f call-recursive-dce-3 swap ] optimize-quot drop ] unit-test
+[ [ f call-recursive-dce-3 swap ] optimize-quot ] must-not-fail
 
 : call-recursive-dce-5 ( -- ) call-recursive-dce-5 ; inline recursive
 
-{ } [ [ call-recursive-dce-5 swap ] optimize-quot drop ] unit-test
+[ [ call-recursive-dce-5 swap ] optimize-quot ] must-not-fail
 
-{ } [ [ [ 0 -rot set-nth-unsafe ] curry each-integer-from ] optimize-quot drop ] unit-test
+[ [ [ 0 -rot set-nth-unsafe ] curry each-integer-from ] optimize-quot ] must-not-fail
 
 : call-recursive-dce-6 ( i quot: ( ..a -- ..b ) -- i )
     dup call [ drop ] [ call-recursive-dce-6 ] if ; inline recursive
 
-{ } [ [ [ ] curry [ ] swap compose call-recursive-dce-6 ] optimize-quot drop ] unit-test
+[ [ [ ] curry [ ] swap compose call-recursive-dce-6 ] optimize-quot ] must-not-fail
 
-{ } [ [ [ ] rot [ . ] curry pick [ roll 2drop call ] [ 2nip call ] if ] optimize-quot drop ] unit-test
+[ [ [ ] rot [ . ] curry pick [ roll 2drop call ] [ 2nip call ] if ] optimize-quot ] must-not-fail
 
 { [ drop ] } [ [ array? drop ] optimize-quot ] unit-test
 
@@ -203,7 +203,7 @@ IN: compiler.tree.dead-code.tests
 : call-recursive-dce-7 ( obj -- elt ? )
     dup 5 = [ t ] [ dup [ call-recursive-dce-7 ] [ drop f f ] if ] if ; inline recursive
 
-{ } [ [ call-recursive-dce-7 ] optimize-quot drop ] unit-test
+[ [ call-recursive-dce-7 ] optimize-quot ] must-not-fail
 
 { [ /i ] } [ [ /mod drop ] optimize-quot ] unit-test
 

diff --git a/basis/compiler/tree/escape-analysis/escape-analysis-tests.factor b/basis/compiler/tree/escape-analysis/escape-analysis-tests.factor
index 505325807a8cbe4a343e26030bd699e3bd7b668f..39e8df86a7c4ec05a6b2ad618a6f0f178a562200 100644 (file)
--- a/basis/compiler/tree/escape-analysis/escape-analysis-tests.factor
+++ b/basis/compiler/tree/escape-analysis/escape-analysis-tests.factor
@@ -314,7 +314,7 @@ C: <ro-box> ro-box
 
 TUPLE: empty-tuple ;
 
-{ } [ [ empty-tuple boa layout-of ] count-unboxed-allocations drop ] unit-test
+[ [ empty-tuple boa layout-of ] count-unboxed-allocations ] must-not-fail
 
 ! New feature!
 

diff --git a/basis/compiler/tree/propagation/call-effect/call-effect-tests.factor b/basis/compiler/tree/propagation/call-effect/call-effect-tests.factor
index 4454c4f2fcbc0819b4b1fc75b260e3479c1aa740..745e84e7e0ad32e1d7380c38a841397d8fb1ca64 100644 (file)
--- a/basis/compiler/tree/propagation/call-effect/call-effect-tests.factor
+++ b/basis/compiler/tree/propagation/call-effect/call-effect-tests.factor
@@ -118,8 +118,8 @@ IN: compiler.tree.propagation.call-effect.tests
 { f } [ [ dup drop ] final-info first infer-value ] unit-test
 
 ! This should not hang
-{ } [ [ [ dup call( quot -- ) ] dup call( quot -- ) ] final-info drop ] unit-test
-{ } [ [ [ dup curry call( quot -- ) ] dup curry call( quot -- ) ] final-info drop ] unit-test
+[ [ [ dup call( quot -- ) ] dup call( quot -- ) ] final-info ] must-not-fail
+[ [ [ dup curry call( quot -- ) ] dup curry call( quot -- ) ] final-info ] must-not-fail
 
 ! This should get inlined, because the parameter to the curry is literal even though
 ! [ boa ] by itself doesn't infer

diff --git a/basis/compiler/tree/propagation/info/info-tests.factor b/basis/compiler/tree/propagation/info/info-tests.factor
index a9541c5618851bd36488eb3dbdd8a60b144d9da3..c770225640bcfce09ff7aaa1c69ffd37eadecadf 100644 (file)
--- a/basis/compiler/tree/propagation/info/info-tests.factor
+++ b/basis/compiler/tree/propagation/info/info-tests.factor
@@ -92,7 +92,7 @@ TUPLE: test-tuple { x read-only } ;
     null-info value-info-union >literal<
 ] unit-test
 
-{ } [ { } value-infos-union drop ] unit-test
+[ { } value-infos-union ] must-not-fail
 
 ! interval>literal
 { 10 t } [

diff --git a/basis/compiler/tree/propagation/propagation-tests.factor b/basis/compiler/tree/propagation/propagation-tests.factor
index b346b36736251f59bf9f9b44ae4005c2b52bf0bb..83dd33f5f97aeb56b7f418e2fd92c0a7ad4aeb46 100644 (file)
--- a/basis/compiler/tree/propagation/propagation-tests.factor
+++ b/basis/compiler/tree/propagation/propagation-tests.factor
@@ -618,7 +618,7 @@ TUPLE: immutable-prop-test-tuple { x sequence read-only } ;
     ] final-classes
 ] unit-test
 
-{ } [ [ dup 3 slot swap 4 slot dup 3 slot swap 4 slot ] final-info drop ] unit-test
+[ [ dup 3 slot swap 4 slot dup 3 slot swap 4 slot ] final-info ] must-not-fail
 
 { V{ number } } [ [ [ "Oops" throw ] [ 2 + ] if ] final-classes ] unit-test
 { V{ number } } [ [ [ 2 + ] [ "Oops" throw ] if ] final-classes ] unit-test
@@ -702,7 +702,7 @@ TUPLE: mixed-mutable-immutable { x integer } { y sequence read-only } ;
 : recursive-test-4 ( i n -- )
     2dup < [ [ 1 + ] dip recursive-test-4 ] [ 2drop ] if ; inline recursive
 
-{ } [ [ recursive-test-4 ] final-info drop ] unit-test
+[ [ recursive-test-4 ] final-info ] must-not-fail
 
 : recursive-test-5 ( a -- b )
     dup 1 <= [ drop 1 ] [ dup 1 - recursive-test-5 * ] if ; inline recursive
@@ -723,7 +723,7 @@ TUPLE: mixed-mutable-immutable { x integer } { y sequence read-only } ;
 
 { V{ integer } } [ [ 0 2 100 ^ [ nip ] each-integer ] final-classes ] unit-test
 
-{ } [ [ [ ] [ ] compose curry call ] final-info drop ] unit-test
+[ [ [ ] [ ] compose curry call ] final-info ] must-not-fail
 
 { V{ } } [
     [ [ drop ] [ drop ] compose curry each-integer-from ] final-classes
@@ -741,7 +741,7 @@ M: array iterate first t ; inline
 : hang-1 ( m -- x )
     dup 0 number= [ hang-1 ] unless ; inline recursive
 
-{ } [ [ 3 hang-1 ] final-info drop ] unit-test
+[ [ 3 hang-1 ] final-info ] must-not-fail
 
 : hang-2 ( m n -- x )
     over 0 number= [
@@ -754,7 +754,7 @@ M: array iterate first t ; inline
         ] if
     ] if ; inline recursive
 
-{ } [ [ 3 over hang-2 ] final-info drop ] unit-test
+[ [ 3 over hang-2 ] final-info ] must-not-fail
 
 { } [
     [
@@ -801,28 +801,28 @@ M: fixnum bad-generic 1 fixnum+fast ; inline
 GENERIC: infinite-loop ( a -- b )
 M: integer infinite-loop infinite-loop ;
 
-{ } [ [ { integer } declare infinite-loop ] final-classes drop ] unit-test
+[ [ { integer } declare infinite-loop ] final-classes ] must-not-fail
 
 { V{ tuple } } [ [ tuple-layout <tuple> ] final-classes ] unit-test
 
-{ } [ [ instance? ] final-classes drop ] unit-test
+[ [ instance? ] final-classes ] must-not-fail
 
 { f } [ [ V{ } clone ] final-info first literal?>> ] unit-test
 
 : fold-throw-test ( a -- b ) "A" throw ; foldable
 
-{ } [ [ 0 fold-throw-test ] final-info drop ] unit-test
+[ [ 0 fold-throw-test ] final-info ] must-not-fail
 
 : too-deep ( a b -- c )
     dup [ drop ] [ 2dup too-deep too-deep * ] if ; inline recursive
 
-{ } [ [ too-deep ] final-info drop ] unit-test
+[ [ too-deep ] final-info ] must-not-fail
 
-{ } [ [ reversed boa slice boa nth-unsafe * ] final-info drop ] unit-test
+[ [ reversed boa slice boa nth-unsafe * ] final-info ] must-not-fail
 
 MIXIN: empty-mixin
 
-{ } [ [ { empty-mixin } declare empty-mixin? ] final-info drop ] unit-test
+[ [ { empty-mixin } declare empty-mixin? ] final-info ] must-not-fail
 
 { V{ fixnum } } [ [ [ bignum-shift drop ] keep ] final-classes ] unit-test
 
@@ -939,7 +939,7 @@ TUPLE: littledan-1 { a read-only } ;
 
 : littledan-1-test ( -- ) 0 littledan-1 boa (littledan-1-test) ; inline
 
-{ } [ [ littledan-1-test ] final-classes drop ] unit-test
+[ [ littledan-1-test ] final-classes ] must-not-fail
 
 TUPLE: littledan-2 { from read-only } { to read-only } ;
 
@@ -949,7 +949,7 @@ TUPLE: littledan-2 { from read-only } { to read-only } ;
 : littledan-2-test ( x -- i elt )
     [ 0 ] dip { array-capacity } declare littledan-2 boa (littledan-2-test) ; inline
 
-{ } [ [ littledan-2-test ] final-classes drop ] unit-test
+[ [ littledan-2-test ] final-classes ] must-not-fail
 
 : (littledan-3-test) ( x -- )
     length 1 + f <array> (littledan-3-test) ; inline recursive
@@ -957,7 +957,7 @@ TUPLE: littledan-2 { from read-only } { to read-only } ;
 : littledan-3-test ( -- )
     0 f <array> (littledan-3-test) ; inline
 
-{ } [ [ littledan-3-test ] final-classes drop ] unit-test
+[ [ littledan-3-test ] final-classes ] must-not-fail
 
 { V{ 0 } } [ [ { } length ] final-literals ] unit-test
 
@@ -980,7 +980,7 @@ TUPLE: littledan-2 { from read-only } { to read-only } ;
 ! Mutable tuples with circularity should not cause problems
 TUPLE: circle me ;
 
-{ } [ circle new dup >>me 1quotation final-info drop ] unit-test
+[ circle new dup >>me 1quotation final-info ] must-not-fail
 
 ! Joe found an oversight
 { V{ integer } } [ [ >integer ] final-classes ] unit-test

diff --git a/basis/concurrency/locks/locks-tests.factor b/basis/concurrency/locks/locks-tests.factor
index f9acb5486cf2e6e2ef8d78db4da95af8eb96fc6d..887894a1a3e35823e4249fb6b2f73c2697b2ee8b 100644 (file)
--- a/basis/concurrency/locks/locks-tests.factor
+++ b/basis/concurrency/locks/locks-tests.factor
@@ -65,7 +65,7 @@ IN: concurrency.locks.tests
     ] with-lock
 ] unit-test
 
-{ } [ <rw-lock> drop ] unit-test
+[ <rw-lock> ] must-not-fail
 
 { } [ <rw-lock> [ ] with-read-lock ] unit-test
 

diff --git a/basis/math/complex/complex-tests.factor b/basis/math/complex/complex-tests.factor
index 9e43f9743b7dfaf87a29dc8ed7635f4b83eae70e..b16bf6ba67250f27cfee21dc15d48c751254fad0 100644 (file)
--- a/basis/math/complex/complex-tests.factor
+++ b/basis/math/complex/complex-tests.factor
@@ -67,10 +67,10 @@ prettyprint.config tools.test ;
 { t } [ -1 >polar nip 3.14 3.15 between? ] unit-test
 
 ! I broke something
-{ } [ C{ 1 4 } tanh drop ] unit-test
-{ } [ C{ 1 4 } tan drop ] unit-test
-{ } [ C{ 1 4 } coth drop ] unit-test
-{ } [ C{ 1 4 } cot drop ] unit-test
+[ C{ 1 4 } tanh ] must-not-fail
+[ C{ 1 4 } tan ] must-not-fail
+[ C{ 1 4 } coth ] must-not-fail
+[ C{ 1 4 } cot ] must-not-fail
 
 { t } [ 0.0 pi rect> e^ C{ -1 0 } 1.0e-7 ~ ] unit-test
 { t } [ 0 pi rect> e^ C{ -1 0 } 1.0e-7 ~ ] unit-test

diff --git a/basis/ui/tools/listener/listener-tests.factor b/basis/ui/tools/listener/listener-tests.factor
index ae060f0c63b6fb9e5b1c27db8cb6e129bec492d2..a22717eb5e745c3c3c4045bc6c8fade8499b9f9d 100644 (file)
--- a/basis/ui/tools/listener/listener-tests.factor
+++ b/basis/ui/tools/listener/listener-tests.factor
@@ -102,11 +102,11 @@ IN: ui.tools.listener.tests
 ] with-interactive-vocabs
 
 ! Hang
-{ } [ <interactor> <pane> <pane-stream> >>output "interactor" set ] unit-test
+[ <interactor> <pane> <pane-stream> >>output "interactor" set ] must-not-fail
 
-{ } [ [ "interactor" get stream-read-quot drop ] "A" spawn drop ] unit-test
+[ [ "interactor" get stream-read-quot drop ] "A" spawn ] must-not-fail
 
-{ } [ [ "interactor" get stream-read-quot drop ] "B" spawn drop ] unit-test
+[ [ "interactor" get stream-read-quot drop ] "B" spawn ] must-not-fail
 
 { } [ 1 seconds sleep ] unit-test
 

diff --git a/basis/unix/groups/groups-tests.factor b/basis/unix/groups/groups-tests.factor
index db6ccf81538feebdb1b7591fcdc844733f822fbf..2a8362803796f93fe9c347470ab79add3b8693fb 100644 (file)
--- a/basis/unix/groups/groups-tests.factor
+++ b/basis/unix/groups/groups-tests.factor
@@ -3,7 +3,7 @@
 USING: kernel math sequences strings tools.test unix.groups ;
 IN: unix.groups.tests
 
-{ } [ all-groups drop ] unit-test
+[ all-groups ] must-not-fail
 
 { t } [ real-group-name string? ] unit-test
 { t } [ effective-group-name string? ] unit-test
@@ -22,7 +22,7 @@ IN: unix.groups.tests
 
 { } [ [ ] with-group-cache ] unit-test
 
-{ } [ real-group-id group-name drop ] unit-test
+[ real-group-id group-name ] must-not-fail
 
 { "888888888888888" } [ 888888888888888 group-name ] unit-test
 { f } [ "please-oh-please-don't-have-a-group-named-this123lalala" group-struct ] unit-test

diff --git a/basis/unix/linux/proc/proc-tests.factor b/basis/unix/linux/proc/proc-tests.factor
index 5fd8e372cbc6f9d76e0e6640cdfa017c7cd09e96..7ddbab0fc55c82449ef9ec34e94afb4b72f7f4e8 100644 (file)
--- a/basis/unix/linux/proc/proc-tests.factor
+++ b/basis/unix/linux/proc/proc-tests.factor
@@ -3,11 +3,11 @@
 USING: kernel tools.test unix.linux.proc ;
 IN: unix.linux.proc.tests
 
-{ } [ parse-proc-cmdline drop ] unit-test
-{ } [ parse-proc-cpuinfo drop ] unit-test
-{ } [ parse-proc-loadavg drop ] unit-test
-{ } [ parse-proc-meminfo drop ] unit-test
-{ } [ parse-proc-partitions drop ] unit-test
-{ } [ parse-proc-stat drop ] unit-test
-{ } [ parse-proc-swaps drop ] unit-test
-{ } [ parse-proc-uptime drop ] unit-test
+[ parse-proc-cmdline ] must-not-fail
+[ parse-proc-cpuinfo ] must-not-fail
+[ parse-proc-loadavg ] must-not-fail
+[ parse-proc-meminfo ] must-not-fail
+[ parse-proc-partitions ] must-not-fail
+[ parse-proc-stat ] must-not-fail
+[ parse-proc-swaps ] must-not-fail
+[ parse-proc-uptime ] must-not-fail

diff --git a/basis/unix/utmpx/utmpx-tests.factor b/basis/unix/utmpx/utmpx-tests.factor
index d7f6c029219a00f7b236600906655b102fe0c54c..6eb894d02f299105278885a8d45d191f1a0a8c0c 100644 (file)
--- a/basis/unix/utmpx/utmpx-tests.factor
+++ b/basis/unix/utmpx/utmpx-tests.factor
@@ -3,4 +3,4 @@
 USING: kernel tools.test unix.utmpx ;
 IN: unix.utmpx.tests
 
-{ } [ all-utmpx drop ] unit-test
+[ all-utmpx ] must-not-fail

diff --git a/core/alien/alien-tests.factor b/core/alien/alien-tests.factor
index ac65b148b92f4106c7f80eb54d3cd65745010811..b9441fffb4896bc7f3ec5c8dee19e00ca1200d04 100644 (file)
--- a/core/alien/alien-tests.factor
+++ b/core/alien/alien-tests.factor
@@ -58,7 +58,7 @@ cell 8 = [
 
 { "ALIEN: 1234" } [ 0x1234 <alien> unparse ] unit-test
 
-{ } [ 0 B{ 1 2 3 } <displaced-alien> drop ] unit-test
+[ 0 B{ 1 2 3 } <displaced-alien> ] must-not-fail
 
 [ 0 B{ 1 2 3 } <displaced-alien> alien-address ] must-fail
 
@@ -80,7 +80,7 @@ f initialize-test set-global
 
 { 31337 } [ initialize-test [ 69 ] initialize-alien ] unit-test
 
-{ } [ initialize-test get BAD-ALIEN >>alien drop ] unit-test
+[ initialize-test get BAD-ALIEN >>alien ] must-not-fail
 
 { 7575 } [ initialize-test [ 7575 ] initialize-alien ] unit-test
 

diff --git a/core/classes/mixin/mixin-tests.factor b/core/classes/mixin/mixin-tests.factor
index ec7c7fb4ec8aa4e4b7fe9e870e78b23cc60f37f8..4431ab0efe678cbf15e858d32b6461078e6c4662 100644 (file)
--- a/core/classes/mixin/mixin-tests.factor
+++ b/core/classes/mixin/mixin-tests.factor
@@ -96,11 +96,11 @@ TUPLE: flat-mx-2-1 ; INSTANCE: flat-mx-2-1 flat-mx-2
 
 ! Too eager with reset-class
 
-{ } [ "IN: classes.mixin.tests MIXIN: blah SINGLETON: boo INSTANCE: boo blah" <string-reader> "mixin-reset-test" parse-stream drop ] unit-test
+[ "IN: classes.mixin.tests MIXIN: blah SINGLETON: boo INSTANCE: boo blah" <string-reader> "mixin-reset-test" parse-stream  ] must-not-fail
 
 { t } [ "blah" "classes.mixin.tests" lookup-word mixin-class? ] unit-test
 
-{ } [ "IN: classes.mixin.tests MIXIN: blah" <string-reader> "mixin-reset-test" parse-stream drop ] unit-test
+[ "IN: classes.mixin.tests MIXIN: blah" <string-reader> "mixin-reset-test" parse-stream  ] must-not-fail
 
 { t } [ "blah" "classes.mixin.tests" lookup-word mixin-class? ] unit-test
 
@@ -110,11 +110,11 @@ MIXIN: empty-mixin
 
 MIXIN: move-instance-declaration-mixin
 
-{ } [ "IN: classes.mixin.tests.a USE: strings USE: classes.mixin.tests INSTANCE: string move-instance-declaration-mixin" <string-reader> "move-mixin-test-1" parse-stream drop ] unit-test
+[ "IN: classes.mixin.tests.a USE: strings USE: classes.mixin.tests INSTANCE: string move-instance-declaration-mixin" <string-reader> "move-mixin-test-1" parse-stream ] must-not-fail
 
-{ } [ "IN: classes.mixin.tests.b USE: strings USE: classes.mixin.tests INSTANCE: string move-instance-declaration-mixin" <string-reader> "move-mixin-test-2" parse-stream drop ] unit-test
+[ "IN: classes.mixin.tests.b USE: strings USE: classes.mixin.tests INSTANCE: string move-instance-declaration-mixin" <string-reader> "move-mixin-test-2" parse-stream ] must-not-fail
 
-{ } [ "IN: classes.mixin.tests.a" <string-reader> "move-mixin-test-1" parse-stream drop ] unit-test
+[ "IN: classes.mixin.tests.a" <string-reader> "move-mixin-test-1" parse-stream  ] must-not-fail
 
 { { string } } [ move-instance-declaration-mixin class-members ] unit-test
 

diff --git a/core/classes/tuple/tuple-tests.factor b/core/classes/tuple/tuple-tests.factor
index d1e31d720ce3b8df5a70928e160315f1e5d5fdcd..44168556c621807803857fdb5126cd4d8a3dd58e 100644 (file)
--- a/core/classes/tuple/tuple-tests.factor
+++ b/core/classes/tuple/tuple-tests.factor
@@ -43,7 +43,7 @@ TUPLE: point x y ;
 { 200 } [ "p" get y>> ] unit-test
 { f } [ "p" get "z>>" "accessors" lookup-word execute ] unit-test
 
-{ } [ "p" get 300 ">>z" "accessors" lookup-word execute drop ] unit-test
+[ "p" get 300 ">>z" "accessors" lookup-word execute ] must-not-fail
 
 { 3 } [ "p" get tuple-size ] unit-test
 
@@ -320,8 +320,8 @@ TUPLE: make-me-some-accessors voltage grounded? ;
 { f } [ "laptop" get voltage>> ] unit-test
 { f } [ "server" get voltage>> ] unit-test
 
-{ } [ "laptop" get 220 >>voltage drop ] unit-test
-{ } [ "server" get 110 >>voltage drop ] unit-test
+[ "laptop" get 220 >>voltage ] must-not-fail
+[ "server" get 110 >>voltage ] must-not-fail
 
 { } [ "IN: classes.tuple.tests TUPLE: electronic-device voltage grounded? ; C: <computer> computer" eval( -- ) ] unit-test
 
@@ -628,7 +628,7 @@ TUPLE: bogus-hashcode-2 x ;
 
 M: bogus-hashcode-1 hashcode* 2drop 0 >bignum ;
 
-{ } [ T{ bogus-hashcode-2 f T{ bogus-hashcode-1 } } hashcode drop ] unit-test
+[ T{ bogus-hashcode-2 f T{ bogus-hashcode-1 } } hashcode ] must-not-fail
 
 DEFER: change-slot-test
 SLOT: kex

diff --git a/core/classes/union/union-tests.factor b/core/classes/union/union-tests.factor
index 1497c1521a7f4d1732f8a86ac50c9e06d1a63b74..76bb3e52702e017730127ab6f949e14e787ce9f0 100644 (file)
--- a/core/classes/union/union-tests.factor
+++ b/core/classes/union/union-tests.factor
@@ -65,13 +65,13 @@ UNION: redefine-bug-2 redefine-bug-1 quotation ;
 
 ! Too eager with reset-class
 
-{ } [ "IN: classes.union.tests SINGLETON: foo UNION: blah foo ;" <string-reader> "union-reset-test" parse-stream drop ] unit-test
+[ "IN: classes.union.tests SINGLETON: foo UNION: blah foo ;" <string-reader> "union-reset-test" parse-stream ] must-not-fail
 
 { t } [ "blah" "classes.union.tests" lookup-word union-class? ] unit-test
 
 { t } [ "foo?" "classes.union.tests" lookup-word predicate? ] unit-test
 
-{ } [ "IN: classes.union.tests USE: math UNION: blah integer ;" <string-reader> "union-reset-test" parse-stream drop ] unit-test
+[ "IN: classes.union.tests USE: math UNION: blah integer ;" <string-reader> "union-reset-test" parse-stream ] must-not-fail
 
 { t } [ "blah" "classes.union.tests" lookup-word union-class? ] unit-test
 

diff --git a/core/generic/standard/standard-tests.factor b/core/generic/standard/standard-tests.factor
index bc48c2f2bd4f0788e0fb712d10d17520816f823b..fcfd8c0a03ba5814a0c69bff57162443bf567e24 100644 (file)
--- a/core/generic/standard/standard-tests.factor
+++ b/core/generic/standard/standard-tests.factor
@@ -385,11 +385,11 @@ must-fail-with
 ! Moving a method from one vocab to another didn't always work
 GENERIC: move-method-generic ( a -- b )
 
-{ } [ "IN: generic.standard.tests.a USE: strings USE: generic.standard.tests M: string move-method-generic ;" <string-reader> "move-method-test-1" parse-stream drop ] unit-test
+[ "IN: generic.standard.tests.a USE: strings USE: generic.standard.tests M: string move-method-generic ;" <string-reader> "move-method-test-1" parse-stream ] must-not-fail
 
-{ } [ "IN: generic.standard.tests.b USE: strings USE: generic.standard.tests M: string move-method-generic ;" <string-reader> "move-method-test-2" parse-stream drop ] unit-test
+[ "IN: generic.standard.tests.b USE: strings USE: generic.standard.tests M: string move-method-generic ;" <string-reader> "move-method-test-2" parse-stream ] must-not-fail
 
-{ } [ "IN: generic.standard.tests.a" <string-reader> "move-method-test-1" parse-stream drop ] unit-test
+[ "IN: generic.standard.tests.a" <string-reader> "move-method-test-1" parse-stream ] must-not-fail
 
 { { string } } [ \ move-method-generic order ] unit-test
 
@@ -428,11 +428,11 @@ M: slice foozul ;
 
 { } [ reversed \ foozul method-for-class M\ reversed foozul assert= ] unit-test
 { } [ { 1 2 3 } <reversed> \ foozul method-for-object M\ reversed foozul assert= ] unit-test
-{ } [ { 1 2 3 } <reversed> \ foozul effective-method M\ reversed foozul assert= drop ] unit-test
+[ { 1 2 3 } <reversed> \ foozul effective-method M\ reversed foozul assert= ] must-not-fail
 
 { } [ fixnum \ foozul method-for-class M\ integer foozul assert= ] unit-test
 { } [ 13 \ foozul method-for-object M\ integer foozul assert= ] unit-test
-{ } [ 13 \ foozul effective-method M\ integer foozul assert= drop ] unit-test
+[ 13 \ foozul effective-method M\ integer foozul assert= ] must-not-fail
 
 ! Ensure dynamic and static dispatch match in ambiguous cases
 UNION: amb-union-1a integer float ;

diff --git a/core/io/backend/backend-tests.factor b/core/io/backend/backend-tests.factor
index 95b05ea9dadcef6a2796e96ea9982f55dd439a8d..21b944ffd80cf3d6d0e1d822ef26051a0f995fb5 100644 (file)
--- a/core/io/backend/backend-tests.factor
+++ b/core/io/backend/backend-tests.factor
@@ -1,3 +1,3 @@
 USING: tools.test io.backend kernel ;
 
-{ } [ "a" normalize-path drop ] unit-test
+[ "a" normalize-path ] must-not-fail

diff --git a/core/kernel/kernel-tests.factor b/core/kernel/kernel-tests.factor
index 7c51468c45ec582266fd0c28963e931b691fcd61..4384b0ab3987bb298d3d1ebf21634c4f14a29e95 100644 (file)
--- a/core/kernel/kernel-tests.factor
+++ b/core/kernel/kernel-tests.factor
@@ -68,7 +68,7 @@ IN: kernel.tests
     2 head ${ KERNEL-ERROR ERROR-DATASTACK-OVERFLOW } =
 ] must-fail-with
 
-{ } [ [ :c ] with-string-writer drop ] unit-test
+[ [ :c ] with-string-writer ] must-not-fail
 
 [ overflow-r ] [
     2 head ${ KERNEL-ERROR ERROR-RETAINSTACK-OVERFLOW } =

diff --git a/core/locals/locals-tests.factor b/core/locals/locals-tests.factor
index 3f9b6bf561c47794c6259c062031b8d23d4b0ab2..e6244fa57c920af328321980b551de1927b48dc8 100644 (file)
--- a/core/locals/locals-tests.factor
+++ b/core/locals/locals-tests.factor
@@ -95,7 +95,7 @@ write-test-2 "q" set
 
 :: write-test-4 ( x! -- q ) [ [let 0 :> y! f x! ] ] ;
 
-{ } [ 5 write-test-4 drop ] unit-test
+[ 5 write-test-4 ] must-not-fail
 
 :: let-let-test ( n -- n ) [let n 3 + :> n n ] ;
 

diff --git a/core/memory/memory-tests.factor b/core/memory/memory-tests.factor
index e05b68a8ff9416fc49eba39b2df34335152981ed..36bbd91171f6e0b9b3cab257037c9a6f32109969 100644 (file)
--- a/core/memory/memory-tests.factor
+++ b/core/memory/memory-tests.factor
@@ -42,7 +42,7 @@ IN: memory.tests
 
 ! Bug found on Windows build box, having too many words in the
 ! image breaks 'become'
-{ } [ 100000 [ f <uninterned-word> ] replicate { } { } become drop ] unit-test
+[ 100000 [ f <uninterned-word> ] replicate { } { } become ] must-not-fail
 
 ! Bug: code heap collection had to be done when data heap was
 ! full, not just when code heap was full. If the code heap

diff --git a/core/sorting/sorting-tests.factor b/core/sorting/sorting-tests.factor
index dd7b9b36a11765fcfd6d1d5df0e7d3dd843d42c2..b7daab03d3f1230f9a67751de5ce6954db55c957 100644 (file)
--- a/core/sorting/sorting-tests.factor
+++ b/core/sorting/sorting-tests.factor
@@ -16,7 +16,7 @@ unit-test
     ] all-integers?
 ] unit-test
 
-{ } [ { 1 2 } [ 2drop 1 ] sort drop ] unit-test
+[ { 1 2 } [ 2drop 1 ] sort ] must-not-fail
 
 ! Is it a stable sort?
 { t } [ { { 1 "a" } { 1 "b" } { 1 "c" } } dup sort-keys = ] unit-test
@@ -24,7 +24,7 @@ unit-test
 { { { 1 "a" } { 1 "b" } { 1 "c" } { 1 "e" } { 2 "d" } } }
 [ { { 1 "a" } { 1 "b" } { 1 "c" } { 2 "d" } { 1 "e" } } sort-keys ] unit-test
 
-{ } [ all-words natural-sort drop ] unit-test
+[ all-words natural-sort ] must-not-fail
 
 { +gt+ } [ "lady" "bug" { [ length ] [ first ] } compare-with ] unit-test
 { +lt+ } [ "bug" "lady" { [ length ] [ first ] } compare-with ] unit-test

diff --git a/extra/arrays/shaped/shaped-tests.factor b/extra/arrays/shaped/shaped-tests.factor
index f1c05a330c23c5bead8aa3ada18ddf92572c895f..4ba9c87f38605f818223c74da278000d44872a35 100644 (file)
--- a/extra/arrays/shaped/shaped-tests.factor
+++ b/extra/arrays/shaped/shaped-tests.factor
@@ -51,4 +51,4 @@ USING: accessors arrays.shaped kernel math sequences tools.test ;
 ] unit-test
 
 
-{ } [ 15 <iota> { 3 5 1 } reshape drop ] unit-test
+[ 15 <iota> { 3 5 1 } reshape ] must-not-fail

diff --git a/extra/gml/gml-tests.factor b/extra/gml/gml-tests.factor
index 2b0203b79df4c5316ada035208bc2c9aeee84d24..3eb37e4031b6cdf1b93538b00fe8a7338941f3f2 100644 (file)
--- a/extra/gml/gml-tests.factor
+++ b/extra/gml/gml-tests.factor
@@ -1,11 +1,11 @@
 USING: accessors combinators gml tools.test kernel sequences
 euler.b-rep ;
 
-{ } [ [ "vocab:gml/test-core.gml" run-gml-file ] make-gml 2drop ] unit-test
+[ [ "vocab:gml/test-core.gml" run-gml-file ] make-gml ] must-not-fail
 
-{ } [ [ "vocab:gml/test-coremath.gml" run-gml-file ] make-gml 2drop ] unit-test
+[ [ "vocab:gml/test-coremath.gml" run-gml-file ] make-gml ] must-not-fail
 
-{ } [ [ "vocab:gml/test-geometry.gml" run-gml-file ] make-gml 2drop ] unit-test
+[ [ "vocab:gml/test-geometry.gml" run-gml-file ] make-gml ] must-not-fail
 
 { } [
     [ "vocab:gml/examples/cube.gml" run-gml-file ] make-gml nip

diff --git a/extra/help/lint/coverage/coverage-tests.factor b/extra/help/lint/coverage/coverage-tests.factor
index f5fccea18226d2f16dfcaf7a4c8260f5fe8ac40e..202ea456db0bcf53bc25787833ffd1c1419a82fc 100644 (file)
--- a/extra/help/lint/coverage/coverage-tests.factor
+++ b/extra/help/lint/coverage/coverage-tests.factor
@@ -69,7 +69,7 @@ PRIVATE>
 ] unit-test
 
 ! make sure this doesn't throw an error (would signify an issue with ignored-words)
-{ } [ { $io-error $prettyprinting-note $nl } [ <word-help-coverage> ] map drop ] unit-test
+[ { $io-error $prettyprinting-note $nl } [ <word-help-coverage> ] map ] must-not-fail
 
 
 ! Lint system is written weirdly, there's no way to invoke it and get the output

diff --git a/extra/ping/ping-tests.factor b/extra/ping/ping-tests.factor
index cc83da90f1d3a358e728c57538ce3c084d9864b8..0807028b3fbe739ad0874564b91651b543e70d38 100644 (file)
--- a/extra/ping/ping-tests.factor
+++ b/extra/ping/ping-tests.factor
@@ -8,7 +8,7 @@ IN: ping.tests
     os-version { 5 1 } after? and not ;
 
 test-ping? [
-    [ ] [ "localhost" ping drop ] unit-test
+    [ "localhost" ping ] must-not-fail
     [ t ] [ "localhost" alive? ] unit-test
     [ t ] [ "127.0.0.1" alive? ] unit-test
     [ f ] [ "0.0.0.0" alive? ] unit-test

diff --git a/extra/smalltalk/parser/parser-tests.factor b/extra/smalltalk/parser/parser-tests.factor
index a7e5afde0d5cb3459edba834219d806d2b9919bc..ab5eb12be9086a4bfef0515d797f69b94894edb0 100644 (file)
--- a/extra/smalltalk/parser/parser-tests.factor
+++ b/extra/smalltalk/parser/parser-tests.factor
@@ -294,8 +294,8 @@ test         = <foreign parse-smalltalk LocalVariableDeclarationList>
 }
 [ "class Test1 [|a|]. class Test2 extends Test1 [|b|]" parse-smalltalk ] unit-test
 
-{ } [ "class Foo []. Tests blah " parse-smalltalk drop ] unit-test
+[ "class Foo []. Tests blah " parse-smalltalk ] must-not-fail
 
-{ } [ "vocab:smalltalk/parser/test.st" ascii file-contents parse-smalltalk drop ] unit-test
+[ "vocab:smalltalk/parser/test.st" ascii file-contents parse-smalltalk ] must-not-fail
 
-{ } [ "_abc_" parse-smalltalk drop ] unit-test
+[ "_abc_" parse-smalltalk ] must-not-fail

diff --git a/extra/unicode/flags/images/images-tests.factor b/extra/unicode/flags/images/images-tests.factor
index 567a2c2caa0ee2ae8fd6c0cc4d3979f0351cb4d4..b824508a0f4cb14f126a241191c212507683ec15 100644 (file)
--- a/extra/unicode/flags/images/images-tests.factor
+++ b/extra/unicode/flags/images/images-tests.factor
@@ -4,7 +4,7 @@ USING: assocs countries kernel sets system tools.test
 unicode.flags unicode.flags.images ;
 IN: unicode.flags.images.tests
 
-{ } [ valid-flag-biassoc drop ] unit-test
+[ valid-flag-biassoc ] must-not-fail
 
 ! Windows doesn't seem to have these flags yet (!)
 { { } } [