steve
/
factor
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

factor: fix unit tests.

locals-and-roots
Doug Coleman 2016-06-07 09:37:38 -07:00
parent 90984e4255
commit 391b01b661
25 changed files with 100 additions and 100 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
collections/hash-sets/identity/identity-tests.factor
View File

@ -7,7 +7,7 @@ CONSTANT: will
IHS{
$ the-real-slim-shady
"marshall mathers"
}
} ;
: please-stand-up ( set obj -- ? )
swap in? ;

2
collections/persistent/heaps/heaps-tests.factor
View File

@ -3,7 +3,7 @@ in: persistent.heaps.tests
CONSTANT: test-input
{ { "hello" 3 } { "goodbye" 2 } { "whatever" 5 }
{ "foo" 1 } { "bar" -1 } { "baz" -7 } { "bing" 0 } }
{ "foo" 1 } { "bar" -1 } { "baz" -7 } { "bing" 0 } } ;
{
{ { "baz" -7 } { "bar" -1 } { "bing" 0 } { "foo" 1 }

2
core/hashtables/identity/identity-tests.factor
View File

@ -8,7 +8,7 @@ CONSTANT: will
IH{
{ $ the-real-slim-shady t }
{ "marshall mathers" f }
}
} ;
: please-stand-up ( assoc key -- value )
of ;

2
core/syntax/syntax.factor
View File

@ -196,7 +196,7 @@ in: bootstrap.syntax
"ALIAS:" [
scan-new-word scan-word ";" expect define-alias
scan-new-escaped scan-escaped-word ";" expect define-alias
] define-core-syntax
"CONSTANT:" [

2
core/words/alias/alias-tests.factor
View File

@ -5,7 +5,7 @@ ALIAS: foo + ;
{ } [ "in: words.alias.tests CONSTANT: foo 5" eval( -- ) ] unit-test
{ ( -- value ) } [ \ foo stack-effect ] unit-test
ALIAS: MY-H{ H{ ;
ALIAS: \ MY-H{ \ H{ ;
{ H{ { 1 2 } } } [
"in: words.alias.tests MY-H{ { 1 2 } }" eval( -- x )
] unit-test

2
ffi/opengl/capabilities/capabilities-tests.factor
View File

@ -7,7 +7,7 @@ CONSTANT: test-extensions
"GL_ARB_vent_core_frogblast"
"GL_EXT_resonance_cascade"
"GL_EXT_slipgate"
}
} ;
{ t }
[ "GL_ARB_vent_core_frogblast" test-extensions (has-extension?) ] unit-test

2
frameworks/game/models/half-edge/half-edge-tests.factor
View File

@ -33,7 +33,7 @@ CONSTANT: cube-edges
T{ edge { face 5 } { vertex 0 } { opposite-edge 3 } { next-edge 22 } }
T{ edge { face 5 } { vertex 2 } { opposite-edge 15 } { next-edge 23 } }
T{ edge { face 5 } { vertex 6 } { opposite-edge 11 } { next-edge 20 } }
}
} ;
: connect-cube-edges ( -- )
cube-edges [

60
language/alien/fortran/fortran-tests.factor
View File

@ -4,8 +4,8 @@ alien.data alien.fortran alien.fortran.private alien.strings
classes.struct arrays assocs byte-arrays combinators fry
generalizations io.encodings.ascii kernel macros
macros.expander namespaces sequences shuffle tools.test vocabs.parser ;
FROM: alien.syntax => pointer: ;
QUALIFIED-WITH: alien.c-types c ;
QUALIFIED-WITH: alien.syntax s ;
in: alien.fortran.tests
<< intel-unix-abi "(alien.fortran-tests)" (add-fortran-library) >>
@ -101,16 +101,16 @@ intel-unix-abi fortran-abi [
! fortran-arg-type>c-type
[ pointer: c:int { } ]
[ s:pointer: c:int { } ]
[ "integer" fortran-arg-type>c-type ] unit-test
[ pointer: { c:int 3 } { } ]
[ s:pointer: { c:int 3 } { } ]
[ "integer(3)" fortran-arg-type>c-type ] unit-test
[ pointer: { c:int 0 } { } ]
[ s:pointer: { c:int 0 } { } ]
[ "integer(*)" fortran-arg-type>c-type ] unit-test
[ pointer: fortran_test_record { } ]
[ s:pointer: fortran_test_record { } ]
[
[
"alien.fortran.tests" use-vocab
@ -118,13 +118,13 @@ intel-unix-abi fortran-abi [
] with-manifest
] unit-test
[ pointer: c:char { } ]
[ s:pointer: c:char { } ]
[ "character" fortran-arg-type>c-type ] unit-test
[ pointer: c:char { } ]
[ s:pointer: c:char { } ]
[ "character(1)" fortran-arg-type>c-type ] unit-test
[ pointer: { c:char 17 } { long } ]
[ s:pointer: { c:char 17 } { long } ]
[ "character(17)" fortran-arg-type>c-type ] unit-test
! fortran-ret-type>c-type
@ -132,7 +132,7 @@ intel-unix-abi fortran-abi [
[ c:char { } ]
[ "character(1)" fortran-ret-type>c-type ] unit-test
[ c:void { pointer: { c:char 17 } long } ]
[ c:void { s:pointer: { c:char 17 } long } ]
[ "character(17)" fortran-ret-type>c-type ] unit-test
[ c:int { } ]
@ -144,22 +144,22 @@ intel-unix-abi fortran-abi [
[ c:float { } ]
[ "real" fortran-ret-type>c-type ] unit-test
[ c:void { pointer: { c:float 0 } } ]
[ c:void { s:pointer: { c:float 0 } } ]
[ "real(*)" fortran-ret-type>c-type ] unit-test
[ c:double { } ]
[ "double-precision" fortran-ret-type>c-type ] unit-test
[ c:void { pointer: complex-float } ]
[ c:void { s:pointer: complex-float } ]
[ "complex" fortran-ret-type>c-type ] unit-test
[ c:void { pointer: complex-double } ]
[ c:void { s:pointer: complex-double } ]
[ "double-complex" fortran-ret-type>c-type ] unit-test
[ c:void { pointer: { c:int 0 } } ]
[ c:void { s:pointer: { c:int 0 } } ]
[ "integer(*)" fortran-ret-type>c-type ] unit-test
[ c:void { pointer: fortran_test_record } ]
[ c:void { s:pointer: fortran_test_record } ]
[
[
"alien.fortran.tests" use-vocab
@ -169,19 +169,19 @@ intel-unix-abi fortran-abi [
! fortran-sig>c-sig
[ c:float { pointer: c:int pointer: { c:char 17 } pointer: c:float pointer: c:double c:long } ]
[ c:float { s:pointer: c:int s:pointer: { c:char 17 } s:pointer: c:float s:pointer: c:double c:long } ]
[ "real" { "integer" "character*17" "real" "real*8" } fortran-sig>c-sig ]
unit-test
[ c:char { pointer: { c:char 17 } pointer: c:char pointer: c:int c:long } ]
[ c:char { s:pointer: { c:char 17 } s:pointer: c:char s:pointer: c:int c:long } ]
[ "character(1)" { "character*17" "character" "integer" } fortran-sig>c-sig ]
unit-test
[ c:void { pointer: { c:char 18 } c:long pointer: { c:char 17 } pointer: c:char pointer: c:int c:long } ]
[ c:void { s:pointer: { c:char 18 } c:long s:pointer: { c:char 17 } s:pointer: c:char s:pointer: c:int c:long } ]
[ "character*18" { "character*17" "character" "integer" } fortran-sig>c-sig ]
unit-test
[ c:void { pointer: complex-float pointer: { c:char 17 } pointer: c:char pointer: c:int c:long } ]
[ c:void { s:pointer: complex-float s:pointer: { c:char 17 } s:pointer: c:char s:pointer: c:int c:long } ]
[ "complex" { "character*17" "character" "integer" } fortran-sig>c-sig ]
unit-test
@ -202,7 +202,7 @@ intel-unix-abi fortran-abi [
! [fortran-invoke]
[
c:void "funpack" "funtimes_"
{ pointer: { c:char 12 } pointer: c:longlong pointer: c:float pointer: complex-float pointer: c:short c:long }
{ s:pointer: { c:char 12 } s:pointer: c:longlong s:pointer: c:float s:pointer: complex-float s:pointer: c:short c:long }
alien-invoke
] 6 nkeep
! [fortran-results>]
@ -227,7 +227,7 @@ intel-unix-abi fortran-abi [
[ { [ drop ] } spread ]
} 1 ncleave
! [fortran-invoke]
[ c:float "funpack" "fun_times_" { pointer: { c:float 0 } } alien-invoke ]
[ c:float "funpack" "fun_times_" { s:pointer: { c:float 0 } } alien-invoke ]
1 nkeep
! [fortran-results>]
shuffle( reta aa -- reta aa )
@ -245,7 +245,7 @@ intel-unix-abi fortran-abi [
! [fortran-invoke]
[
c:void "funpack" "fun_times_"
{ pointer: complex-float pointer: { c:float 0 } }
{ s:pointer: complex-float s:pointer: { c:float 0 } }
alien-invoke
] 2 nkeep
! [fortran-results>]
@ -262,7 +262,7 @@ intel-unix-abi fortran-abi [
! [fortran-invoke]
[
c:void "funpack" "fun_times_"
{ pointer: { c:char 20 } long }
{ s:pointer: { c:char 20 } long }
alien-invoke
] 2 nkeep
! [fortran-results>]
@ -288,7 +288,7 @@ intel-unix-abi fortran-abi [
! [fortran-invoke]
[
c:void "funpack" "fun_times_"
{ pointer: { c:char 10 } long pointer: { c:char 20 } pointer: c:float pointer: { c:char 30 } c:long c:long }
{ s:pointer: { c:char 10 } long s:pointer: { c:char 20 } s:pointer: c:float s:pointer: { c:char 30 } c:long c:long }
alien-invoke
] 7 nkeep
! [fortran-results>]
@ -322,16 +322,16 @@ f2c-abi fortran-abi [
[ { c:char 1 } ]
[ "character(1)" fortran-type>c-type ] unit-test
[ pointer: c:char { c:long } ]
[ s:pointer: c:char { c:long } ]
[ "character" fortran-arg-type>c-type ] unit-test
[ c:void { pointer: c:char c:long } ]
[ c:void { s:pointer: c:char c:long } ]
[ "character" fortran-ret-type>c-type ] unit-test
[ c:double { } ]
[ "real" fortran-ret-type>c-type ] unit-test
[ c:void { pointer: { c:float 0 } } ]
[ c:void { s:pointer: { c:float 0 } } ]
[ "real(*)" fortran-ret-type>c-type ] unit-test
[ "fun_" ] [ "FUN" fortran-name>symbol-name ] unit-test
@ -345,7 +345,7 @@ gfortran-abi fortran-abi [
[ c:float { } ]
[ "real" fortran-ret-type>c-type ] unit-test
[ c:void { pointer: { c:float 0 } } ]
[ c:void { s:pointer: { c:float 0 } } ]
[ "real(*)" fortran-ret-type>c-type ] unit-test
[ complex-float { } ]
@ -357,10 +357,10 @@ gfortran-abi fortran-abi [
[ { char 1 } ]
[ "character(1)" fortran-type>c-type ] unit-test
[ pointer: c:char { c:long } ]
[ s:pointer: c:char { c:long } ]
[ "character" fortran-arg-type>c-type ] unit-test
[ c:void { pointer: c:char c:long } ]
[ c:void { s:pointer: c:char c:long } ]
[ "character" fortran-ret-type>c-type ] unit-test
[ complex-float { } ]
@ -369,7 +369,7 @@ gfortran-abi fortran-abi [
[ complex-double { } ]
[ "double-complex" fortran-ret-type>c-type ] unit-test
[ c:void { pointer: { complex-double 3 } } ]
[ c:void { s:pointer: { complex-double 3 } } ]
[ "double-complex(3)" fortran-ret-type>c-type ] unit-test
] with-variable

2
language/classes/struct/vectored/vectored-tests.factor
View File

@ -12,7 +12,7 @@ STRUCT: foo
{ w ushort } ;
specialized-array: foo
VECTORED-STRUCT: foo
vectored-struct: foo
{
T{ vectored-foo

2
language/classes/struct/vectored/vectored.factor
View File

@ -113,5 +113,5 @@ M: T-array struct-transpose
FUNCTOR;
SYNTAX: \ VECTORED-STRUCT:
SYNTAX: \ vectored-struct:
scan-word define-vectored-struct ;

4
language/compiler/cfg/intrinsics/simd/simd-tests.factor
View File

@ -85,12 +85,12 @@ in: compiler.cfg.intrinsics.simd.tests
] make-classes ; inline
CONSTANT: signed-reps
{ char-16-rep short-8-rep int-4-rep longlong-2-rep float-4-rep double-2-rep }
{ char-16-rep short-8-rep int-4-rep longlong-2-rep float-4-rep double-2-rep } ;
CONSTANT: all-reps
{
char-16-rep short-8-rep int-4-rep longlong-2-rep float-4-rep double-2-rep
uchar-16-rep ushort-8-rep uint-4-rep ulonglong-2-rep
}
} ;
TUPLE: scalar-cpu ;

2
language/constructors/constructors-tests.factor
View File

@ -50,7 +50,7 @@ TUPLE: a-monster < monster ;
TUPLE: b-monster < monster ;
<<
SLOT-CONSTRUCTOR: a-monster
slot-constructor: a-monster
>>
: <a-monster> ( name hp max-hp -- obj )

2
language/constructors/constructors.factor
View File

@ -59,6 +59,6 @@ SYNTAX: \ CONSTRUCTOR:
: scan-full-input-effect ( -- effect )
"(" expect scan-rest-input-effect ;
SYNTAX: \ SLOT-CONSTRUCTOR:
SYNTAX: \ slot-constructor:
scan-new-word [ name>> "(" append create-reset ] keep
'[ scan-rest-input-effect in>> _ '[ _ _ slots>boa ] append! ] define-syntax ;

4
language/cpu/x86/x86-tests.factor
View File

@ -60,7 +60,7 @@ cpu x86.64? [
! %clear
{ t } [
[ D: 0 %clear ] B{ } make
[ d: 0 %clear ] B{ } make
cpu x86.32? B{ 199 6 144 18 0 0 } B{ 73 199 6 144 18 0 0 } ? =
] unit-test
@ -96,6 +96,6 @@ cpu x86.64? [
B{ 73 199 6 0 0 0 0 }
}
[
init-relocation [ 34.0 D: 0 %replace-imm ] B{ } make
init-relocation [ 34.0 d: 0 %replace-imm ] B{ } make
] unit-test
] when

28
language/io/encodings/iso2022/iso2022-tests.factor
View File

@ -7,16 +7,16 @@ in: io.encodings.iso2022
{ "hello" } [ "hello" >byte-array iso2022 decode ] unit-test
{ "hello" } [ "hello" iso2022 encode >string ] unit-test
{ "hi" } [ B{ char: h $ ESC char: ( char: B char: i } iso2022 decode ] unit-test
{ "hi" } [ B{ char: h char: i $ ESC char: ( char: B } iso2022 decode ] unit-test
{ "hi\u00fffd" } [ B{ char: h char: i $ ESC char: ( } iso2022 decode ] unit-test
{ "hi" } [ B{ char: h $ ESC char: \( char: B char: i } iso2022 decode ] unit-test
{ "hi" } [ B{ char: h char: i $ ESC char: \( char: B } iso2022 decode ] unit-test
{ "hi\u00fffd" } [ B{ char: h char: i $ ESC char: \( } iso2022 decode ] unit-test
{ "hi\u00fffd" } [ B{ char: h char: i $ ESC } iso2022 decode ] unit-test
{ B{ char: h $ ESC char: ( char: J 0xD8 } } [ "h\u00ff98" iso2022 encode ] unit-test
{ "h\u00ff98" } [ B{ char: h $ ESC char: ( char: J 0xD8 } iso2022 decode ] unit-test
{ "hi" } [ B{ char: h $ ESC char: ( char: J char: i } iso2022 decode ] unit-test
{ "h" } [ B{ char: h $ ESC char: ( char: J } iso2022 decode ] unit-test
{ "h\u00fffd" } [ B{ char: h $ ESC char: ( char: J 0x80 } iso2022 decode ] unit-test
{ B{ char: h $ ESC char: \( char: J 0xD8 } } [ "h\u00ff98" iso2022 encode ] unit-test
{ "h\u00ff98" } [ B{ char: h $ ESC char: \( char: J 0xD8 } iso2022 decode ] unit-test
{ "hi" } [ B{ char: h $ ESC char: \( char: J char: i } iso2022 decode ] unit-test
{ "h" } [ B{ char: h $ ESC char: \( char: J } iso2022 decode ] unit-test
{ "h\u00fffd" } [ B{ char: h $ ESC char: \( char: J 0x80 } iso2022 decode ] unit-test
{ B{ char: h $ ESC char: $ char: B 0x3E 0x47 } } [ "h\u007126" iso2022 encode ] unit-test
{ "h\u007126" } [ B{ char: h $ ESC char: $ char: B 0x3E 0x47 } iso2022 decode ] unit-test
@ -26,11 +26,11 @@ in: io.encodings.iso2022
{ "h\u00fffd" } [ B{ char: h $ ESC } iso2022 decode ] unit-test
{ "h\u00fffd" } [ B{ char: h $ ESC char: $ char: B 0x80 0x80 } iso2022 decode ] unit-test
{ B{ char: h $ ESC char: $ char: ( char: D 0x38 0x54 } } [ "h\u0058ce" iso2022 encode ] unit-test
{ "h\u0058ce" } [ B{ char: h $ ESC char: $ char: ( char: D 0x38 0x54 } iso2022 decode ] unit-test
{ "h\u00fffd" } [ B{ char: h $ ESC char: $ char: ( char: D 0x38 } iso2022 decode ] unit-test
{ "h" } [ B{ char: h $ ESC char: $ char: ( char: D } iso2022 decode ] unit-test
{ "h\u00fffd" } [ B{ char: h $ ESC char: $ char: ( } iso2022 decode ] unit-test
{ "h\u00fffd" } [ B{ char: h $ ESC char: $ char: ( char: D 0x70 0x70 } iso2022 decode ] unit-test
{ B{ char: h $ ESC char: $ char: \( char: D 0x38 0x54 } } [ "h\u0058ce" iso2022 encode ] unit-test
{ "h\u0058ce" } [ B{ char: h $ ESC char: $ char: \( char: D 0x38 0x54 } iso2022 decode ] unit-test
{ "h\u00fffd" } [ B{ char: h $ ESC char: $ char: \( char: D 0x38 } iso2022 decode ] unit-test
{ "h" } [ B{ char: h $ ESC char: $ char: \( char: D } iso2022 decode ] unit-test
{ "h\u00fffd" } [ B{ char: h $ ESC char: $ char: \( } iso2022 decode ] unit-test
{ "h\u00fffd" } [ B{ char: h $ ESC char: $ char: \( char: D 0x70 0x70 } iso2022 decode ] unit-test
[ "\u{syriac-music}" iso2022 encode ] must-fail

5
language/multiline/multiline-tests.factor
View File

@ -81,7 +81,8 @@ SYNTAX: MULTILINE-LITERAL: parse-here suffix! ;
CONSTANT: foo { MULTILINE-LITERAL:
bar
;
} foo
} ;
foo
] unit-test
! Make sure parse-here fails if extra crap appears on the first line
@ -89,6 +90,6 @@ bar
"CONSTANT: foo { MULTILINE-LITERAL: asdfasfdasdfas
bar
;
}" eval
} ;" eval
] must-fail
*/

3
language/serialize/serialize-tests.factor
View File

@ -1,6 +1,5 @@
! Copyright (C) 2006 Chris Double.
! See http://factorcode.org/license.txt for BSD license.
!
USING: tools.test kernel serialize io io.streams.byte-array
alien arrays byte-arrays bit-arrays specialized-arrays
sequences math prettyprint parser classes math.constants
@ -63,7 +62,7 @@ CONSTANT: objects
<< 1 [ 2 ] curry suffix! >>
{ { "a" "bc" } { "de" "fg" } }
H{ { "a" "bc" } { "de" "fg" } }
}
} ;
: check-serialize-1 ( obj -- ? )
"=====" print

10
language/tuple-arrays/tuple-arrays-tests.factor
View File

@ -5,7 +5,7 @@ in: tuple-arrays.tests
symbol: mat
TUPLE: foo bar ; final
C: <foo> foo ;
TUPLE-ARRAY: foo
tuple-array: foo
{ 2 } [ 2 <foo-array> dup mat set length ] unit-test
{ T{ foo } } [ mat get first ] unit-test
@ -19,7 +19,7 @@ TUPLE-ARRAY: foo
{ T{ foo f 1 } } [ T{ foo f 1 } 0 mat get [ set-nth ] keep first ] unit-test
TUPLE: baz { bing integer } bong ; final
TUPLE-ARRAY: baz
tuple-array: baz
{ 0 } [ 1 <baz-array> first bing>> ] unit-test
{ f } [ 1 <baz-array> first bong>> ] unit-test
@ -27,7 +27,7 @@ TUPLE-ARRAY: baz
TUPLE: broken x ; final
: broken ( -- ) ;
TUPLE-ARRAY: broken
tuple-array: broken
{ 100 } [ 100 <broken-array> length ] unit-test
@ -46,7 +46,7 @@ must-fail-with
! Empty tuple
TUPLE: empty-tuple ; final
TUPLE-ARRAY: empty-tuple
tuple-array: empty-tuple
{ 100 } [ 100 <empty-tuple-array> length ] unit-test
{ T{ empty-tuple } } [ 100 <empty-tuple-array> first ] unit-test
@ -56,7 +56,7 @@ TUPLE-ARRAY: empty-tuple
! of crashing Factor
TUPLE: tuple-to-struct x ; final
TUPLE-ARRAY: tuple-to-struct
tuple-array: tuple-to-struct
{ f } [ tuple-to-struct struct-class? ] unit-test

2
language/tuple-arrays/tuple-arrays.factor
View File

@ -73,4 +73,4 @@ INSTANCE: CLASS-array sequence ;
FUNCTOR;
SYNTAX: \ TUPLE-ARRAY: scan-word define-tuple-array ;
SYNTAX: \ tuple-array: scan-word define-tuple-array ;

12
libs/c/lexer/lexer-tests.factor
View File

@ -51,32 +51,32 @@ in: c.lexer.tests
{ f }
[
"\"abc\" asdf" <sequence-parser>
[ char: \ char: " take-quoted-string drop ] [ "asdf" take-sequence ] bi
[ char: \ char: \" take-quoted-string drop ] [ "asdf" take-sequence ] bi
] unit-test
{ "abc\\\"def" }
[
"\"abc\\\"def\" asdf" <sequence-parser>
char: \ char: " take-quoted-string
char: \ char: \" take-quoted-string
] unit-test
{ "asdf" }
[
"\"abc\" asdf" <sequence-parser>
[ char: \ char: " take-quoted-string drop ]
[ char: \ char: \" take-quoted-string drop ]
[ skip-whitespace "asdf" take-sequence ] bi
] unit-test
{ f }
[
"\"abc asdf" <sequence-parser>
char: \ char: " take-quoted-string
char: \ char: \" take-quoted-string
] unit-test
{ "\"abc" }
[
"\"abc asdf" <sequence-parser>
[ char: \ char: " take-quoted-string drop ]
[ char: \ char: \" take-quoted-string drop ]
[ "\"abc" take-sequence ] bi
] unit-test
@ -87,7 +87,7 @@ in: c.lexer.tests
[ "" <sequence-parser> take-token ] unit-test
{ "abcd e \\\"f g" }
[ "\"abcd e \\\"f g\"" <sequence-parser> char: \ char: " take-token* ] unit-test
[ "\"abcd e \\\"f g\"" <sequence-parser> char: \ char: \" take-token* ] unit-test
{ "123" }
[ "123jjj" <sequence-parser> take-c-integer ] unit-test

6
libs/euler/b-rep/io/obj/obj-tests.factor
View File

@ -18,7 +18,7 @@ f 7 8 6 5
f 3 4 8 7
f 2 6 8 4
f 5 1 3 7
"
" ;
CONSTANT: valid-cube-obj-relative-indices
"v -1.0 -1.0 -1.0
@ -35,7 +35,7 @@ f 7 8 6 5
f 3 4 8 7
f 2 6 8 4
f 5 1 3 7
"
" ;
CONSTANT: valid-cube-obj-texcoords
"# comment should be ignored
@ -57,7 +57,7 @@ f 7/3 8/4 6/2 5/1
f 3/3 4/4 8/4 7/3
f 2/2 6/2 8/4 4/4
f 5/1 1/1 3/3 7/3
"
" ;
{ $ valid-cube-obj } [ [ valid-cube-b-rep write-obj ] with-string-writer ] unit-test

8
libs/infix/tokenizer/tokenizer-tests.factor
View File

@ -5,17 +5,17 @@ in: infix.tokenizer.tests
{ V{ T{ ast-number f 1 } } } [ "1" tokenize-infix ] unit-test
{ V{ T{ ast-number f 1.02 } char: * T{ ast-number f 3 } } } [ "1.02*3" tokenize-infix ] unit-test
{ V{ T{ ast-number f 3 } char: / char: ( T{ ast-number f 3 } char: + T{ ast-number f 4 } char: ) } }
{ V{ T{ ast-number f 3 } char: / char: \( T{ ast-number f 3 } char: + T{ ast-number f 4 } char: ) } }
[ "3/(3+4)" tokenize-infix ] unit-test
{ V{ "foo" char: ( "x" char: , "y" char: , "z" char: ) } } [ "foo(x,y,z)" tokenize-infix ] unit-test
{ V{ "arr" char: [ "x" char: + T{ ast-number f 3 } char: ] } }
{ V{ "foo" char: \( "x" char: , "y" char: , "z" char: ) } } [ "foo(x,y,z)" tokenize-infix ] unit-test
{ V{ "arr" char: \[ "x" char: + T{ ast-number f 3 } char: ] } }
[ "arr[x+3]" tokenize-infix ] unit-test
[ "1.0.4" tokenize-infix ] must-fail
{ V{ char: + char: ] T{ ast-number f 3.4 } char: , "bar" } }
[ "+]3.4,bar" tokenize-infix ] unit-test
{ V{ "baz_34c" } } [ "baz_34c" tokenize-infix ] unit-test
{ V{ T{ ast-number f 34 } "c_baz" } } [ "34c_baz" tokenize-infix ] unit-test
{ V{ char: ( T{ ast-number f 1 } char: + T{ ast-number f 2 } char: ) } }
{ V{ char: \( T{ ast-number f 1 } char: + T{ ast-number f 2 } char: ) } }
[ "(1+2)" tokenize-infix ] unit-test
{ V{ T{ ast-number f 1 } char: + T{ ast-number f 2 } char: / T{ ast-number f 3 } } }
[ "1\n+\r2\t/ 3" tokenize-infix ] unit-test

28
libs/math/rectangles/rectangles-tests.factor
View File

@ -2,39 +2,39 @@ USING: tools.test math.rectangles prettyprint io.streams.string
kernel accessors ;
in: math.rectangles.tests
{ RECT: { 10 10 } { 20 20 } }
{ RECT: { 10 10 } { 20 20 } ; }
[
RECT: { 10 10 } { 50 50 }
RECT: { -10 -10 } { 40 40 }
RECT: { 10 10 } { 50 50 } ;
RECT: { -10 -10 } { 40 40 } ;
rect-intersect
] unit-test
{ RECT: { 200 200 } { 0 0 } }
{ RECT: { 200 200 } { 0 0 } ; }
[
RECT: { 100 100 } { 50 50 }
RECT: { 200 200 } { 40 40 }
RECT: { 100 100 } { 50 50 } ;
RECT: { 200 200 } { 40 40 } ;
rect-intersect
] unit-test
{ f } [
RECT: { 100 100 } { 50 50 }
RECT: { 200 200 } { 40 40 }
RECT: { 100 100 } { 50 50 } ;
RECT: { 200 200 } { 40 40 } ;
contains-rect?
] unit-test
{ t } [
RECT: { 100 100 } { 50 50 }
RECT: { 120 120 } { 40 40 }
RECT: { 100 100 } { 50 50 } ;
RECT: { 120 120 } { 40 40 } ;
contains-rect?
] unit-test
{ f } [
RECT: { 1000 100 } { 50 50 }
RECT: { 120 120 } { 40 40 }
RECT: { 1000 100 } { 50 50 } ;
RECT: { 120 120 } { 40 40 } ;
contains-rect?
] unit-test
{ RECT: { 10 20 } { 20 20 } } [
{ RECT: { 10 20 } { 20 20 } ; } [
{
{ 20 20 }
{ 10 40 }
@ -43,4 +43,4 @@ in: math.rectangles.tests
] unit-test
! Prettyprint for RECT: didn't do nesting check properly
{ } [ [ RECT: f f dup >>dim . ] with-string-writer drop ] unit-test
{ } [ [ RECT: f f ; dup >>dim . ] with-string-writer drop ] unit-test

4
libs/math/rectangles/rectangles.factor
View File

@ -1,14 +1,14 @@
! Copyright (C) 2008, 2009 Slava Pestov.
! See http://factorcode.org/license.txt for BSD license.
USING: kernel arrays sequences math math.vectors accessors
parser ;
parser lexer ;
in: math.rectangles
TUPLE: rect { loc initial: { 0 0 } } { dim initial: { 0 0 } } ;
: <rect> ( loc dim -- rect ) rect boa ; inline
SYNTAX: \ RECT: scan-object scan-object <rect> suffix! ;
SYNTAX: \ RECT: scan-object scan-object ";" expect <rect> suffix! ;
: <zero-rect> ( -- rect ) rect new ; inline

4
libs/uu/uu-tests.factor
View File

@ -2,14 +2,14 @@ USING: kernel tools.test ;
in: uu
CONSTANT: plain
"The smooth-scaled python crept over the sleeping dog"
"The smooth-scaled python crept over the sleeping dog" ;
CONSTANT: encoded
"begin
M5&AE('-M;V]T:\"US8V%L960@<'ET:&]N(&-R97!T(&]V97(@=&AE('-L965P
':6YG(&1O9P
end
"
" ;
{ t } [ plain string>uu encoded = ] unit-test
{ t } [ encoded uu>string plain = ] unit-test