ascii [ readln ] with-process-reader ;
:: test-embedding ( code -- line )
- image :> image
+ image-path :> image
[
I[
] [ { [ unknown-digest? ] [ name>> "no such checksum" = ] } 1&& ]
must-fail-with
-{ } [ image openssl-sha1 checksum-file drop ] unit-test
+{ } [ image-path openssl-sha1 checksum-file drop ] unit-test
! Invalid parameter tests
[
- image binary [ input-stream get accept ] with-file-reader
+ image-path binary [ input-stream get accept ] with-file-reader
] must-fail
[
- image binary [ input-stream get receive ] with-file-reader
+ image-path binary [ input-stream get receive ] with-file-reader
] must-fail
[
- image binary [
+ image-path binary [
B{ 1 2 } datagram-server <local>
input-stream get send
] with-file-reader
{ } [
[
vm-path ,
- "-i=" image append ,
+ "-i=" image-path append ,
"-run=none" ,
"-e=USING: destructors namespaces io calendar threads ; input-stream get dispose 1 seconds sleep" ,
] { } make try-process
{ } [ "IN: classes.mixin.tests.a" <string-reader> "move-mixin-test-1" parse-stream drop ] unit-test
-{ { string } } [ move-instance-declaration-mixin members ] unit-test
+{ { string } } [ move-instance-declaration-mixin class-members ] unit-test
MIXIN: silly-mixin
SYMBOL: not-a-class
! Forgetting a mixin member class should remove it from the mixin
{ } [ [ metaclass-change forget-class ] with-compilation-unit ] unit-test
-{ t } [ metaclass-change-mixin members empty? ] unit-test
+{ t } [ metaclass-change-mixin class-members empty? ] unit-test
{ } [ "IN: classes.predicate.tests USE: arrays UNION: change-meta-test-class array ;" eval( -- ) ] unit-test
! Should not have changed
-{ change-meta-test-class } [ change-meta-test-predicate superclass ] unit-test
+{ change-meta-test-class } [ change-meta-test-predicate superclass-of ] unit-test
[ { } change-meta-test ] [ no-method? ] must-fail-with
{ 4 } [ { 1 2 3 4 } change-meta-test ] unit-test
TUPLE: test-2 < test-1 ;
{ t } [ test-2 "slots" word-prop empty? ] unit-test
-{ test-1 } [ test-2 superclass ] unit-test
+{ test-1 } [ test-2 superclass-of ] unit-test
TUPLE: test-3 a ;
IN: tools.image-analyzer.vm.32
STRUCT: boxed-float
- { header cell }
- { padding cell }
+ { header cell_t }
+ { padding cell_t }
{ n double } ;
STRUCT: byte-array
- { header cell }
- { capacity cell }
- { padding0 cell }
- { padding1 cell } ;
+ { header cell_t }
+ { capacity cell_t }
+ { padding0 cell_t }
+ { padding1 cell_t } ;
IN: tools.image-analyzer.vm.64
STRUCT: boxed-float
- { header cell }
+ { header cell_t }
{ n double } ;
STRUCT: byte-array
- { header cell }
- { capacity cell } ;
+ { header cell_t }
+ { capacity cell_t } ;
! These structs and words correspond to vm/image.hpp
STRUCT: image-header
- { magic cell }
- { version cell }
- { data-relocation-base cell }
- { data-size cell }
- { code-relocation-base cell }
- { code-size cell }
- { true-object cell }
- { bignum-zero cell }
- { bignum-pos-one cell }
- { bignum-neg-one cell }
- { special-objects cell[special-object-count] } ;
+ { magic cell_t }
+ { version cell_t }
+ { data-relocation-base cell_t }
+ { data-size cell_t }
+ { code-relocation-base cell_t }
+ { code-size cell_t }
+ { true-object cell_t }
+ { bignum-zero cell_t }
+ { bignum-pos-one cell_t }
+ { bignum-neg-one cell_t }
+ { special-objects cell_t[special-object-count] } ;
! These structs and words correspond to vm/layouts.hpp
STRUCT: object
- { header cell } ;
+ { header cell_t } ;
STRUCT: alien
- { header cell }
- { base cell }
- { expired cell }
- { displacement cell }
- { address cell } ;
+ { header cell_t }
+ { base cell_t }
+ { expired cell_t }
+ { displacement cell_t }
+ { address cell_t } ;
STRUCT: array
- { header cell }
- { capacity cell } ;
+ { header cell_t }
+ { capacity cell_t } ;
STRUCT: bignum
- { header cell }
- { capacity cell } ;
+ { header cell_t }
+ { capacity cell_t } ;
STRUCT: callstack
- { header cell }
- { length cell } ;
+ { header cell_t }
+ { length cell_t } ;
STRUCT: dll
- { header cell }
- { path cell }
+ { header cell_t }
+ { path cell_t }
{ handle void* } ;
STRUCT: quotation
- { header cell }
- { array cell }
- { cached_effect cell }
- { cache_counter cell }
- { entry_point cell } ;
+ { header cell_t }
+ { array cell_t }
+ { cached_effect cell_t }
+ { cache_counter cell_t }
+ { entry_point cell_t } ;
STRUCT: string
- { header cell }
- { length cell }
- { aux cell }
- { hashcode cell } ;
+ { header cell_t }
+ { length cell_t }
+ { aux cell_t }
+ { hashcode cell_t } ;
STRUCT: tuple
- { header cell }
- { layout cell } ;
+ { header cell_t }
+ { layout cell_t } ;
STRUCT: tuple-layout
- { header cell }
- { capacity cell }
- { klass cell }
- { size cell }
- { echelon cell } ;
+ { header cell_t }
+ { capacity cell_t }
+ { klass cell_t }
+ { size cell_t }
+ { echelon cell_t } ;
STRUCT: word
- { header cell }
- { hashcode cell }
- { name cell }
- { vocabulary cell }
- { def cell }
- { props cell }
- { pic_def cell }
- { pic_tail_def cell }
- { subprimitive cell }
- { entry_point cell } ;
+ { header cell_t }
+ { hashcode cell_t }
+ { name cell_t }
+ { vocabulary cell_t }
+ { def cell_t }
+ { props cell_t }
+ { pic_def cell_t }
+ { pic_tail_def cell_t }
+ { subprimitive cell_t }
+ { entry_point cell_t } ;
STRUCT: wrapper
- { header cell }
- { object cell } ;
+ { header cell_t }
+ { object cell_t } ;
! These structs and words correspond to vm/code_blocks.hpp
STRUCT: code-block
- { header cell }
- { owner cell }
- { parameters cell }
- { relocation cell } ;
+ { header cell_t }
+ { owner cell_t }
+ { parameters cell_t }
+ { relocation cell_t } ;
PREDICATE: variant-class < mixin-class "variant?" word-prop ;
M: variant-class initial-value*
- members [ f f ] [
+ class-members [ f f ] [
first dup word? [ t ] [ initial-value* ] if
] if-empty ;