core: Trim using lists from -tests and clean up a few irregularities.

core/alien/alien-tests.factor

@@ -1,7 +1,6 @@
-USING: accessors alien alien.accessors alien.c-types alien.libraries
+USING: accessors alien alien.accessors alien.c-types
-alien.syntax arrays byte-arrays continuations fry kernel kernel.private
+alien.syntax byte-arrays continuations fry kernel layouts math
-layouts libc math namespaces prettyprint sequences system tools.memory
+namespaces prettyprint sequences tools.memory tools.test ;
-tools.test ;
 QUALIFIED: sets
 IN: alien.tests
 

core/arrays/arrays-tests.factor

@@ -1,6 +1,5 @@
 USING: accessors arrays kernel kernel.private layouts literals math
 sequences tools.test vectors ;
-IN: arrays.tests
 
 [ -2 { "a" "b" "c" } nth ] must-fail
 [ 10 { "a" "b" "c" } nth ] must-fail

core/assocs/assocs-tests.factor

@@ -1,6 +1,6 @@
-USING: kernel math namespaces make tools.test vectors sequences
+USING: alien.c-types assocs kernel make math namespaces
-sequences.private hashtables io prettyprint assocs
+sequences specialized-arrays tools.test ;
-continuations specialized-arrays alien.c-types ;
+IN: assocs.tests
 SPECIALIZED-ARRAY: double
 IN: assocs.tests
 

core/byte-arrays/byte-arrays-tests.factor

@@ -1,6 +1,5 @@
 USING: byte-arrays kernel math sequences sequences.private
 tools.test ;
