-IN: temporary
+IN: alien.tests
USING: alien alien.accessors byte-arrays arrays kernel
kernel.private namespaces tools.test sequences libc math system
prettyprint ;
-IN: temporary
+IN: alien.c-types.tests
USING: alien alien.syntax alien.c-types kernel tools.test
sequences system libc ;
-IN: temporary\r
+IN: alien.compiler.tests\r
USING: alien alien.c-types alien.syntax compiler kernel\r
namespaces namespaces tools.test sequences inference words\r
arrays parser quotations continuations inference.backend effects\r
-IN: temporary
+IN: alien.structs.tests
USING: alien alien.syntax alien.c-types kernel tools.test
sequences system libc words vocabs namespaces ;
USING: arrays kernel sequences sequences.private growable
tools.test vectors layouts system math vectors.private ;
-IN: temporary
+IN: arrays.tests
[ -2 { "a" "b" "c" } nth ] must-fail
[ 10 { "a" "b" "c" } nth ] must-fail
-IN: temporary
+IN: assocs.tests
USING: kernel math namespaces tools.test vectors sequences
sequences.private hashtables io prettyprint assocs
continuations ;
USING: sequences arrays bit-arrays kernel tools.test math
random ;
-IN: temporary
+IN: bit-arrays.tests
[ 100 ] [ 100 <bit-array> length ] unit-test
-IN: temporary\r
+IN: bit-vectors.tests\r
USING: tools.test bit-vectors vectors sequences kernel math ;\r
\r
[ 0 ] [ 123 <bit-vector> length ] unit-test\r
-IN: temporary
+IN: bootstrap.image.tests
USING: bootstrap.image bootstrap.image.private tools.test ;
\ ' must-infer
-IN: temporary\r
+IN: boxes.tests\r
USING: boxes namespaces tools.test ;\r
\r
[ ] [ <box> "b" set ] unit-test\r
-IN: temporary\r
+IN: byte-arrays.tests\r
USING: tools.test byte-arrays ;\r
\r
[ B{ 1 2 3 0 0 0 } ] [ 6 B{ 1 2 3 } resize-byte-array ] unit-test\r
-IN: temporary\r
+IN: byte-vectors.tests\r
USING: tools.test byte-vectors vectors sequences kernel ;\r
\r
[ 0 ] [ 123 <byte-vector> length ] unit-test\r
tools.test vectors words quotations classes io.streams.string
classes.private classes.union classes.mixin classes.predicate
vectors definitions source-files compiler.units ;
-IN: temporary
+IN: classes.tests
H{ } "s" set
[ bah ] [ \ bah? "predicating" word-prop ] unit-test
! Test generic see and parsing
-[ "USING: alien math ;\nIN: temporary\nUNION: bah fixnum alien ;\n" ]
+[ "USING: alien math ;\nIN: classes.tests\nUNION: bah fixnum alien ;\n" ]
[ [ \ bah see ] with-string-writer ] unit-test
! Test redefinition of classes
[ union-1 ] [ fixnum float class-or ] unit-test
-"IN: temporary USE: math USE: arrays UNION: union-1 rational array ;" eval
+"IN: classes.tests USE: math USE: arrays UNION: union-1 rational array ;" eval
[ t ] [ bignum union-1 class< ] unit-test
[ f ] [ union-1 number class< ] unit-test
[ object ] [ fixnum float class-or ] unit-test
-"IN: temporary USE: math PREDICATE: integer union-1 even? ;" eval
+"IN: classes.tests USE: math PREDICATE: integer union-1 even? ;" eval
[ f ] [ union-1 union-class? ] unit-test
[ t ] [ union-1 predicate-class? ] unit-test
[ t ] [ mx1 integer class< ] unit-test
[ t ] [ mx1 number class< ] unit-test
-"IN: temporary USE: arrays INSTANCE: array mx1" eval
+"IN: classes.tests USE: arrays INSTANCE: array mx1" eval
[ t ] [ array mx1 class< ] unit-test
[ f ] [ mx1 number class< ] unit-test
[ t ] [ quotation redefine-bug-2 class< ] unit-test
[ redefine-bug-2 ] [ fixnum quotation class-or ] unit-test
-[ ] [ "IN: temporary USE: math UNION: redefine-bug-1 bignum ;" eval ] unit-test
+[ ] [ "IN: classes.tests USE: math UNION: redefine-bug-1 bignum ;" eval ] unit-test
[ t ] [ bignum redefine-bug-1 class< ] unit-test
[ f ] [ fixnum redefine-bug-2 class< ] unit-test
[ ] [
{
"USING: sequences ;"
- "IN: temporary"
+ "IN: classes.tests"
"MIXIN: mixin-forget-test"
"INSTANCE: sequence mixin-forget-test"
"GENERIC: mixin-forget-test-g ( x -- y )"
[ ] [
{
"USING: hashtables ;"
- "IN: temporary"
+ "IN: classes.tests"
"MIXIN: mixin-forget-test"
"INSTANCE: hashtable mixin-forget-test"
"GENERIC: mixin-forget-test-g ( x -- y )"
-IN: temporary
+IN: combinators.tests
USING: alien strings kernel math tools.test io prettyprint
namespaces combinators words ;
USING: namespaces tools.test kernel command-line ;
-IN: temporary
+IN: command-line.tests
[
[ f ] [ "-no-user-init" cli-arg ] unit-test
USING: tools.test quotations math kernel sequences
assocs namespaces compiler.units ;
-IN: temporary
+IN: compiler.tests
[ 3 ] [ 5 [ [ 2 - ] curry call ] compile-call ] unit-test
[ 3 ] [ [ 5 [ 2 - ] curry call ] compile-call ] unit-test
-IN: temporary
+IN: compiler.tests
USING: compiler.units kernel kernel.private memory math
math.private tools.test math.floats.private ;
-IN: temporary
+IN: compiler.tests
USING: arrays compiler.units kernel kernel.private math
math.constants math.private sequences strings tools.test words
continuations sequences.private hashtables.private byte-arrays
USING: compiler.units tools.test kernel kernel.private
sequences.private math.private math combinators strings
alien arrays memory ;
-IN: temporary
+IN: compiler.tests
! Test empty word
[ ] [ [ ] compile-call ] unit-test
-IN: temporary
+IN: compiler.tests
USING: compiler tools.test namespaces sequences
kernel.private kernel math continuations continuations.private
words splitting sorting ;
! Testing templates machinery without compiling anything
-IN: temporary
+IN: compiler.tests
USING: compiler generator generator.registers
generator.registers.private tools.test namespaces sequences
words kernel math effects definitions compiler.units ;
sequences.private tools.test namespaces.private slots.private
sequences.private byte-arrays alien alien.accessors layouts
words definitions compiler.units io combinators ;
-IN: temporary
+IN: compiler.tests
! Oops!
[ 5000 ] [ [ 5000 ] compile-call ] unit-test
-IN: temporary
+IN: compiler.tests
USING: kernel tools.test compiler.units ;
TUPLE: color red green blue ;
USING: kernel math namespaces io tools.test sequences vectors
continuations debugger parser memory arrays words
kernel.private ;
-IN: temporary
+IN: continuations.tests
: (callcc1-test)
swap 1- tuck swap ?push
-IN: temporary
+IN: cpu.arm.assembler.tests
USING: assembler-arm math test namespaces sequences kernel
quotations ;
USING: cpu.x86.assembler kernel tools.test namespaces ;
-IN: temporary
+IN: cpu.x86.assembler.tests
[ { HEX: 49 HEX: 89 HEX: 04 HEX: 24 } ] [ [ R12 [] RAX MOV ] { } make ] unit-test
[ { HEX: 49 HEX: 8b HEX: 06 } ] [ [ RAX R14 [] MOV ] { } make ] unit-test
-IN: temporary\r
+IN: debugger.tests\r
USING: debugger kernel continuations tools.test ;\r
\r
[ ] [ [ drop ] [ error. ] recover ] unit-test\r
-IN: temporary
+IN: definitions.tests
USING: tools.test generic kernel definitions sequences
compiler.units ;
USING: dlists dlists.private kernel tools.test random assocs
hashtables sequences namespaces sorting debugger io prettyprint
math ;
-IN: temporary
+IN: dlists.tests
[ t ] [ <dlist> dlist-empty? ] unit-test
-IN: temporary
+IN: effects.tests
USING: effects tools.test ;
[ t ] [ 1 1 <effect> 2 2 <effect> effect<= ] unit-test
-IN: temporary
+IN: float-arrays.tests
USING: float-arrays tools.test ;
[ F{ 1.0 1.0 1.0 } ] [ 3 1.0 <float-array> ] unit-test
-IN: temporary\r
+IN: float-vectors.tests\r
USING: tools.test float-vectors vectors sequences kernel ;\r
\r
[ 0 ] [ 123 <float-vector> length ] unit-test\r
prettyprint sequences strings tools.test vectors words
quotations classes continuations layouts classes.union sorting
compiler.units ;
-IN: temporary
+IN: generic.tests
GENERIC: foobar ( x -- y )
M: object foobar drop "Hello world" ;
[ 2 ] [ 1.0 union-containment ] unit-test
! Testing recovery from bad method definitions
-"IN: temporary GENERIC: unhappy ( x -- x )" eval
+"IN: generic.tests GENERIC: unhappy ( x -- x )" eval
[
- "IN: temporary M: dictionary unhappy ;" eval
+ "IN: generic.tests M: dictionary unhappy ;" eval
] must-fail
-[ ] [ "IN: temporary GENERIC: unhappy ( x -- x )" eval ] unit-test
+[ ] [ "IN: generic.tests GENERIC: unhappy ( x -- x )" eval ] unit-test
GENERIC# complex-combination 1 ( a b -- c )
M: string complex-combination drop ;
TUPLE: redefinition-test-tuple ;
-"IN: temporary M: redefinition-test-tuple redefinition-test-generic ;" eval
+"IN: generic.tests M: redefinition-test-tuple redefinition-test-generic ;" eval
[ t ] [
[
redefinition-test-generic ,
- "IN: temporary TUPLE: redefinition-test-tuple ;" eval
+ "IN: generic.tests TUPLE: redefinition-test-tuple ;" eval
redefinition-test-generic ,
] { } make all-equal?
] unit-test
USING: math sequences classes growable tools.test kernel
layouts ;
-IN: temporary
+IN: growable.tests
! erg found this one
[ fixnum ] [
-IN: temporary
+IN: hashtables.tests
USING: kernel math namespaces tools.test vectors sequences
sequences.private hashtables io prettyprint assocs
continuations ;
USING: arrays kernel math namespaces tools.test
heaps heaps.private math.parser random assocs sequences sorting ;
-IN: temporary
+IN: heaps.tests
[ <min-heap> heap-pop ] must-fail
[ <max-heap> heap-pop ] must-fail
-IN: temporary
+IN: inference.class.tests
USING: arrays math.private kernel math compiler inference
inference.dataflow optimizer tools.test kernel.private generic
sequences words inference.class quotations alien
prettyprint io inspector tuples classes.union classes.predicate
debugger threads.private io.streams.string io.timeouts
io.thread sequences.private ;
-IN: temporary
+IN: inference.tests
{ 0 2 } [ 2 "Hello" ] must-infer-as
{ 1 2 } [ dup ] must-infer-as
-IN: temporary
+IN: inference.state.tests
USING: tools.test inference.state words ;
SYMBOL: a
-IN: temporary
+IN: inference.transforms.tests
USING: sequences inference.transforms tools.test math kernel
quotations inference ;
-IN: temporary
+IN: init.tests
USING: init namespaces sequences math tools.test kernel ;
[ t ] [
USING: kernel tools.test math namespaces prettyprint
sequences inspector io.streams.string ;
-IN: temporary
+IN: inspector.tests
[ 1 2 3 ] describe
f describe
-IN: temporary\r
+IN: io.backend.tests\r
USING: tools.test io.backend kernel ;\r
\r
[ ] [ "a" normalize-pathname drop ] unit-test\r
USING: io.binary tools.test ;
-IN: temporary
+IN: io.binary.tests
[ "\0\0\u000004\u0000d2" ] [ 1234 4 >be ] unit-test
[ "\u0000d2\u000004\0\0" ] [ 1234 4 >le ] unit-test
-IN: temporary
+IN: io.files.tests
USING: tools.test io.files io threads kernel continuations ;
[ "passwd" ] [ "/etc/passwd" file-name ] unit-test
USING: arrays io io.files kernel math parser strings system
tools.test words namespaces ;
-IN: temporary
+IN: io.tests
[ f ] [
"resource:/core/io/test/no-trailing-eol.factor" run-file
- "foo" "temporary" lookup
+ "foo" "io.tests" lookup
] unit-test
: <resource-reader> ( resource -- stream )
USING: tools.test io.files io io.streams.c ;
-IN: temporary
+IN: io.streams.c.tests
[ "hello world" ] [
"test.txt" temp-file [
USING: io.streams.duplex io kernel continuations tools.test ;
-IN: temporary
+IN: io.streams.duplex.tests
! Test duplex stream close behavior
TUPLE: closing-stream closed? ;
USING: io.streams.lines io.files io.streams.string io
tools.test kernel ;
-IN: temporary
+IN: io.streams.lines.tests
: <resource-reader> ( resource -- stream )
resource-path <file-reader> ;
USING: io io.streams.string io.streams.nested kernel math
namespaces io.styles tools.test ;
-IN: temporary
+IN: io.streams.nested.tests
USING: io.streams.string io kernel arrays namespaces tools.test ;
-IN: temporary
+IN: io.streams.string.tests
[ "line 1" CHAR: l ]
[
-IN: temporary
+IN: io.tests
USE: math
: foo 2 2 + ;
FORGET: foo
\ No newline at end of file
USING: arrays byte-arrays kernel kernel.private math memory
namespaces sequences tools.test math.private quotations
continuations prettyprint io.streams.string debugger assocs ;
-IN: temporary
+IN: kernel.tests
[ 0 ] [ f size ] unit-test
[ t ] [ [ \ = \ = ] all-equal? ] unit-test
USING: io io.streams.string io.streams.duplex listener
tools.test parser math namespaces continuations vocabs kernel
compiler.units ;
-IN: temporary
+IN: listener.tests
: hello "Hi" print ; parsing
] unit-test
[ ] [
- "IN: temporary : hello\n\"world\" ;" parse-interactive
+ "IN: listener.tests : hello\n\"world\" ;" parse-interactive
drop
] unit-test
USING: math math.bitfields tools.test kernel words ;
-IN: temporary
+IN: math.bitfields.tests
[ 0 ] [ { } bitfield ] unit-test
[ 256 ] [ 1 { 8 } bitfield ] unit-test
USING: kernel math math.constants tools.test sequences ;
-IN: temporary
+IN: math.floats.tests
[ t ] [ 0.0 float? ] unit-test
[ t ] [ 3.1415 number? ] unit-test
USING: kernel math namespaces prettyprint
math.private continuations tools.test sequences ;
-IN: temporary
+IN: math.integers.tests
[ "-8" ] [ -8 unparse ] unit-test
USING: math.intervals kernel sequences words math arrays
prettyprint tools.test random vocabs ;
-IN: temporary
+IN: math.intervals.tests
[ T{ interval f { 1 t } { 2 t } } ] [ 1 2 [a,b] ] unit-test
USING: kernel math namespaces tools.test ;
-IN: temporary
+IN: math.tests
[ ] [ 5 [ ] times ] unit-test
[ ] [ 0 [ ] times ] unit-test
USING: kernel math math.parser sequences tools.test ;
-IN: temporary
+IN: math.parser.tests
[ f ]
[ f string>number ]
USING: generic kernel kernel.private math memory prettyprint
sequences tools.test words namespaces layouts classes ;
-IN: temporary
+IN: memory.tests
TUPLE: testing x y z ;
USING: mirrors tools.test assocs kernel arrays ;
-IN: temporary
+IN: mirrors.tests
TUPLE: foo bar baz ;
-IN: temporary
+IN: namespaces.tests
USING: kernel namespaces tools.test words ;
H{ } clone "test-namespace" set
-IN: temporary
+IN: optimizer.control.tests
USING: tools.test optimizer.control combinators kernel
sequences inference.dataflow math inference classes strings
optimizer ;
-IN: temporary
+IN: optimizer.def-use.tests
USING: inference inference.dataflow optimizer optimizer.def-use
namespaces assocs kernel sequences math tools.test words ;
strings tools.test vectors words sequences.private quotations\r
optimizer.backend classes inference.dataflow tuples.private\r
continuations growable optimizer.inlining namespaces hints ;\r
-IN: temporary\r
+IN: optimizer.tests\r
\r
[ H{ { 1 5 } { 3 4 } { 2 5 } } ] [\r
H{ { 1 2 } { 3 4 } } H{ { 2 5 } } union*\r
io.streams.string namespaces classes effects source-files
assocs sequences strings io.files definitions continuations
sorting tuples compiler.units debugger ;
-IN: temporary
+IN: parser.tests
[
[ 1 [ 2 [ 3 ] 4 ] 5 ]
[ "hello world" ]
[
- "IN: temporary : hello \"hello world\" ;"
+ "IN: parser.tests : hello \"hello world\" ;"
eval "USE: temporary hello" eval
] unit-test
: effect-parsing-test ( a b -- c ) + ;
[ t ] [
- "effect-parsing-test" "temporary" lookup
+ "effect-parsing-test" "parser.tests" lookup
\ effect-parsing-test eq?
] unit-test
[ \ baz "declared-effect" word-prop effect-terminated? ]
unit-test
- [ ] [ "IN: temporary USE: math : effect-parsing-test ( a b -- d ) - ;" eval ] unit-test
+ [ ] [ "IN: parser.tests USE: math : effect-parsing-test ( a b -- d ) - ;" eval ] unit-test
[ t ] [
- "effect-parsing-test" "temporary" lookup
+ "effect-parsing-test" "parser.tests" lookup
\ effect-parsing-test eq?
] unit-test
[ T{ effect f { "a" "b" } { "d" } f } ]
[ \ effect-parsing-test "declared-effect" word-prop ] unit-test
- [ ] [ "IN: temporary : effect-parsing-test ;" eval ] unit-test
+ [ ] [ "IN: parser.tests : effect-parsing-test ;" eval ] unit-test
[ f ] [ \ effect-parsing-test "declared-effect" word-prop ] unit-test
! Funny bug
- [ 2 ] [ "IN: temporary : \0. 2 ; \0." eval ] unit-test
+ [ 2 ] [ "IN: parser.tests : \0. 2 ; \0." eval ] unit-test
- [ "IN: temporary : missing-- ( a b ) ;" eval ] must-fail
+ [ "IN: parser.tests : missing-- ( a b ) ;" eval ] must-fail
! These should throw errors
[ "HEX: zzz" eval ] must-fail
] unit-test
DEFER: foo
- "IN: temporary USING: math prettyprint ; : foo 2 2 + . ; parsing" eval
+ "IN: parser.tests USING: math prettyprint ; : foo 2 2 + . ; parsing" eval
[ ] [ "USE: temporary foo" eval ] unit-test
- "IN: temporary USING: math prettyprint ; : foo 2 2 + . ;" eval
+ "IN: parser.tests USING: math prettyprint ; : foo 2 2 + . ;" eval
[ t ] [
"USE: temporary \\ foo" eval
- "foo" "temporary" lookup eq?
+ "foo" "parser.tests" lookup eq?
] unit-test
! Test smudging
[ 1 ] [
- "IN: temporary : smudge-me ;" <string-reader> "foo"
+ "IN: parser.tests : smudge-me ;" <string-reader> "foo"
parse-stream drop
"foo" source-file source-file-definitions first assoc-size
] unit-test
- [ t ] [ "smudge-me" "temporary" lookup >boolean ] unit-test
+ [ t ] [ "smudge-me" "parser.tests" lookup >boolean ] unit-test
[ ] [
- "IN: temporary : smudge-me-more ;" <string-reader> "foo"
+ "IN: parser.tests : smudge-me-more ;" <string-reader> "foo"
parse-stream drop
] unit-test
- [ t ] [ "smudge-me-more" "temporary" lookup >boolean ] unit-test
- [ f ] [ "smudge-me" "temporary" lookup >boolean ] unit-test
+ [ t ] [ "smudge-me-more" "parser.tests" lookup >boolean ] unit-test
+ [ f ] [ "smudge-me" "parser.tests" lookup >boolean ] unit-test
[ 3 ] [
- "IN: temporary USING: math strings ; GENERIC: smudge-me M: integer smudge-me ; M: string smudge-me ;" <string-reader> "foo"
+ "IN: parser.tests USING: math strings ; GENERIC: smudge-me M: integer smudge-me ; M: string smudge-me ;" <string-reader> "foo"
parse-stream drop
"foo" source-file source-file-definitions first assoc-size
] unit-test
[ 1 ] [
- "IN: temporary USING: arrays ; M: array smudge-me ;" <string-reader> "bar"
+ "IN: parser.tests USING: arrays ; M: array smudge-me ;" <string-reader> "bar"
parse-stream drop
"bar" source-file source-file-definitions first assoc-size
] unit-test
[ 2 ] [
- "IN: temporary USING: math strings ; GENERIC: smudge-me M: integer smudge-me ;" <string-reader> "foo"
+ "IN: parser.tests USING: math strings ; GENERIC: smudge-me M: integer smudge-me ;" <string-reader> "foo"
parse-stream drop
"foo" source-file source-file-definitions first assoc-size
] unit-test
[ t ] [
- array "smudge-me" "temporary" lookup order memq?
+ array "smudge-me" "parser.tests" lookup order memq?
] unit-test
[ t ] [
- integer "smudge-me" "temporary" lookup order memq?
+ integer "smudge-me" "parser.tests" lookup order memq?
] unit-test
[ f ] [
- string "smudge-me" "temporary" lookup order memq?
+ string "smudge-me" "parser.tests" lookup order memq?
] unit-test
[ ] [
- "IN: temporary USE: math 2 2 +" <string-reader> "a"
+ "IN: parser.tests USE: math 2 2 +" <string-reader> "a"
parse-stream drop
] unit-test
] unit-test
[ ] [
- "IN: temporary USE: math 2 2 -" <string-reader> "a"
+ "IN: parser.tests USE: math 2 2 -" <string-reader> "a"
parse-stream drop
] unit-test
[ ] [
"a" source-files get delete-at
2 [
- "IN: temporary DEFER: x : y x ; : x y ;"
+ "IN: parser.tests DEFER: x : y x ; : x y ;"
<string-reader> "a" parse-stream drop
] times
] unit-test
"a" source-files get delete-at
[
- "IN: temporary : x ; : y 3 throw ; this is an error"
+ "IN: parser.tests : x ; : y 3 throw ; this is an error"
<string-reader> "a" parse-stream
] [ parse-error? ] must-fail-with
[ t ] [
- "y" "temporary" lookup >boolean
+ "y" "parser.tests" lookup >boolean
] unit-test
[ f ] [
- "IN: temporary : x ;"
+ "IN: parser.tests : x ;"
<string-reader> "a" parse-stream drop
- "y" "temporary" lookup
+ "y" "parser.tests" lookup
] unit-test
! Test new forward definition logic
] unit-test
[ ] [
- "IN: temporary : <bogus-error> ; : bogus <bogus-error> ;"
+ "IN: parser.tests : <bogus-error> ; : bogus <bogus-error> ;"
<string-reader> "bogus-error" parse-stream drop
] unit-test
[ ] [
- "IN: temporary TUPLE: bogus-error ; C: <bogus-error> bogus-error : bogus <bogus-error> ;"
+ "IN: parser.tests TUPLE: bogus-error ; C: <bogus-error> bogus-error : bogus <bogus-error> ;"
<string-reader> "bogus-error" parse-stream drop
] unit-test
! Problems with class predicates -vs- ordinary words
[ ] [
- "IN: temporary TUPLE: killer ;"
+ "IN: parser.tests TUPLE: killer ;"
<string-reader> "removing-the-predicate" parse-stream drop
] unit-test
[ ] [
- "IN: temporary GENERIC: killer? ( a -- b )"
+ "IN: parser.tests GENERIC: killer? ( a -- b )"
<string-reader> "removing-the-predicate" parse-stream drop
] unit-test
[ t ] [
- "killer?" "temporary" lookup >boolean
+ "killer?" "parser.tests" lookup >boolean
] unit-test
[
- "IN: temporary TUPLE: another-pred-test ; GENERIC: another-pred-test?"
+ "IN: parser.tests TUPLE: another-pred-test ; GENERIC: another-pred-test?"
<string-reader> "removing-the-predicate" parse-stream
] [ [ redefine-error? ] is? ] must-fail-with
[
- "IN: temporary TUPLE: class-redef-test ; TUPLE: class-redef-test ;"
+ "IN: parser.tests TUPLE: class-redef-test ; TUPLE: class-redef-test ;"
<string-reader> "redefining-a-class-1" parse-stream
] [ [ redefine-error? ] is? ] must-fail-with
[ ] [
- "IN: temporary TUPLE: class-redef-test ; SYMBOL: class-redef-test"
+ "IN: parser.tests TUPLE: class-redef-test ; SYMBOL: class-redef-test"
<string-reader> "redefining-a-class-2" parse-stream drop
] unit-test
[
- "IN: temporary TUPLE: class-redef-test ; SYMBOL: class-redef-test : class-redef-test ;"
+ "IN: parser.tests TUPLE: class-redef-test ; SYMBOL: class-redef-test : class-redef-test ;"
<string-reader> "redefining-a-class-3" parse-stream drop
] [ [ redefine-error? ] is? ] must-fail-with
[ ] [
- "IN: temporary TUPLE: class-fwd-test ;"
+ "IN: parser.tests TUPLE: class-fwd-test ;"
<string-reader> "redefining-a-class-3" parse-stream drop
] unit-test
[
- "IN: temporary \\ class-fwd-test"
+ "IN: parser.tests \\ class-fwd-test"
<string-reader> "redefining-a-class-3" parse-stream drop
] [ [ no-word? ] is? ] must-fail-with
[ ] [
- "IN: temporary TUPLE: class-fwd-test ; SYMBOL: class-fwd-test"
+ "IN: parser.tests TUPLE: class-fwd-test ; SYMBOL: class-fwd-test"
<string-reader> "redefining-a-class-3" parse-stream drop
] unit-test
[
- "IN: temporary \\ class-fwd-test"
+ "IN: parser.tests \\ class-fwd-test"
<string-reader> "redefining-a-class-3" parse-stream drop
] [ [ no-word? ] is? ] must-fail-with
[
- "IN: temporary : foo ; TUPLE: foo ;"
+ "IN: parser.tests : foo ; TUPLE: foo ;"
<string-reader> "redefining-a-class-4" parse-stream drop
] [ [ redefine-error? ] is? ] must-fail-with
[ ] [
- "IN: temporary : foo ( x y -- z ) 1 2 ; : bar ( a -- b ) ;" eval
+ "IN: parser.tests : foo ( x y -- z ) 1 2 ; : bar ( a -- b ) ;" eval
] unit-test
[
- "IN: temporary : foo ( x y -- z) 1 2 ; : bar ( a -- b ) ;" eval
+ "IN: parser.tests : foo ( x y -- z) 1 2 ; : bar ( a -- b ) ;" eval
] must-fail
] with-file-vocabs
DEFER: ~b
- "IN: temporary : ~b ~a ;" <string-reader>
+ "IN: parser.tests : ~b ~a ;" <string-reader>
"smudgy" parse-stream drop
: ~c ;
] with-scope
[ ] [
- "IN: temporary USE: kernel PREDICATE: object foo ( x -- y ) ;" eval
+ "IN: parser.tests USE: kernel PREDICATE: object foo ( x -- y ) ;" eval
] unit-test
[ t ] [
- "foo?" "temporary" lookup word eq?
+ "foo?" "parser.tests" lookup word eq?
] unit-test
[ ] [
- "IN: temporary TUPLE: foo ; GENERIC: foo"
+ "IN: parser.tests TUPLE: foo ; GENERIC: foo"
<string-reader> "redefining-a-class-5" parse-stream drop
] unit-test
[ ] [
- "IN: temporary M: f foo ;"
+ "IN: parser.tests M: f foo ;"
<string-reader> "redefining-a-class-6" parse-stream drop
] unit-test
-[ f ] [ f "foo" "temporary" lookup execute ] unit-test
+[ f ] [ f "foo" "parser.tests" lookup execute ] unit-test
[ ] [
- "IN: temporary TUPLE: foo ; GENERIC: foo"
+ "IN: parser.tests TUPLE: foo ; GENERIC: foo"
<string-reader> "redefining-a-class-5" parse-stream drop
] unit-test
-[ f ] [ f "foo" "temporary" lookup execute ] unit-test
+[ f ] [ f "foo" "parser.tests" lookup execute ] unit-test
[ ] [
- "IN: temporary TUPLE: foo ; GENERIC: foo"
+ "IN: parser.tests TUPLE: foo ; GENERIC: foo"
<string-reader> "redefining-a-class-7" parse-stream drop
] unit-test
[ ] [
- "IN: temporary TUPLE: foo ;"
+ "IN: parser.tests TUPLE: foo ;"
<string-reader> "redefining-a-class-7" parse-stream drop
] unit-test
-[ t ] [ "foo" "temporary" lookup symbol? ] unit-test
+[ t ] [ "foo" "parser.tests" lookup symbol? ] unit-test
[ "resource:core/parser/test/assert-depth.factor" run-file ]
[ relative-overflow-stack { 1 2 3 } sequence= ]
prettyprint.sections sequences tools.test vectors words
effects splitting generic.standard prettyprint.private
continuations generic compiler.units tools.walker ;
-IN: temporary
+IN: prettyprint.tests
[ "4" ] [ 4 unparse ] unit-test
[ "1.0" ] [ 1.0 unparse ] unit-test
: foo ( a -- b ) dup * ; inline
-[ "USING: kernel math ;\nIN: temporary\n: foo ( a -- b ) dup * ; inline\n" ]
+[ "USING: kernel math ;\nIN: prettyprint.tests\n: foo ( a -- b ) dup * ; inline\n" ]
[ [ \ foo see ] with-string-writer ] unit-test
: bar ( x -- y ) 2 + ;
-[ "USING: math ;\nIN: temporary\n: bar ( x -- y ) 2 + ;\n" ]
+[ "USING: math ;\nIN: prettyprint.tests\n: bar ( x -- y ) 2 + ;\n" ]
[ [ \ bar see ] with-string-writer ] unit-test
: blah
[
[ parse-fresh drop ] with-compilation-unit
[
- "temporary" lookup see
+ "prettyprint.tests" lookup see
] with-string-writer "\n" split 1 head*
] keep =
] with-scope ;
: method-test
{
- "IN: temporary"
+ "IN: prettyprint.tests"
"GENERIC: method-layout"
""
"USING: math temporary ;"
: retain-stack-test
{
"USING: io kernel sequences words ;"
- "IN: temporary"
+ "IN: prettyprint.tests"
": retain-stack-layout ( x -- )"
" dup stream-readln stream-readln"
" >r [ define ] map r>"
: soft-break-test
{
"USING: kernel math sequences strings ;"
- "IN: temporary"
+ "IN: prettyprint.tests"
": soft-break-layout ( x y -- ? )"
" over string? ["
" over hashcode over hashcode number="
: another-retain-layout-test
{
"USING: kernel sequences ;"
- "IN: temporary"
+ "IN: prettyprint.tests"
": another-retain-layout ( seq1 seq2 quot -- newseq )"
" -rot 2dup dupd min-length [ each drop roll ] map"
" >r 3drop r> ; inline"
: another-soft-break-test
{
"USING: namespaces parser sequences ;"
- "IN: temporary"
+ "IN: prettyprint.tests"
": another-soft-break-layout ( node -- quot )"
" parse-error-file"
" [ <reversed> \"hello world foo\" add ] [ ] make ;"
: string-layout
{
"USING: io kernel parser ;"
- "IN: temporary"
+ "IN: prettyprint.tests"
": string-layout-test ( error -- )"
" \"Expected \" write dup unexpected-want expected>string write"
" \" but got \" write unexpected-got expected>string print ;"
: final-soft-break-test
{
"USING: kernel sequences ;"
- "IN: temporary"
+ "IN: prettyprint.tests"
": final-soft-break-layout ( class dim -- view )"
" >r \"alloc\" send 0 0 r>"
" first2 <NSRect>"
: narrow-test
{
"USING: arrays combinators continuations kernel sequences ;"
- "IN: temporary"
+ "IN: prettyprint.tests"
": narrow-layout ( obj -- )"
" {"
" { [ dup continuation? ] [ append ] }"
: another-narrow-test
{
- "IN: temporary"
+ "IN: prettyprint.tests"
": another-narrow-layout ( -- obj )"
" H{"
" { 1 2 }"
: class-see-test
{
- "IN: temporary"
+ "IN: prettyprint.tests"
"TUPLE: class-see-layout ;"
""
- "IN: temporary"
+ "IN: prettyprint.tests"
"GENERIC: class-see-layout ( x -- y )"
""
"USING: temporary ;"
! Regression
[ t ] [
- "IN: temporary\nGENERIC: generic-decl-test ( a -- b ) flushable\n"
+ "IN: prettyprint.tests\nGENERIC: generic-decl-test ( a -- b ) flushable\n"
dup eval
- "generic-decl-test" "temporary" lookup
+ "generic-decl-test" "prettyprint.tests" lookup
[ see ] with-string-writer =
] unit-test
USING: math kernel quotations tools.test sequences ;
-IN: temporary
+IN: quotations.tests
[ [ 3 ] ] [ 3 [ ] curry ] unit-test
[ [ \ + ] ] [ \ + [ ] curry ] unit-test
USING: kernel math namespaces sequences sbufs strings
tools.test classes ;
-IN: temporary
+IN: sbufs.tests
[ 5 ] [ "Hello" >sbuf length ] unit-test
USING: arrays kernel math namespaces sequences kernel.private
sequences.private strings sbufs tools.test vectors bit-arrays
generic ;
-IN: temporary
+IN: sequences.tests
[ V{ 1 2 3 4 } ] [ 1 5 dup <slice> >vector ] unit-test
[ 3 ] [ 1 4 dup <slice> length ] unit-test
USING: sorting sequences kernel math random tools.test
vectors ;
-IN: temporary
+IN: sorting.tests
[ [ ] ] [ [ ] natural-sort ] unit-test
USING: splitting tools.test ;
-IN: temporary
+IN: splitting.tests
[ { 1 2 3 } 0 group ] must-fail
USING: continuations kernel math namespaces strings sbufs
tools.test sequences vectors arrays ;
-IN: temporary
+IN: strings.tests
[ CHAR: b ] [ 1 >bignum "abc" nth ] unit-test
USING: math tools.test system prettyprint ;
-IN: temporary
+IN: system.tests
[ t ] [ cell integer? ] unit-test
[ t ] [ bootstrap-cell integer? ] unit-test
USING: namespaces io tools.test threads kernel ;
-IN: temporary
+IN: threads.tests
3 "x" set
namespace [ [ yield 2 "x" set ] bind ] curry "Test" spawn drop
namespaces quotations sequences.private classes continuations
generic.standard effects tuples tuples.private arrays vectors
strings compiler.units ;
-IN: temporary
+IN: tuples.tests
[ t ] [ \ tuple-class \ class class< ] unit-test
[ f ] [ \ class \ tuple-class class< ] unit-test
100 200 <point> "p" set
! Use eval to sequence parsing explicitly
-"IN: temporary TUPLE: point x y z ;" eval
+"IN: tuples.tests TUPLE: point x y z ;" eval
[ 100 ] [ "p" get point-x ] unit-test
[ 200 ] [ "p" get point-y ] unit-test
-[ f ] [ "p" get "point-z" "temporary" lookup execute ] unit-test
+[ f ] [ "p" get "point-z" "tuples.tests" lookup execute ] unit-test
-300 "p" get "set-point-z" "temporary" lookup execute
+300 "p" get "set-point-z" "tuples.tests" lookup execute
-"IN: temporary TUPLE: point z y ;" eval
+"IN: tuples.tests TUPLE: point z y ;" eval
[ "p" get point-x ] must-fail
[ 200 ] [ "p" get point-y ] unit-test
-[ 300 ] [ "p" get "point-z" "temporary" lookup execute ] unit-test
+[ 300 ] [ "p" get "point-z" "tuples.tests" lookup execute ] unit-test
TUPLE: predicate-test ;
TUPLE: yo-momma ;
-"IN: temporary C: <yo-momma> yo-momma" eval
+"IN: tuples.tests C: <yo-momma> yo-momma" eval
[ f ] [ \ <yo-momma> generic? ] unit-test
SYMBOL: not-a-tuple-class
[
- "IN: temporary C: <not-a-tuple-class> not-a-tuple-class"
+ "IN: tuples.tests C: <not-a-tuple-class> not-a-tuple-class"
eval
] must-fail
[ t ] [
- "not-a-tuple-class" "temporary" lookup symbol?
+ "not-a-tuple-class" "tuples.tests" lookup symbol?
] unit-test
! Missing check
{ set-erg's-reshape-problem-a }
\ erg's-reshape-problem construct ;
-"IN: temporary TUPLE: erg's-reshape-problem a b c d e f ;" eval
+"IN: tuples.tests TUPLE: erg's-reshape-problem a b c d e f ;" eval
[ ] [ 1 2 3 4 5 6 cons-test-2 "a" set ] unit-test
[ t ] [ 1 cons-test-3 array-capacity "a" get array-capacity = ] unit-test
[
- "IN: temporary SYMBOL: not-a-class C: <not-a-class> not-a-class" eval
+ "IN: tuples.tests SYMBOL: not-a-class C: <not-a-class> not-a-class" eval
] [ [ check-tuple? ] is? ] must-fail-with
! Hardcore unit tests
USING: arrays kernel kernel.private math namespaces
sequences sequences.private strings tools.test vectors
continuations random growable classes ;
-IN: temporary
+IN: vectors.tests
[ ] [ 10 [ [ -1000000 <vector> ] ignore-errors ] times ] unit-test
! Unit tests for vocabs.loader vocabulary
-IN: temporary
+IN: vocabs.loader.tests
USING: vocabs.loader tools.test continuations vocabs math
kernel arrays sequences namespaces io.streams.string
parser source-files words assocs tuples definitions
MAIN: hello
-IN: temporary
+IN: vocabs.loader.tests
[ { 3 3 3 } ] [
"vocabs.loader.test.2" run
! Unit tests for vocabs vocabulary
USING: vocabs tools.test ;
-IN: temporary
+IN: vocabs.tests
[ f ] [ "kernel" vocab-main ] unit-test
USING: arrays generic assocs kernel math namespaces
sequences tools.test words definitions parser quotations
vocabs continuations tuples compiler.units io.streams.string ;
-IN: temporary
+IN: words.tests
[ 4 ] [
[
- "poo" "temporary" create [ 2 2 + ] define
+ "poo" "words.tests" create [ 2 2 + ] define
] with-compilation-unit
- "poo" "temporary" lookup execute
+ "poo" "words.tests" lookup execute
] unit-test
[ t ] [ t vocabs [ words [ word? and ] each ] each ] unit-test
! See if redefining a generic as a colon def clears some
! word props.
GENERIC: testing
-"IN: temporary : testing ;" eval
+"IN: words.tests : testing ;" eval
[ f ] [ \ testing generic? ] unit-test
DEFER: x
[ x ] [ undefined? ] must-fail-with
-[ ] [ "no-loc" "temporary" create drop ] unit-test
-[ f ] [ "no-loc" "temporary" lookup where ] unit-test
+[ ] [ "no-loc" "words.tests" create drop ] unit-test
+[ f ] [ "no-loc" "words.tests" lookup where ] unit-test
-[ ] [ "IN: temporary : no-loc-2 ;" eval ] unit-test
-[ f ] [ "no-loc-2" "temporary" lookup where ] unit-test
+[ ] [ "IN: words.tests : no-loc-2 ;" eval ] unit-test
+[ f ] [ "no-loc-2" "words.tests" lookup where ] unit-test
-[ ] [ "IN: temporary : test-last ( -- ) ;" eval ] unit-test
+[ ] [ "IN: words.tests : test-last ( -- ) ;" eval ] unit-test
[ "test-last" ] [ word word-name ] unit-test
! regression
[ { + } ] [ \ quot-uses-b uses ] unit-test
-[ "IN: temporary : undef-test ; << undef-test >>" eval ]
+[ "IN: words.tests : undef-test ; << undef-test >>" eval ]
[ [ undefined? ] is? ] must-fail-with
[ ] [
- "IN: temporary GENERIC: symbol-generic" eval
+ "IN: words.tests GENERIC: symbol-generic" eval
] unit-test
[ ] [
- "IN: temporary SYMBOL: symbol-generic" eval
+ "IN: words.tests SYMBOL: symbol-generic" eval
] unit-test
-[ t ] [ "symbol-generic" "temporary" lookup symbol? ] unit-test
-[ f ] [ "symbol-generic" "temporary" lookup generic? ] unit-test
+[ t ] [ "symbol-generic" "words.tests" lookup symbol? ] unit-test
+[ f ] [ "symbol-generic" "words.tests" lookup generic? ] unit-test
[ ] [
- "IN: temporary GENERIC: symbol-generic" <string-reader>
+ "IN: words.tests GENERIC: symbol-generic" <string-reader>
"symbol-generic-test" parse-stream drop
] unit-test
[ ] [
- "IN: temporary TUPLE: symbol-generic ;" <string-reader>
+ "IN: words.tests TUPLE: symbol-generic ;" <string-reader>
"symbol-generic-test" parse-stream drop
] unit-test
-[ t ] [ "symbol-generic" "temporary" lookup symbol? ] unit-test
-[ f ] [ "symbol-generic" "temporary" lookup generic? ] unit-test
+[ t ] [ "symbol-generic" "words.tests" lookup symbol? ] unit-test
+[ f ] [ "symbol-generic" "words.tests" lookup generic? ] unit-test
! Regressions
-[ ] [ "IN: temporary : decl-forget-test ; foldable" eval ] unit-test
-[ t ] [ "decl-forget-test" "temporary" lookup "foldable" word-prop ] unit-test
-[ ] [ "IN: temporary : decl-forget-test ;" eval ] unit-test
-[ f ] [ "decl-forget-test" "temporary" lookup "foldable" word-prop ] unit-test
-
-[ ] [ "IN: temporary : decl-forget-test ; flushable" eval ] unit-test
-[ t ] [ "decl-forget-test" "temporary" lookup "flushable" word-prop ] unit-test
-[ ] [ "IN: temporary : decl-forget-test ;" eval ] unit-test
-[ f ] [ "decl-forget-test" "temporary" lookup "flushable" word-prop ] unit-test
+[ ] [ "IN: words.tests : decl-forget-test ; foldable" eval ] unit-test
+[ t ] [ "decl-forget-test" "words.tests" lookup "foldable" word-prop ] unit-test
+[ ] [ "IN: words.tests : decl-forget-test ;" eval ] unit-test
+[ f ] [ "decl-forget-test" "words.tests" lookup "foldable" word-prop ] unit-test
+
+[ ] [ "IN: words.tests : decl-forget-test ; flushable" eval ] unit-test
+[ t ] [ "decl-forget-test" "words.tests" lookup "flushable" word-prop ] unit-test
+[ ] [ "IN: words.tests : decl-forget-test ;" eval ] unit-test
+[ f ] [ "decl-forget-test" "words.tests" lookup "flushable" word-prop ] unit-test
-IN: temporary
+IN: ascii.tests
USING: ascii tools.test sequences kernel math ;
[ t ] [ CHAR: a letter? ] unit-test
-IN: temporary\r
+IN: benchmark.reverse-complement.tests\r
USING: tools.test benchmark.reverse-complement crypto.md5\r
io.files kernel ;\r
\r
-IN: temporary\r
+IN: calendar.format.tests\r
USING: calendar.format tools.test io.streams.string ;\r
\r
[ 0 ] [\r
!
USING: kernel tools.test math channels channels.private
sequences threads sorting ;
-IN: temporary
+IN: channels.tests
{ V{ 10 } } [
V{ } clone <channel>
!
USING: kernel tools.test math assocs channels channels.remote
channels.remote.private ;
-IN: temporary
+IN: channels.remote.tests
{ t } [
remote-channels assoc?
-IN: temporary
+IN: cocoa.tests
USING: cocoa cocoa.messages cocoa.subclassing cocoa.types
compiler kernel namespaces cocoa.classes tools.test memory
compiler.units ;
USING: combinators.lib kernel math random sequences tools.test continuations
arrays vectors ;
-IN: temporary
+IN: combinators.lib.tests
[ 5 ] [ [ 10 random ] [ 5 = ] generate ] unit-test
[ t ] [ [ 10 random ] [ even? ] generate even? ] unit-test
-IN: temporary\r
+IN: concurrency.combinators.tests\r
USING: concurrency.combinators tools.test random kernel math \r
concurrency.mailboxes threads sequences ;\r
\r
USING: concurrency.count-downs threads kernel tools.test ;\r
-IN: temporary`\r
+IN: concurrency.count-downs.tests`\r
\r
[ ] [ 0 <count-down> await ] unit-test\r
\r
-IN: temporary\r
+IN: concurrency.exchangers.tests\r
USING: sequences tools.test concurrency.exchangers\r
concurrency.count-downs concurrency.promises locals kernel\r
threads ;\r
-IN: temporary\r
+IN: concurrency.flags.tests\r
USING: tools.test concurrency.flags kernel threads locals ;\r
\r
:: flag-test-1 ( -- )\r
-IN: temporary\r
+IN: concurrency.futures.tests\r
USING: concurrency.futures kernel tools.test threads ;\r
\r
[ 50 ] [\r
-IN: temporary\r
+IN: concurrency.locks.tests\r
USING: tools.test concurrency.locks concurrency.count-downs\r
concurrency.messaging concurrency.mailboxes locals kernel\r
threads sequences calendar ;\r
-IN: temporary\r
+IN: concurrency.mailboxes.tests\r
USING: concurrency.mailboxes vectors sequences threads\r
tools.test math kernel strings ;\r
\r
USING: kernel threads vectors arrays sequences
namespaces tools.test continuations dlists strings math words
match quotations concurrency.messaging concurrency.mailboxes ;
-IN: temporary
+IN: concurrency.messaging.tests
[ ] [ my-mailbox mailbox-data dlist-delete-all ] unit-test
-IN: temporary\r
+IN: concurrency.promises.tests\r
USING: vectors concurrency.promises kernel threads sequences\r
tools.test ;\r
\r
! Copyright (C) 2005 Chris Double, 2007 Clemens Hofreither.
! See http://factorcode.org/license.txt for BSD license.
-IN: temporary
+IN: coroutines.tests
USING: coroutines kernel sequences prettyprint tools.test math ;
: test1 ( -- co )
USING: kernel io strings sequences namespaces math parser crypto.hmac tools.test ;
-IN: temporary
+IN: crypto.hmac.tests
[ "\u000092\u000094rz68\u0000bb\u00001c\u000013\u0000f4\u00008e\u0000f8\u000015\u00008b\u0000fc\u00009d" ] [ 16 11 <string> "Hi There" string>md5-hmac >string ] unit-test
[ "u\u00000cx>j\u0000b0\u0000b5\u000003\u0000ea\u0000a8n1\n]\u0000b78" ] [ "Jefe" "what do ya want for nothing?" string>md5-hmac >string ] unit-test
USING: crypto.timing kernel tools.test system math ;
-IN: temporary
+IN: crypto.timing.tests
[ t ] [ millis [ ] 1000 with-timing millis swap - 1000 >= ] unit-test
USING: continuations crypto.xor kernel strings tools.test ;
-IN: temporary
+IN: crypto.xor.tests
! No key
[ "" dup xor-crypt ] [ T{ no-xor-key f } = ] must-fail-with
USING: kernel db.postgresql alien continuations io classes
prettyprint sequences namespaces tools.test db
db.tuples db.types unicode.case ;
-IN: temporary
+IN: db.postgresql.tests
-IN: scratchpad
: test-db ( -- postgresql-db )
{ "localhost" "postgres" "" "factor-test" } postgresql-db ;
-IN: temporary
[ ] [ test-db [ ] with-db ] unit-test
USING: io io.files io.launcher kernel namespaces
prettyprint tools.test db.sqlite db sequences
continuations db.types db.tuples unicode.case ;
-IN: temporary
+IN: db.sqlite.tests
: test.db "extra/db/sqlite/test.db" resource-path ;
USING: io.files kernel tools.test db db.tuples
db.types continuations namespaces db.postgresql math
prettyprint tools.walker db.sqlite ;
-IN: temporary
+IN: db.tuples.tests
TUPLE: person the-id the-name the-number the-real ;
: <person> ( name age real -- person )
USING: delegate kernel arrays tools.test ;
-IN: temporary
+IN: delegate.tests
TUPLE: hello this that ;
C: <hello> hello
USING: destructors kernel tools.test continuations ;
-IN: temporary
+IN: destructors.tests
TUPLE: dummy-obj destroyed? ;
-IN: temporary
+IN: documents.tests
USING: documents namespaces tools.test ;
! Tests
USING: farkup kernel tools.test ;
-IN: temporary
+IN: farkup.tests
[ "<ul><li>foo</li></ul>" ] [ "-foo" parse-farkup ] unit-test
[ "<ul><li>foo</li></ul>\n" ] [ "-foo\n" parse-farkup ] unit-test
! Copyright (C) 2006 Chris Double. All Rights Reserved.
! See http://factorcode.org/license.txt for BSD license.
USING: kernel tools.test peg fjsc ;
-IN: temporary
+IN: fjsc.tests
{ T{ ast-expression f V{ T{ ast-number f 55 } T{ ast-identifier f "2abc1" } T{ ast-number f 100 } } } } [
"55 2abc1 100" 'expression' parse parse-result-ast
-IN: temporary\r
+IN: fry.tests\r
USING: fry tools.test math prettyprint kernel io arrays\r
sequences ;\r
\r
USING: kernel sequences namespaces math tools.test furnace furnace.validator ;
-IN: temporary
+IN: furnace.tests
TUPLE: test-tuple m n ;
-IN: temporary
+IN: furnace.validator.tests
USING: kernel sequences tools.test furnace.validator furnace ;
[
-IN: temporary
+IN: globs.tests
USING: tools.test globs ;
[ f ] [ "abd" "fdf" glob-matches? ] unit-test
-IN: temporary
+IN: help.crossref.tests
USING: help.crossref help.topics help.markup tools.test words
definitions assocs sequences kernel namespaces parser arrays
io.streams.string continuations debugger compiler.units ;
[ ] [
- "IN: temporary USING: help.syntax help.markup ; : foo ; HELP: foo \"foo is great\" ; ARTICLE: \"foo\" \"Foo\" { $subsection foo } ;" eval
+ "IN: help.crossref.tests USING: help.syntax help.markup ; : foo ; HELP: foo \"foo is great\" ; ARTICLE: \"foo\" \"Foo\" { $subsection foo } ;" eval
] unit-test
[ $subsection ] [
[ t ] [
"foo" article-children
- "foo" "temporary" lookup 1array sequence=
+ "foo" "help.crossref.tests" lookup 1array sequence=
] unit-test
-[ "foo" ] [ "foo" "temporary" lookup article-parent ] unit-test
+[ "foo" ] [ "foo" "help.crossref.tests" lookup article-parent ] unit-test
[ ] [
- [ "foo" "temporary" lookup forget ] with-compilation-unit
+ [ "foo" "help.crossref.tests" lookup forget ] with-compilation-unit
] unit-test
[ ] [
- "IN: temporary USING: help.syntax help.markup ; : bar ; HELP: bar \"bar is great\" ; ARTICLE: \"bar\" \"Bar\" { $subsection bar } ;" eval
+ "IN: help.crossref.tests USING: help.syntax help.markup ; : bar ; HELP: bar \"bar is great\" ; ARTICLE: \"bar\" \"Bar\" { $subsection bar } ;" eval
] unit-test
[ ] [
USING: math definitions help.topics help tools.test
prettyprint parser io.streams.string kernel source-files
assocs namespaces words io sequences ;
-IN: temporary
+IN: help.definitions.tests
[ ] [ \ + >link see ] unit-test
[
[ 4 ] [
- "IN: temporary USING: help.syntax ; : hello ; HELP: hello \"test\" ; ARTICLE: \"hello\" \"world\" ; ARTICLE: \"hello2\" \"world\" ;" <string-reader> "foo"
+ "IN: help.definitions.tests USING: help.syntax ; : hello ; HELP: hello \"test\" ; ARTICLE: \"hello\" \"world\" ; ARTICLE: \"hello2\" \"world\" ;" <string-reader> "foo"
parse-stream drop
"foo" source-file source-file-definitions first assoc-size
[ t ] [ "hello" articles get key? ] unit-test
[ t ] [ "hello2" articles get key? ] unit-test
[ t ] [
- "hello" "temporary" lookup "help" word-prop >boolean
+ "hello" "help.definitions" lookup "help" word-prop >boolean
] unit-test
[ 2 ] [
- "IN: temporary USING: help.syntax ; : hello ; ARTICLE: \"hello\" \"world\" ;" <string-reader> "foo"
+ "IN: help.definitions.tests USING: help.syntax ; : hello ; ARTICLE: \"hello\" \"world\" ;" <string-reader> "foo"
parse-stream drop
"foo" source-file source-file-definitions first assoc-size
[ t ] [ "hello" articles get key? ] unit-test
[ f ] [ "hello2" articles get key? ] unit-test
[ f ] [
- "hello" "temporary" lookup "help" word-prop
+ "hello" "help.definitions" lookup "help" word-prop
] unit-test
- [ ] [ "IN: temporary USING: help.syntax ; : xxx ; HELP: xxx ;" eval ] unit-test
+ [ ] [ "IN: help.definitions.tests USING: help.syntax ; : xxx ; HELP: xxx ;" eval ] unit-test
- [ ] [ "xxx" "temporary" lookup help ] unit-test
+ [ ] [ "xxx" "help.definitions" lookup help ] unit-test
- [ ] [ "xxx" "temporary" lookup >link synopsis print ] unit-test
+ [ ] [ "xxx" "help.definitions" lookup >link synopsis print ] unit-test
] with-file-vocabs
USING: definitions help help.markup kernel sequences tools.test
words parser namespaces assocs generic io.streams.string ;
-IN: temporary
+IN: help.markup.tests
TUPLE: blahblah quux ;
-IN: temporary
+IN: help.syntax.tests
USING: tools.test parser vocabs help.syntax namespaces ;
[
[ "foobar" ] [
- "IN: temporary USE: help.syntax ABOUT: \"foobar\"" eval
- "temporary" vocab vocab-help
+ "IN: help.syntax.tests USE: help.syntax ABOUT: \"foobar\"" eval
+ "help.syntax" vocab vocab-help
] unit-test
[ { "foobar" } ] [
- "IN: temporary USE: help.syntax ABOUT: { \"foobar\" }" eval
- "temporary" vocab vocab-help
+ "IN: help.syntax.tests USE: help.syntax ABOUT: { \"foobar\" }" eval
+ "help.syntax" vocab vocab-help
] unit-test
SYMBOL: xyz
[ xyz ] [
- "IN: temporary USE: help.syntax ABOUT: xyz" eval
- "temporary" vocab vocab-help
+ "IN: help.syntax.tests USE: help.syntax ABOUT: xyz" eval
+ "help.syntax" vocab vocab-help
] unit-test
] with-file-vocabs
USING: definitions help help.topics help.crossref help.markup
help.syntax kernel sequences tools.test words parser namespaces
assocs source-files ;
-IN: temporary
+IN: help.topics.tests
! Test help cross-referencing
-IN: temporary
+IN: hexdump.tests
USING: hexdump kernel sequences tools.test ;
[ t ] [ "" hexdump "Length: 0, 0h\n" = ] unit-test
-IN: temporary
+IN: html.elements.tests
USING: tools.test html html.elements io.streams.string ;
: make-html-string
USING: html http io io.streams.string io.styles kernel
namespaces tools.test xml.writer sbufs sequences html.private ;
-IN: temporary
+IN: html.tests
: make-html-string
[ with-html-stream ] with-string-writer ;
USING: html.parser kernel tools.test ;
-IN: temporary
+IN: html.parser.tests
[
V{ T{ tag f "html" H{ } f f f } }
namespaces prettyprint quotations sequences splitting
state-parser strings tools.test ;
USING: html.parser.utils ;
-IN: temporary
+IN: html.parser.utils.tests
[ "'Rome'" ] [ "Rome" single-quote ] unit-test
[ "\"Roma\"" ] [ "Roma" double-quote ] unit-test
USING: http tools.test ;
-IN: temporary
+IN: http.tests
[ "hello%20world" ] [ "hello world" url-encode ] unit-test
[ "hello world" ] [ "hello%20world" url-decode ] unit-test
USING: webapps.file http.server.responders http
http.server namespaces io tools.test strings io.server
logging ;
-IN: temporary
+IN: http.server.tests
[ ] [ f [ "404 not found" httpd-error ] with-logging ] unit-test
USING: io io.files io.streams.string http.server.templating kernel tools.test
sequences ;
-IN: temporary
+IN: http.server.templating.tests
: test-template ( path -- ? )
"extra/http/server/templating/test/" swap append
-IN: temporary
+IN: io.buffers.tests
USING: alien alien.c-types io.buffers kernel kernel.private libc
sequences tools.test namespaces ;
-IN: temporary
+IN: io.launcher.tests
USING: tools.test io.launcher ;
\ <process-stream> must-infer
USING: io io.mmap io.files kernel tools.test continuations sequences ;
-IN: temporary
+IN: io.mmap.tests
[ "mmap-test-file.txt" resource-path delete-file ] ignore-errors
[ ] [ "mmap-test-file.txt" resource-path [ "12345" write ] with-file-writer ] unit-test
-IN: temporary
+IN: io.server.tests
USING: tools.test io.server io.server.private ;
{ 1 0 } [ [ ] server-loop ] must-infer-as
USING: io.sockets.impl io.sockets kernel tools.test ;
-IN: temporary
+IN: io.sockets.impl.tests
[ B{ 1 2 3 4 } ]
[ "1.2.3.4" T{ inet4 } inet-pton ] unit-test
USING: tools.test io.files ;
-IN: temporary
+IN: io.unix.files.tests
[ "/usr/libexec/" ] [ "/usr/libexec/awk/" parent-directory ] unit-test
[ "/etc/" ] [ "/etc/passwd" parent-directory ] unit-test
-IN: temporary
+IN: io.unix.launcher.tests
USING: io.unix.launcher tools.test ;
[ "" tokenize-command ] must-fail
USING: io.files io.sockets io kernel threads
namespaces tools.test continuations strings byte-arrays
sequences prettyprint system ;
-IN: temporary
+IN: io.unix.tests
! Unix domain stream sockets
: socket-server "unix-domain-socket-test" temp-file ;
USING: io.files kernel tools.test io.backend
io.windows.nt.files splitting ;
-IN: temporary
+IN: io.windows.nt.tests
[ "c:\\foo\\" ] [ "c:\\foo\\bar" parent-directory ] unit-test
[ "c:\\" ] [ "c:\\foo\\" parent-directory ] unit-test
USING: jamshred.oint jamshred.tunnel kernel sequences tools.test ;
-IN: temporary
+IN: jamshred.tunnel.tests
[ 0 ] [ T{ segment T{ oint f { 0 0 0 } } 0 }
T{ segment T{ oint f { 1 1 1 } } 1 }
USING: koszul tools.test kernel sequences assocs namespaces ;
-IN: temporary
+IN: koszul.tests
[
{ V{ { } } V{ { 1 } } V{ { 2 3 } { 7 8 } } V{ { 4 5 6 } } }
USING: lazy-lists.examples lazy-lists tools.test ;
-IN: temporary
+IN: lazy-lists.examples.tests
[ { 1 3 5 7 } ] [ 4 odds ltake list>array ] unit-test
[ { 0 1 4 9 16 } ] [ first-five-squares ] unit-test
! See http://factorcode.org/license.txt for BSD license.
!
USING: lazy-lists tools.test kernel math io sequences ;
-IN: temporary
+IN: lazy-lists.tests
[ { 1 2 3 4 } ] [
{ 1 2 3 4 } >list list>array
! Copyright (C) 2006 Slava Pestov.
! See http://factorcode.org/license.txt for BSD license.
-IN: temporary
+IN: levenshtein.tests
USING: tools.test levenshtein ;
[ 3 ] [ "sitting" "kitten" levenshtein ] unit-test
USING: io lint kernel math tools.test ;
-IN: temporary
+IN: lint.tests
! Don't write code like this
: lint1
USING: locals math sequences tools.test hashtables words kernel
namespaces arrays strings prettyprint ;
-IN: temporary
+IN: locals.tests
:: foo ( a b -- a a ) a a ;
-IN: temporary
+IN: macros.tests
USING: tools.test macros math kernel arrays
vectors ;
! Copyright (C) 2006 Chris Double.
! See http://factorcode.org/license.txt for BSD license.
USING: tools.test match namespaces arrays ;
-IN: temporary
+IN: match.tests
MATCH-VARS: ?a ?b ;
USING: kernel math math.functions tools.test math.analysis
math.constants ;
-IN: temporary
+IN: math.analysis.tests
: eps
.00000001 ;
USING: math.combinatorics math.combinatorics.private tools.test ;
-IN: temporary
+IN: math.combinatorics.tests
[ { } ] [ 0 factoradic ] unit-test
[ { 1 0 } ] [ 1 factoradic ] unit-test
USING: kernel math math.constants math.functions tools.test
prettyprint ;
-IN: temporary
+IN: math.complex.tests
[ 1 C{ 0 1 } rect> ] must-fail
[ C{ 0 1 } 1 rect> ] must-fail
! Copyright (c) 2007 Samuel Tardieu.
! See http://factorcode.org/license.txt for BSD license.
USING: lazy-lists math.erato tools.test ;
-IN: temporary
+IN: math.erato.tests
[ { 2 3 5 7 11 13 17 19 } ] [ 20 lerato list>array ] unit-test
USING: kernel math math.constants math.functions math.private
math.libm tools.test ;
-IN: temporary
+IN: math.functions.tests
[ t ] [ 4 4 .00000001 ~ ] unit-test
[ t ] [ 4.0000001 4.0000001 .000001 ~ ] unit-test
-IN: temporary
+IN: math.matrices.elimination.tests
USING: kernel math.matrices math.matrices.elimination
tools.test sequences ;
-IN: temporary
+IN: math.matrices.tests
USING: math.matrices math.vectors tools.test math ;
[
USING: math.miller-rabin tools.test ;
-IN: temporary
+IN: math.miller-rabin.tests
[ f ] [ 473155932665450549999756893736999469773678960651272093993257221235459777950185377130233556540099119926369437865330559863 miller-rabin ] unit-test
[ t ] [ 2 miller-rabin ] unit-test
USING: kernel math.numerical-integration tools.test math
math.constants math.functions ;
-IN: temporary
+IN: math.numerical-integration.tests
[ 50 ] [ 0 10 [ ] integrate-simpson ] unit-test
[ 1000/3 ] [ 0 10 [ sq ] integrate-simpson ] unit-test
-IN: temporary
+IN: math.polynomials.tests
USING: kernel math math.polynomials tools.test ;
! Tests
-IN: temporary
+IN: math.quaternions.tests
USING: tools.test math.quaternions kernel math.vectors
math.constants ;
USING: math.ranges sequences tools.test arrays ;
-IN: temporary
+IN: math.ranges.tests
[ { } ] [ 1 1 (a,b) >array ] unit-test
[ { } ] [ 1 1 (a,b] >array ] unit-test
USING: kernel math math.parser math.ratios math.functions
tools.test ;
-IN: temporary
+IN: math.ratios.tests
[ 1 2 ] [ 1/2 >fraction ] unit-test
USING: kernel math math.functions math.statistics tools.test ;
-IN: temporary
+IN: math.statistics.tests
[ 1 ] [ { 1 } mean ] unit-test
[ 3/2 ] [ { 1 2 } mean ] unit-test
USING: math.functions math.text.english tools.test ;
-IN: temporary
+IN: math.text.english.tests
[ "Zero" ] [ 0 number>text ] unit-test
[ "Twenty-One" ] [ 21 number>text ] unit-test
-IN: temporary
+IN: math.vectors.tests
USING: math.vectors tools.test ;
[ { 1 2 3 } ] [ 1/2 { 2 4 6 } n*v ] unit-test
-IN: temporary
+IN: models.tests
USING: arrays generic kernel math models namespaces sequences assocs
tools.test ;
USING: money parser tools.test ;
-IN: temporary
+IN: money.tests
[ -1/10 ] [ DECIMAL: -.1 ] unit-test
[ -1/10 ] [ DECIMAL: -0.1 ] unit-test
-IN: temporary
+IN: multi-methods.tests
USING: multi-methods tools.test kernel math arrays sequences
prettyprint strings classes hashtables assocs namespaces
debugger continuations ;
! See http://factorcode.org/license.txt for BSD license.
USING: kernel lazy-lists tools.test strings math
sequences parser-combinators arrays math.parser unicode.categories ;
-IN: temporary
+IN: parser-combinators.tests
! Testing <&>
{ { T{ parse-result f { "a" "b" } T{ slice f 2 4 "abcd" } } } } [
USING: namespaces math partial-continuations tools.test
kernel sequences ;
-IN: temporary
+IN: partial-continuations.tests
SYMBOL: sum
! See http://factorcode.org/license.txt for BSD license.
!
USING: kernel tools.test peg peg.ebnf ;
-IN: temporary
+IN: peg.ebnf.tests
{ T{ ebnf-non-terminal f "abc" } } [
"abc" 'non-terminal' parse parse-result-ast
! See http://factorcode.org/license.txt for BSD license.
!
USING: kernel tools.test strings namespaces arrays sequences peg peg.private ;
-IN: temporary
+IN: peg.tests
{ 0 1 2 } [
0 next-id set-global get-next-id get-next-id get-next-id
! See http://factorcode.org/license.txt for BSD license.
!
USING: kernel tools.test peg peg.pl0 ;
-IN: temporary
+IN: peg.pl0.tests
{ "abc" } [
"abc" ident parse parse-result-ast
! See http://factorcode.org/license.txt for BSD license.
!
USING: kernel math math.parser arrays tools.test peg peg.search ;
-IN: temporary
+IN: peg.search.tests
{ V{ 123 456 } } [
"abc 123 def 456" 'integer' search
-IN: temporary
+IN: porter-stemmer.tests
USING: arrays io kernel porter-stemmer sequences tools.test
io.files ;
USING: kernel math random namespaces sequences tools.test ;
-IN: temporary
+IN: random.tests
: check-random ( max -- ? )
dup >r random 0 r> between? ;
USING: arrays kernel sequences sequences.lib math math.functions math.ranges
tools.test strings ;
-IN: temporary
+IN: sequences.lib.tests
[ 50 ] [ 100 [1,b] [ even? ] count ] unit-test
[ 50 ] [ 100 [1,b] [ odd? ] count ] unit-test
USING: tools.test kernel serialize io io.streams.string math
alien arrays byte-arrays sequences math prettyprint parser
classes math.constants ;
-IN: temporary
+IN: serialize.tests
TUPLE: serialize-test a b ;
USING: smtp tools.test io.streams.string threads
smtp.server kernel sequences namespaces logging ;
-IN: temporary
+IN: smtp.tests
{ 0 0 } [ [ ] with-smtp-connection ] must-infer-as
USING: kernel money taxes tools.test ;
-IN: temporary
+IN: taxes.tests
[
426 23
USING: tools.test tools.annotations math parser ;
-IN: temporary
+IN: tools.annotations.tests
: foo ;
\ foo watch
[ 4 ] [ 3 some-generic ] unit-test
-[ ] [ "IN: temporary USE: math M: integer some-generic 1- ;" eval ] unit-test
+[ ] [ "IN: tools.annotations.tests USE: math M: integer some-generic 1- ;" eval ] unit-test
[ 2 ] [ 3 some-generic ] unit-test
-IN: temporary
+IN: tools.browser.tests
USING: tools.browser tools.test help.markup ;
[ ] [ { $describe-vocab "scratchpad" } print-content ] unit-test
USING: math kernel sequences io.files tools.crossref tools.test
parser namespaces source-files generic definitions ;
-IN: temporary
+IN: tools.crossref.tests
GENERIC: foo
-IN: temporary\r
+IN: tools.deploy.tests\r
USING: tools.test system io.files kernel tools.deploy.config\r
tools.deploy.backend math ;\r
\r
USING: tools.test tools.memory ;
-IN: temporary
+IN: tools.memory.tests
[ ] [ heap-stats. ] unit-test
-IN: temporary
+IN: tools.profiler.tests
USING: tools.profiler tools.test kernel memory math threads
alien tools.profiler.private sequences ;
}
"The latter is used for vocabularies with more extensive test suites."
$nl
-"If the test harness needs to define words, they should be placed in the " { $snippet "temporary" } " vocabulary so that they can be forgotten after the tests have been run."
+"If the test harness needs to define words, they should be placed in a vocabulary named " { $snippet { $emphasis "vocab" } ".tests" } " where " { $emphasis "vocab" } " is the vocab being tested."
{ $subsection "tools.test.write" }
{ $subsection "tools.test.run" }
{ $subsection "tools.test.failure" } ;
: (run-test) ( vocab -- )
dup vocab-source-loaded? [
- vocab-tests
- [
- "temporary" forget-vocab
- dup [ forget-source ] each
- ] with-compilation-unit
- dup [ run-file ] each
- ] when drop ;
+ vocab-tests [ run-file ] each
+ ] [ drop ] if ;
: run-test ( vocab -- failures )
V{ } clone [
-IN: temporary
+IN: tools.test.tests
USING: completion words sequences test ;
[ ] [ "swp" apropos ] unit-test
USING: tools.walker io io.streams.string kernel math
math.private namespaces prettyprint sequences tools.test
continuations math.parser threads arrays tools.walker.debug ;
-IN: temporary
+IN: tools.walker.tests
[ { } ] [
[ ] test-walker
USING: kernel tools.test trees trees.avl math random sequences assocs ;
-IN: temporary
+IN: trees.avl.tests
[ "key1" 0 "key2" 0 ] [
T{ avl-node T{ node f "key1" f f T{ avl-node T{ node f "key2" } 1 } } 2 }
! See http://factorcode.org/license.txt for BSD license.
USING: kernel tools.test trees.splay math namespaces assocs
sequences random ;
-IN: temporary
+IN: trees.splay.tests
: randomize-numeric-splay-tree ( splay-tree -- )
100 [ drop 100 random swap at drop ] with each ;
USING: trees assocs tools.test kernel sequences ;
-IN: temporary
+IN: trees.tests
: test-tree ( -- tree )
TREE{
USING: tools.test tuple-syntax ;
-IN: temporary
+IN: tuple-syntax.tests
TUPLE: foo bar baz ;
USING: kernel tools.test tuples.lib ;
-IN: temporary
+IN: tuples.lib.tests
TUPLE: foo a b* c d* e f* ;
-IN: temporary
+IN: ui.commands.tests
USING: ui.commands ui.gestures tools.test help.markup io
io.streams.string ;
-IN: temporary
+IN: ui.gadgets.books.tests
USING: tools.test ui.gadgets.books ;
\ <book> must-infer
-IN: temporary
+IN: ui.gadgets.buttons.tests
USING: ui.commands ui.gadgets.buttons ui.gadgets.labels
ui.gadgets tools.test namespaces sequences kernel models ;
-IN: temporary
+IN: ui.gadgets.frames.tests
USING: ui.gadgets.frames ui.gadgets tools.test ;
[ ] [ <frame> layout ] unit-test
-IN: temporary
+IN: ui.gadgets.tests
USING: ui.gadgets ui.gadgets.packs ui.gadgets.worlds tools.test
namespaces models kernel dlists math
math.parser ui sequences hashtables assocs io arrays
USING: ui.gadgets ui.gadgets.grids tools.test kernel arrays
namespaces ;
-IN: temporary
+IN: ui.gadgets.grids.tests
[ { 0 0 } ] [ { } <grid> pref-dim ] unit-test
USING: ui.gadgets ui.gadgets.labels ui.gadgets.labelled
ui.gadgets.packs ui.gadgets.frames ui.gadgets.grids namespaces
kernel tools.test ui.gadgets.buttons sequences ;
-IN: temporary
+IN: ui.gadgets.labelled.tests
TUPLE: testing ;
-IN: temporary
+IN: ui.gadgets.lists.tests
USING: ui.gadgets.lists models prettyprint math tools.test
kernel ;
-IN: temporary
+IN: ui.gadgets.packs.tests
USING: ui.gadgets.packs ui.gadgets.labels ui.gadgets ui.render
kernel namespaces tools.test math.parser sequences ;
-IN: temporary
+IN: ui.gadgets.panes.tests
USING: alien ui.gadgets.panes ui.gadgets namespaces
kernel sequences io io.streams.string tools.test prettyprint
definitions help help.syntax help.markup splitting
-IN: temporary
+IN: ui.gadgets.presentations.tests
USING: math ui.gadgets.presentations ui.gadgets tools.test
prettyprint ui.gadgets.buttons io io.streams.string kernel
tuples ;
-IN: temporary
+IN: ui.gadgets.scrollers.tests
USING: ui.gadgets ui.gadgets.scrollers
namespaces tools.test kernel models ui.gadgets.viewports
ui.gadgets.labels ui.gadgets.grids ui.gadgets.frames
-IN: temporary
+IN: ui.gadgets.slots.tests
USING: assocs ui.gadgets.slots tools.test refs ;
[ t ] [ { 1 2 3 } 2 <value-ref> <slot-editor> slot-editor? ] unit-test
USING: kernel ui.gadgets ui.gadgets.tracks tools.test ;
-IN: temporary
+IN: ui.gadgets.tracks.tests
[ { 100 100 } ] [
[
-IN: temporary
+IN: ui.gadgets.worlds.tests
USING: ui.gadgets ui.gadgets.packs ui.gadgets.worlds tools.test
namespaces models kernel ;
-IN: temporary
+IN: ui.operations.tests
USING: ui.operations ui.commands prettyprint kernel namespaces
tools.test ui.gadgets ui.gadgets.editors parser io
io.streams.string math help help.markup ;
-IN: temporary
+IN: ui.tools.browser.tests
USING: tools.test tools.test.ui ui.tools.browser ;
\ <browser-gadget> must-infer
-IN: temporary
+IN: ui.tools.interactor.tests
USING: ui.tools.interactor tools.test ;
\ <interactor> must-infer
tools.test ui.commands ui.gadgets ui.gadgets.editors
ui.gadgets.panes vocabs words tools.test.ui slots.private
threads ;
-IN: temporary
+IN: ui.tools.listener.tests
[ f ] [ "word" source-editor command-map empty? ] unit-test
kernel namespaces sequences source-files threads
tools.test ui.gadgets ui.gestures vocabs
vocabs.loader words tools.test.ui debugger ;
-IN: temporary
+IN: ui.tools.search.tests
[ f ] [
"no such word with this name exists, certainly"
sequences tools.test ui.gadgets ui.gadgets.buttons
ui.gadgets.labelled ui.gadgets.presentations
ui.gadgets.scrollers vocabs tools.test.ui ui ;
-IN: temporary
+IN: ui.tools.tests
[
[ f ] [
USING: ui.tools.walker tools.test ;
-IN: temporary
+IN: ui.tools.walker.tests
\ <walker-gadget> must-infer
-IN: temporary
+IN: ui.tools.workspace.tests
USING: tools.test ui.tools ;
\ <workspace> must-infer
-IN: temporary
+IN: ui.traverse.tests
USING: ui.gadgets ui.gadgets.labels namespaces sequences kernel
math arrays tools.test io ui.gadgets.panes ui.traverse
definitions compiler.units ;
USING: kernel math tools.test units.imperial inverse ;
-IN: temporary
+IN: units.imperial.tests
[ 1 ] [ 12 inches [ feet ] undo ] unit-test
[ 12 ] [ 1 feet [ inches ] undo ] unit-test
USING: kernel tools.test units.si inverse math.constants
math.functions units.imperial ;
-IN: temporary
+IN: units.si.tests
[ t ] [ 1 m 100 cm = ] unit-test
USING: arrays kernel math sequences tools.test units.si
units.imperial units inverse math.functions ;
-IN: temporary
+IN: units.tests
[ T{ dimensioned f 3 { m } { } } ] [ 3 m ] unit-test
[ T{ dimensioned f 3 { m } { s } } ] [ 3 m/s ] unit-test
! Copyright (C) 2005, 2006 Daniel Ehrenberg
! See http://factorcode.org/license.txt for BSD license.
-IN: xml-arith
+IN: xml.tests
USING: xml io kernel math sequences strings xml.utilities tools.test math.parser ;
PROCESS: calculate ( tag -- n )
USING: sequences xml kernel arrays xml.utilities io.files tools.test ;
-IN: temporary
+IN: xml.tests
: assemble-data ( tag -- 3array )
{ "URL" "snippet" "title" }
USING: kernel xml sequences assocs tools.test io arrays namespaces
xml.data xml.utilities xml.writer generic sequences.deep ;
+IN: xml.tests
: sub-tag
T{ name f f "sub" "http://littledan.onigirihouse.com/namespaces/replace" } ;
! Copyright (C) 2005, 2006 Daniel Ehrenberg
! See http://factorcode.org/license.txt for BSD license.
-IN: temporary
+IN: xml.tests
USING: kernel xml tools.test io namespaces sequences xml.errors xml.entities
parser strings xml.data io.files xml.writer xml.utilities state-parser
continuations assocs sequences.deep ;
-IN: temporary
+IN: xmode.catalog.tests
USING: xmode.catalog tools.test hashtables assocs
kernel sequences io ;
-IN: temporary
+IN: xmode.keyword-map.tests
USING: xmode.keyword-map xmode.tokens
tools.test namespaces assocs kernel strings ;
USING: xmode.tokens xmode.catalog
xmode.marker tools.test kernel ;
-IN: temporary
+IN: xmode.marker.tests
[
{
-IN: temporary
+IN: xmode.rules.tests
USING: xmode.rules tools.test ;
[ { 1 2 3 } ] [ f { 1 2 3 } ?push-all ] unit-test
-IN: temporary
+IN: xmode.utilities.tests
USING: xmode.utilities tools.test xml xml.data kernel strings
vectors sequences io.files prettyprint assocs unicode.case ;
projects / factor.git / commitdiff