-IN: byte-arrays.tests
 
 { 6 B{ 1 2 3 } } [
     6 B{ 1 2 3 } resize-byte-array

core/byte-vectors/byte-vectors-tests.factor

@@ -1,5 +1,5 @@
-USING: tools.test byte-vectors vectors sequences kernel
+USING: byte-vectors math prettyprint sequences tools.test
-prettyprint math ;
+vectors ;
 IN: byte-vectors.tests
 
 { 0 } [ 123 <byte-vector> length ] unit-test

core/checksums/crc32/crc32-tests.factor

@@ -1,4 +1,4 @@
-USING: checksums checksums.crc32 kernel math tools.test namespaces ;
+USING: checksums checksums.crc32 tools.test ;
 
 { B{ 0 0 0 0 } } [ "" crc32 checksum-bytes ] unit-test
 

core/classes/algebra/algebra-tests.factor

@@ -1,10 +1,7 @@
-USING: alien arrays definitions generic assocs hashtables io
+USING: accessors arrays assocs classes classes.algebra
-kernel math namespaces parser prettyprint sequences strings
+classes.tuple classes.union generic generic.private growable
-tools.test words quotations classes classes.algebra
+kernel math prettyprint quotations random sbufs sequences
-classes.private classes.union classes.mixin classes.predicate
+stack-checker strings tools.test vectors words ;
-vectors source-files compiler.units growable random
-stack-checker effects kernel.private sbufs math.order
-classes.tuple accessors generic.private ;
 IN: classes.algebra.tests
 
 TUPLE: first-one ;

core/classes/builtin/builtin-tests.factor

@@ -1,4 +1,4 @@
-USING: tools.test words sequences kernel memory accessors ;
+USING: accessors kernel memory sequences tools.test words ;
 IN: classes.builtin.tests
 
 { f } [

core/classes/classes-tests.factor

@@ -1,9 +1,6 @@
-USING: alien arrays generic assocs hashtables io
+USING: assocs classes classes.private compiler.units definitions
-io.streams.string kernel math namespaces parser prettyprint
+eval generic io.streams.string kernel math multiline namespaces
-sequences strings tools.test vectors words quotations classes
+parser sequences sets sorting tools.test vocabs words ;
-classes.private classes.union classes.mixin classes.predicate
-classes.algebra definitions source-files compiler.units
-kernel.private sorting vocabs memory eval accessors sets ;
 IN: classes.tests
 
 { t } [ 3 object instance? ] unit-test

core/classes/error/error-tests.factor

@@ -1,8 +1,7 @@
 ! Copyright (C) 2015 Doug Coleman.
 ! See http://factorcode.org/license.txt for BSD license.
 USING: accessors classes classes.error classes.tuple
-compiler.units effects eval generic io.streams.string kernel
+compiler.units effects eval generic kernel tools.test words ;
-math namespaces parser tools.test words words.symbol ;
 IN: classes.error.tests
 
 ! Test error classes

core/classes/intersection/intersection-tests.factor

@@ -1,5 +1,4 @@
-USING: kernel tools.test generic generic.standard classes math
+USING: accessors generic kernel math math.order slots tools.test ;
-accessors classes.intersection slots math.order ;
 IN: classes.intersection.tests
 
 TUPLE: a ;

core/classes/maybe/maybe-tests.factor

@@ -1,8 +1,7 @@
 ! Copyright (C) 2011 Doug Coleman.
 ! See http://factorcode.org/license.txt for BSD license.
-USING: classes.maybe eval generic.single kernel tools.test
+USING: accessors classes classes.algebra classes.algebra.private
-math classes accessors slots classes.algebra
+classes.maybe eval generic.single kernel math slots tools.test ;
-classes.algebra.private ;
 IN: classes.maybe.tests
 
 { t } [ 3 maybe{ integer } instance? ] unit-test

core/classes/mixin/mixin-tests.factor

@@ -1,8 +1,7 @@
-USING: alien arrays definitions generic assocs hashtables io kernel
+USING: arrays assocs classes classes.algebra classes.mixin
-math namespaces parser prettyprint sequences strings tools.test words
+compiler.units definitions eval hashtables io.streams.string
-quotations classes classes.private classes.union classes.mixin
+kernel math parser sequences source-files strings tools.test
-classes.predicate classes.algebra vectors source-files compiler.units
+vectors words ;
-kernel.private sorting vocabs eval ;
 IN: classes.mixin.tests
 
 ! Test mixins

core/classes/predicate/predicate-tests.factor

@@ -1,6 +1,5 @@
-USING: math tools.test classes.algebra words kernel sequences assocs
+USING: accessors assocs classes classes.algebra compiler.units
-accessors eval definitions compiler.units generic strings classes
+eval generic.single kernel math strings tools.test words ;
-generic.single ;
 IN: classes.predicate.tests
 
 PREDICATE: negative < integer 0 < ;

core/classes/singleton/singleton-tests.factor

@@ -1,4 +1,4 @@
-USING: kernel classes.singleton tools.test prettyprint io.streams.string see ;
+USING: classes.singleton io.streams.string kernel see tools.test ;
 IN: classes.singleton.tests
 
 { } [ SINGLETON: bzzt ] unit-test

core/classes/tuple/tuple-tests.factor

@@ -1,13 +1,11 @@
 USING: accessors arrays assocs calendar classes classes.algebra
 classes.private classes.tuple classes.tuple.private columns
-compiler.errors compiler.units continuations definitions
+combinators.short-circuit compiler.errors compiler.units
-effects eval generic generic.single generic.standard grouping
+definitions eval generic generic.single io.streams.string kernel
-io.streams.string kernel kernel.private math math.constants
+kernel.private literals math math.constants memory namespaces
-math.order namespaces parser parser.notes prettyprint
+parser parser.notes see sequences sequences.private slots
-quotations random see sequences sequences.private slots
+splitting strings threads tools.test vectors vocabs words
-slots.private splitting strings summary threads tools.test
+words.symbol ;
-vectors vocabs words words.symbol fry literals memory
-combinators.short-circuit ;
 IN: classes.tuple.tests
 
 TUPLE: rect x y w h ;

core/classes/union/union-tests.factor

@@ -1,10 +1,7 @@
-USING: accessors alien arrays definitions generic assocs
+USING: accessors alien assocs classes classes.algebra
-hashtables io kernel math namespaces parser prettyprint
+classes.predicate classes.union classes.union.private
-sequences strings tools.test vectors words quotations classes
+compiler.units eval io.streams.string kernel math math.private
-classes.private classes.union classes.mixin classes.predicate
+parser quotations see sequences slots strings tools.test words ;
-classes.algebra classes.union.private source-files
-compiler.units kernel.private sorting vocabs io.streams.string
-eval see math.private slots generic.single ;
 IN: classes.union.tests
 
 ! DEFER: bah

core/combinators/combinators-tests.factor

@@ -1,6 +1,6 @@
-USING: alien strings kernel math tools.test io prettyprint
+USING: accessors arrays combinators combinators.private io
-namespaces combinators words classes sequences accessors
+kernel math math.functions prettyprint sequences stack-checker
-math.functions arrays combinators.private stack-checker ;
+tools.test words ;
 IN: combinators.tests
 
 { 3 } [ 1 2 [ + ] call( x y -- z ) ] unit-test

core/compiler/units/units-tests.factor

@@ -1,5 +1,5 @@
-USING: compiler definitions compiler.units tools.test arrays sequences words kernel
+USING: arrays compiler compiler.units definitions eval fry
-accessors namespaces fry eval quotations math ;
+kernel math namespaces quotations sequences tools.test words ;
 IN: compiler.units.tests
 
 [ [ [ ] define-temp ] with-compilation-unit ] must-infer

core/continuations/continuations-tests.factor

@@ -1,6 +1,6 @@
-USING: accessors continuations debugger eval hashtables io
+USING: accessors continuations debugger eval io kernel
-kernel kernel.private math memory namespaces sequences
+kernel.private math memory namespaces sequences tools.test
-tools.test vectors words ;
+vectors words ;
 IN: continuations.tests
 
 : (callcc1-test) ( n obj -- n' obj )

core/definitions/definitions-tests.factor

@@ -1,5 +1,5 @@
-USING: tools.test generic kernel definitions sequences
+USING: arrays bit-arrays byte-arrays compiler.units definitions
-compiler.units words ;
+tools.test ;
 IN: definitions.tests
 
 GENERIC: some-generic ( a -- b )

core/destructors/destructors-tests.factor

@@ -1,5 +1,5 @@
-USING: destructors kernel tools.test continuations accessors
+USING: accessors continuations destructors destructors.private
-namespaces sequences destructors.private ;
+kernel namespaces sequences tools.test ;
 IN: destructors.tests
 
 TUPLE: dispose-error ;

core/effects/effects-tests.factor

@@ -1,5 +1,5 @@
-USING: effects effects.parser eval kernel tools.test prettyprint accessors
+USING: accessors effects effects.parser eval kernel prettyprint
-quotations sequences ;
+sequences tools.test ;
 IN: effects.tests
 
 { t } [ { "a" } { "a" } <effect> { "a" "b" } { "a" "b" } <effect> effect<= ] unit-test

core/generic/math/math-tests.factor

@@ -1,5 +1,4 @@
-USING: generic.math math tools.test kernel ;
+USING: generic.math kernel math tools.test ;
-IN: generic.math.tests
 
 ! Test math-combination
 { [ [ >float ] dip ] } [ \ real \ float math-upgrade ] unit-test

core/generic/parser/parser-tests.factor

@@ -1,7 +1,5 @@
 USING: generic.parser tools.test ;
 
-IN: generic.parser.tests
-
 { t } [ ( -- ) ( -- ) method-effect= ] unit-test
 { t } [ ( a -- b ) ( x -- y ) method-effect= ] unit-test
 { f } [ ( a b -- c ) ( x -- y ) method-effect= ] unit-test

core/growable/growable-tests.factor

@@ -1,5 +1,4 @@
-USING: math sequences classes growable tools.test kernel
+USING: classes kernel layouts math sequences tools.test ;
-layouts ;
 IN: growable.tests
 
 ! erg found this one

core/hash-sets/hash-sets-tests.factor

@@ -1,8 +1,7 @@
 ! Copyright (C) 2010 Daniel Ehrenberg
 ! See http://factorcode.org/license.txt for BSD license.
-USING: accessors fry hash-sets kernel math prettyprint
+USING: accessors fry hash-sets kernel math prettyprint sequences
-sequences sets sorting tools.test ;
+sets sorting tools.test ;
-IN: hash-sets.tests
 
 { { 1 2 3 } } [ HS{ 1 2 3 } members natural-sort ] unit-test
 

core/hashtables/hashtables-tests.factor

@@ -1,6 +1,5 @@
 USING: accessors assocs continuations fry hashtables kernel make
-math namespaces sequences slots.private tools.test ;
+math namespaces sequences tools.test ;
-IN: hashtables.tests
 
 { H{ } } [ { } [ dup ] H{ } map>assoc ] unit-test
 

core/io/encodings/ascii/ascii-tests.factor

@@ -1,5 +1,5 @@
-USING: io.encodings.string io.encodings.ascii tools.test strings arrays ;
+USING: arrays io.encodings.ascii io.encodings.string strings
-IN: io.encodings.ascii.tests
+tools.test ;
 
 { B{ CHAR: f CHAR: o CHAR: o } } [ "foo" ascii encode ] unit-test
 [ { 128 } >string ascii encode ] must-fail

core/io/encodings/utf16/utf16-tests.factor

@@ -1,9 +1,7 @@
 ! Copyright (C) 2008 Daniel Ehrenberg.
 ! See http://factorcode.org/license.txt for BSD license.
-USING: kernel tools.test io.encodings.utf16 arrays sbufs
+USING: arrays io.encodings.string io.encodings.utf16 strings
-io.streams.byte-array sequences io.encodings io strings
+tools.test ;
-io.encodings.string alien.c-types alien.strings accessors classes ;
-IN: io.encodings.utf16.tests
 
 { { CHAR: x } } [ B{ 0 CHAR: x } utf16be decode >array ] unit-test
 { { 0x1D11E } } [ B{ 0xD8 0x34 0xDD 0x1E } utf16be decode >array ] unit-test

core/io/encodings/utf16n/utf16n-tests.factor

@@ -1,6 +1,6 @@
-USING: accessors alien.c-types alien.data kernel
+USING: accessors alien.data io.encodings.utf16
-io.encodings.utf16 io.streams.byte-array tools.test ;
+io.streams.byte-array kernel tools.test ;
-IN: io.encodings.utf16n
+IN: io.encodings.utf16n.tests
 
 : correct-endian ( obj -- ? )
     code>> little-endian? [ utf16le = ] [ utf16be = ] if ;

core/io/encodings/utf8/utf8-tests.factor

@@ -1,5 +1,5 @@
-USING: io.encodings.utf8 tools.test io.encodings.string strings arrays
+USING: arrays io.encodings.string io.encodings.utf8 kernel
-bootstrap.unicode kernel sequences ;
+sequences strings tools.test ;
 IN: io.encodings.utf8.tests
 
 : decode-utf8-w/stream ( array -- newarray )

core/io/io-tests.factor

@@ -1,5 +1,5 @@
-USING: accessors io io.streams.string kernel math parser sbufs
+USING: accessors io io.streams.string kernel math namespaces
-sequences tools.test words namespaces strings ;
+parser sbufs sequences strings tools.test words ;
 IN: io.tests
 
 { f } [

core/io/streams/byte-array/byte-array-tests.factor

@@ -1,8 +1,8 @@
-USING: tools.test io.streams.byte-array io.encodings.binary
+USING: alien.c-types alien.data arrays io io.encodings.ascii
-io.encodings.utf8 io kernel arrays strings namespaces math
+io.encodings.binary io.encodings.utf8 io.streams.byte-array
-specialized-arrays alien.c-types alien.data io.encodings.ascii ;
+kernel math specialized-arrays strings tools.test ;
-SPECIALIZED-ARRAY: int
 IN: io.streams.byte-array.tests
+SPECIALIZED-ARRAY: int
 
 { B{ } } [ B{ } binary [ contents ] with-byte-reader ] unit-test
 

core/kernel/kernel-tests.factor

@@ -1,8 +1,7 @@
-USING: arrays byte-arrays kernel kernel.private literals math
+USING: accessors alien alien.accessors arrays assocs byte-arrays
-memory namespaces sequences tools.test math.private quotations
+continuations debugger grouping io.streams.string kernel
-continuations prettyprint io.streams.string debugger assocs
+kernel.private literals locals.backend math memory namespaces
-sequences.private accessors locals.backend grouping words
+prettyprint sequences sequences.private tools.test words ;
-system alien alien.accessors kernel.private ;
 IN: kernel.tests
 
 { 0 } [ f size ] unit-test

core/layouts/layouts-tests.factor

@@ -1,5 +1,4 @@
 USING: layouts math tools.test ;
-IN: system.tests
 
 { t } [ cell integer? ] unit-test
 { t } [ bootstrap-cell integer? ] unit-test

core/make/make-tests.factor

@@ -1,6 +1,4 @@
-
 USING: make sequences tools.test ;
-IN: make
 
 { "ABCD" } [ [ "ABCD" [ , ] each ] "" make ] unit-test
 

core/math/floats/floats-tests.factor

@@ -1,6 +1,5 @@
-USING: kernel math math.constants math.order tools.test sequences
+USING: grouping kernel math math.constants math.order sequences
-grouping ;
+tools.test ;
-IN: math.floats.tests
 
 { t } [ 0.0 float? ] unit-test
 { t } [ 3.1415 number? ] unit-test

core/math/integers/integers-tests.factor

@@ -1,6 +1,6 @@
-USING: kernel math math.functions math.order namespaces
+USING: continuations kernel math math.functions math.order
-prettyprint math.private continuations tools.test sequences
+math.private namespaces prettyprint prettyprint.config random
-random prettyprint.config ;
+sequences tools.test ;
 IN: math.integers.tests
 
 10 number-base [

core/math/math-tests.factor

@@ -1,4 +1,4 @@
-USING: kernel layouts math math.private namespaces make tools.test ;
+USING: kernel layouts make math math.private tools.test ;
 IN: math.tests
 
 { } [ 5 [ ] times ] unit-test

core/math/order/order-tests.factor

@@ -1,5 +1,4 @@
-USING: kernel math.order tools.test ;
+USING: math.order tools.test ;
-IN: math.order.tests
 
 { +lt+ } [ "ab" "abc" <=> ] unit-test
 { +gt+ } [ "abc" "ab" <=> ] unit-test

core/math/parser/parser-tests.factor

@@ -1,6 +1,4 @@
-USING: kernel layouts literals math math.parser sequences
+USING: layouts literals math math.parser sequences tools.test ;
-tools.test ;
-IN: math.parser.tests
 
 { f }
 [ f string>number ]

core/math/ratios/ratios-tests.factor

@@ -1,6 +1,4 @@
-USING: kernel math math.order math.parser math.ratios
+USING: kernel math math.functions math.parser tools.test ;
-math.functions tools.test ;
-IN: math.ratios.tests
 
 { 1 2 } [ 1/2 >fraction ] unit-test
 

core/memory/memory-tests.factor

@@ -1,6 +1,6 @@
-USING: accessors byte-arrays effects kernel kernel.private math memory
+USING: accessors arrays byte-arrays effects kernel
-prettyprint io sequences tools.test words namespaces layouts classes
+kernel.private math memory namespaces quotations sequences
-classes.builtin arrays quotations system ;
+tools.test words ;
 FROM: tools.memory => data-room code-room ;
 IN: memory.tests
 

core/namespaces/namespaces-tests.factor

@@ -1,5 +1,5 @@
 USING: assocs compiler.tree.debugger kernel namespaces
-tools.test words ;
+tools.test ;
 IN: namespaces.tests
 
 H{ } clone "test-namespace" set

core/parser/parser-tests.factor

@@ -1,10 +1,8 @@
-USING: arrays math parser tools.test kernel generic words
+USING: accessors arrays assocs classes compiler.units effects
-io.streams.string namespaces classes effects source-files assocs
+eval generic grouping io.pathnames io.streams.string kernel
-sequences strings io.files io.pathnames definitions
+lexer math multiline namespaces parser sequences sets
-continuations sorting classes.tuple compiler.units debugger
+source-files source-files.errors strings tools.crossref
-vocabs vocabs.loader accessors eval combinators lexer
+tools.test vocabs vocabs.parser words words.symbol ;
-vocabs.parser words.symbol multiline source-files.errors
-tools.crossref grouping sets ;
 IN: parser.tests
 
 { 1 [ 2 [ 3 ] 4 ] 5 }

core/quotations/quotations-tests.factor

@@ -1,5 +1,4 @@
-USING: math kernel quotations tools.test sequences ;
+USING: kernel math quotations sequences tools.test ;
-IN: quotations.tests
 
 { [ 3 ] } [ 3 [ ] curry ] unit-test
 { [ \ + ] } [ \ + [ ] curry ] unit-test

core/sbufs/sbufs-tests.factor

@@ -1,6 +1,5 @@
 USING: classes kernel math namespaces sbufs sequences
 sequences.private strings tools.test ;
-IN: sbufs.tests
 
 { 5 } [ "Hello" >sbuf length ] unit-test
 

core/sequences/sequences-tests.factor

@@ -1,7 +1,6 @@
-USING: arrays byte-arrays kernel math math.order math.parser
+USING: arrays assocs byte-arrays generic.single kernel make math
-namespaces sequences kernel.private sequences.private strings
+math.functions math.order math.parser math.vectors sbufs
-sbufs tools.test vectors assocs generic vocabs.loader
+sequences sequences.private strings tools.test vectors ;
-generic.single math.vectors math.functions ;
 IN: sequences.tests
 
 { "empty" } [ { } [ "empty" ] [ "not empty" ] if-empty ] unit-test
@@ -345,8 +344,6 @@ M: bogus-hashcode hashcode* 2drop 0 >bignum ;
     { 1 2 3 4 5 6 7 8 } [ H{ { 11 "hi" } } at ] map-find
 ] unit-test
 
-USE: make
-
 { { "a" 1 "b" 1 "c" } }
 [ 1 { "a" "b" "c" } [ [ dup , ] [ , ] interleave drop ] { } make ] unit-test
 

core/sets/sets-tests.factor

@@ -1,7 +1,7 @@
 ! Copyright (C) 2010 Daniel Ehrenberg, Doug Coleman.
 ! See http://factorcode.org/license.txt for BSD license.
-USING: sets tools.test kernel prettyprint hash-sets sorting
+USING: bit-arrays bit-sets kernel math sequences sets sorting
-math sequences bit-sets bit-arrays ;
+tools.test ;
 IN: sets.tests
 
 { V{ 1 2 3 } } [ 3 V{ 1 2 } clone [ adjoin ] keep ] unit-test

core/slots/slots-tests.factor

@@ -1,5 +1,5 @@
-USING: math accessors slots strings generic.single kernel
+USING: accessors arrays generic.single kernel math
-tools.test generic words parser eval math.functions arrays ;
+math.functions slots tools.test words ;
 IN: slots.tests
 
 TUPLE: r/w-test foo ;

core/sorting/sorting-tests.factor

@@ -1,6 +1,5 @@
-USING: sorting sequences kernel math math.order random
+USING: grouping kernel math math.order random sequences sets
-tools.test vectors sets vocabs grouping ;
+sorting tools.test vocabs ;
-IN: sorting.tests
 
 { { } } [ { } natural-sort ] unit-test
 

core/source-files/errors/errors-tests.factor

@@ -1,5 +1,5 @@
 USING: assocs compiler.errors compiler.units definitions
-namespaces source-files.errors tools.test words ;
+namespaces tools.test words ;
 IN: source-files.errors.tests
 
 DEFER: forget-test

core/source-files/source-files-tests.factor

@@ -1,5 +1,4 @@
-IN: source-files.tests
+USING: assocs namespaces sequences source-files strings
-USING: source-files tools.test assocs sequences strings
+tools.test ;
-namespaces kernel ;
 
 { { } } [ source-files get keys [ string? ] reject ] unit-test

core/splitting/splitting-tests.factor

@@ -1,5 +1,4 @@
-USING: splitting tools.test kernel sequences arrays strings ascii math ;
+USING: ascii kernel math sequences splitting strings tools.test ;
-IN: splitting.tests
 
 { "hello" "world ." } [ "hello world ." " " split1 ] unit-test
 { "hello" "world-+." } [ "hello-+world-+." "-+" split1 ] unit-test

core/strings/parser/parser-tests.factor

@@ -1,6 +1,4 @@
-USING: accessors eval strings.parser strings.parser.private
+USING: eval strings.parser tools.test ;
-tools.test ;
-IN: strings.parser.tests
 
 { "Hello\n\rworld" } [ "Hello\\n\\rworld" unescape-string ] unit-test
 

core/strings/strings-tests.factor

@@ -1,7 +1,7 @@
-USING: continuations kernel literals math math.order namespaces make
+USING: arrays continuations io.streams.null kernel
-strings strings.private sbufs tools.test sequences vectors
+kernel.private literals make math math.order memory namespaces
-arrays memory prettyprint io.streams.null kernel.private ;
+prettyprint sbufs sequences strings strings.private tools.test
-IN: strings.tests
+vectors ;
 
 { CHAR: b } [ 1 >bignum "abc" nth ] unit-test
 

core/system/system-tests.factor

@@ -1,5 +1,4 @@
 USING: arrays sequences system tools.test ;
-IN: system.tests
 
 { { t t t } } [
     vm-version vm-compiler vm-compile-time 3array

core/vectors/vectors-tests.factor

@@ -1,7 +1,5 @@
-USING: accessors arrays kernel kernel.private math namespaces
+USING: accessors arrays classes continuations kernel math
-sequences sequences.private strings tools.test vectors
+namespaces random sequences tools.test vectors ;
-continuations random growable classes ;
-IN: vectors.tests
 
 { } [ 10 [ [ -1000000 <vector> ] ignore-errors ] times ] unit-test
 

core/vocabs/loader/loader-tests.factor

@@ -1,8 +1,7 @@
-USING: vocabs.loader tools.test continuations vocabs math
+USING: accessors compiler.units continuations debugger
-kernel arrays sequences namespaces io.streams.string sets
+definitions eval io.streams.string kernel math namespaces parser
-parser source-files words assocs classes.tuple definitions
+prettyprint sequences sets source-files tools.test vocabs
-debugger compiler.units accessors eval vocabs.hierarchy
+vocabs.files vocabs.loader vocabs.parser vocabs.refresh words ;
-combinators vocabs.parser grouping vocabs.files vocabs.refresh ;
 IN: vocabs.loader.tests
 
 ! This vocab should not exist, but just in case...
@@ -46,7 +45,7 @@ IN: vocabs.loader.tests
 
     [ t ] [
         "resource:core/vocabs/loader/test/a/a.factor"
-        path>source-file definitions>> dup USE: prettyprint .
+        path>source-file definitions>>
         "v-l-t-a-hello" "vocabs.loader.test.a" lookup-word dup .
         swap first in?
     ] unit-test

core/vocabs/parser/parser-tests.factor

@@ -1,6 +1,6 @@
+USING: accessors compiler.units definitions eval kernel
+tools.test vocabs vocabs.parser words ;
 IN: vocabs.parser.tests
-USING: vocabs.parser tools.test eval kernel accessors definitions
-compiler.units words vocabs ;
 
 [ "FROM: kernel => doesnotexist ;" eval( -- ) ]
 [ error>> T{ no-word-in-vocab { word "doesnotexist" } { vocab "kernel" } } = ]

core/vocabs/vocabs-tests.factor

@@ -1,6 +1,4 @@
-! Unit tests for vocabs vocabulary
+USING: tools.test vocabs ;
-USING: vocabs tools.test ;
-IN: vocabs.tests
 
 { f } [ "kernel" vocab-main ] unit-test
 

core/words/alias/alias-tests.factor

@@ -1,4 +1,4 @@
-USING: math eval lexer tools.test effects sequences ;
+USING: effects eval math tools.test ;
 IN: words.alias.tests
 
 ALIAS: foo +

core/words/constant/constant-tests.factor

@@ -1,5 +1,5 @@
+USING: math tools.test words.constant ;
 IN: words.constant.tests
-USING: tools.test math words.constant ;
 
 CONSTANT: a +
 

core/words/words-tests.factor

@@ -1,7 +1,6 @@
-USING: arrays generic assocs kernel math namespaces
+USING: accessors arrays compiler.units definitions eval generic
-sequences tools.test words definitions parser quotations
+io.streams.string kernel math namespaces parser sequences
-vocabs continuations classes.tuple compiler.units
+tools.test vocabs words words.symbol ;
-io.streams.string accessors eval words.symbol grouping ;
 IN: words.tests
 
 { 4 } [