Build report for windows/x86.32
Tests failed
Build output:
V{ 3 9 8 } introduce-values
stack-visitor get first out-d>> known-values get
]
}
Unit Test: {
{ V{ 1 2 3 4 5 } }
[ 0 \ <value> set-global init-inference 5 ensure-d ]
}
Unit Test: {
{ V{ 9 7 3 } }
[
V{ } clone stack-visitor set V{ 9 7 3 } (meta-d) set
end-infer stack-visitor get first in-d>>
]
}
Unit Test: {
{ H{ } }
[
H{ } clone dependencies set H{ } clone known-values set
init-inference [ \ sam-sum ] first apply-object
dependencies get
]
}
Unit Test: {
{ V{ "abc" } }
[
H{ } clone known-values set
init-inference "abc" apply-object literals get
]
}
Unit Test: {
{ t }
[
0 \ <value> set-global
[ V{ } clone stack-visitor set pop-d ] with-infer 2nip
V{
T{ #introduce { out-d { 1 } } }
T{ #return { in-d V{ } } }
} node-seqs-eq?
]
}
Unit Test: { { 2 } [ V{ 1 2 } clone literals set pop-literal ] }
Unit Test: {
{ 4321 }
[
init-inference 4321 <literal> make-known push-d
pop-literal
]
}
Unit Test: {
{ t }
[
0 \ <value> set-global [
V{ } clone stack-visitor set
[ foo ] <literal> infer-literal-quot
] with-infer nip V{
T{ #introduce { out-d { 1 } } }
T{ #call
{ word foo }
{ in-d V{ 1 } }
{ out-d { } }
}
T{ #return { in-d V{ } } }
} node-seqs-eq?
]
}
Loading resource:basis/stack-checker/branches/branches-tests.factor
Unit Test: {
{
H{
{ inner-d-index 0 }
{ recursive-state T{ recursive-state } }
{ (meta-r) f }
{ input-count 2 }
{ quotation [ 2drop ] }
{ stack-visitor f }
{ literals V{ } }
{ terminated? f }
{ current-word f }
{ (meta-d) V{ } }
}
}
[
init-inference H{ } clone known-values set
[ 2drop ] <literal> make-known push-d
pop-d known infer-branch
]
}
Loading resource:basis/stack-checker/known-words/known-words-tests.factor
Unit Test: {
{ t }
[
0 \ <value> set-global [
V{ } clone stack-visitor set
\ swap "shuffle" word-prop infer-shuffle
] with-infer nip V{
T{ #introduce { out-d { 1 2 } } }
T{ #shuffle
{ mapping { { 3 2 } { 4 1 } } }
{ in-d V{ 1 2 } }
{ out-d V{ 3 4 } }
}
T{ #return { in-d V{ 3 4 } } }
} node-seqs-eq?
]
}
Unit Test: {
{ t }
[
0 \ <value> set-global [
V{ } clone stack-visitor set 1234 T{ literal-tuple
{ value [ foo ] }
{ recursion T{ recursive-state } }
} infer-call*
] with-infer nip V{
T{ #shuffle
{ mapping { } }
{ in-d { 1234 } }
{ out-d { } }
}
T{ #introduce { out-d { 1 } } }
T{ #call
{ word foo }
{ in-d V{ 1 } }
{ out-d { } }
}
T{ #return { in-d V{ } } }
} node-seqs-eq?
]
}
Loading resource:basis/stack-checker/state/state-tests.factor
Unit Test: {
{ V{ 1 2 3 } }
[
0 \ <value> set-global init-inference
H{ } clone known-values set V{ 1 2 3 } literals set
commit-literals (meta-d) get
]
}
Unit Test: {
{ t t }
[
23 \ <value> set-global [
V{ } clone stack-visitor set 33 (push-literal)
known-values get 24 of value>> 33 =
] with-infer nip V{
T{ #push { literal 33 } { out-d { 24 } } }
T{ #return { in-d V{ 24 } } }
} node-seqs-eq?
]
}
Unit Test: {
{ t }
[
0 \ <value> set-global V{ } clone stack-visitor set
V{ [ call ] } literals set
commit-literals stack-visitor get
V{ T{ #push { literal [ call ] } { out-d { 1 } } } }
node-seqs-eq?
]
}
Loading resource:basis/stack-checker/transforms/transforms-tests.factor
Unit Test: { { 6 } [ 1 2 3 compose-n-test ] }
Must Infer As: { { 1 3 } [ cleave-test ] }
Unit Test: { { 1 2 3 } [ 1 2 3 <color> cleave-test ] }
Unit Test: { { 1 2 3 } [ 1 2 3 <color> \ cleave-test def>> call ] }
Unit Test: { { { 1 2 } 3 -1 } [ 1 2 2cleave-test ] }
Unit Test: { { { 1 2 } 3 -1 } [ 1 2 \ 2cleave-test def>> call ] }
Unit Test: { { 16 -3 1/6 } [ 4 3 6 spread-test ] }
Unit Test: { { 16 -3 1/6 } [ 4 3 6 \ spread-test def>> call ] }
Must Infer: { [ fixnum instance? ] }
Must Infer: { [ bad-new-test ] }
Must Fail: { [ bad-new-test ] }
Must Infer: { [ [ "a" "b" "c" ] smart-combo ] }
Must Infer: { [ [ [ "a" "b" ] smart-combo "c" ] smart-combo ] }
Must Infer: { [ [ "a" "b" "c" ] very-smart-combo ] }
Must Infer: { [ [ [ "a" "b" ] very-smart-combo "c" ] very-smart-combo ] }
Must Infer As: { { 3 0 } [ [ 1 2 3 ] curry-folding-test ] }
Must Infer As: { { 3 0 } [ 1 [ 2 3 ] curry curry-folding-test ] }
Must Infer As: { { 3 0 } [ [ 1 2 ] 3 [ ] curry compose curry-folding-test ] }
Must Fail With: {
[ [ curry curry-folding-test ] infer ]
[ T{ unknown-macro-input { macro curry-folding-test } } = ]
}
Unit Test: { { f } [ 1.0 member?-test ] }
Unit Test: { { t } [ \ member?-test def>> first [ member?-test ] all? ] }
Must Fail With: {
[ [ bad-macro ] infer ]
[
[ transform-expansion-error? ] [ error>> "OOPS" = ]
[ word>> \ bad-macro = ] tri and and
]
}
Must Fail With: {
[ [ 3 two-params ] infer ]
[ T{ unknown-macro-input { macro two-params } } = ]
}
Loading resource:basis/stack-checker/values/values-tests.factor
Unit Test: {
{ T{ foo-tup { a 10 } { b 20 } } }
[
H{ } clone known-values set 0 \ <value> set-global
V{ } clone literals set 10 20 foo-tup boa 23 set-known
23 known
]
}
Unit Test: {
{ T{ foo-tup { a 10 } { b 20 } } }
[
H{ } clone known-values set 0 \ <value> set-global
V{ } clone literals set 10 20 foo-tup boa
<literal> make-known literal value>>
]
}
Unit Test: {
{ H{ { 3 input-parameter } } }
[
H{ } clone known-values set input-parameter 3 set-known
known-values get
]
}
Loading resource:basis/strings/tables/tables-tests.factor
Unit Test: { { { } } [ { } format-table ] }
Unit Test: {
{ { "A BB" "CC D" } }
[ { { "A" "BB" } { "CC" "D" } } format-table ]
}
Unit Test: {
{ { "A C" "B " "D E" } }
[ { { "A\nB" "C" } { "D" "E" } } format-table ]
}
Unit Test: {
{ { "A B" " C" "D E" } }
[ { { "A" "B\nC" } { "D" "E" } } format-table ]
}
Unit Test: {
{ { "A B" "C D" " E" } }
[ { { "A" "B" } { "C" "D\nE" } } format-table ]
}
Unit Test: {
{
{
"┌───┬───┐"
"│ A │ B │"
"├───┼───┤"
"│ C │ D │"
"└───┴───┘"
}
}
[ { { "A" "B" } { "C" "D" } } format-box ]
}
Loading resource:basis/suffix-arrays/suffix-arrays-tests.factor
Unit Test: {
{ }
[
{
"run-tests"
"must-fail-with"
"test-all"
"short-effect"
"failure"
"test"
"<failure>"
"this-test"
"(unit-test)"
"unit-test"
} >suffix-array "suffix-array" set
]
}
Unit Test: { { t } [ "suffix-array" get "" swap query empty? not ] }
Unit Test: { { { } } [ { } "something" swap query ] }
Unit Test: {
{ { "unit-test" "(unit-test)" } }
[ "suffix-array" get "unit-test" swap query ]
}
Unit Test: {
{ t }
[ "suffix-array" get "something else" swap query empty? ]
}
Unit Test: {
{ { "rofl" } }
[
{
T{ slice { from 2 } { to 4 } { seq "rofl" } }
T{ slice { from 3 } { to 4 } { seq "rofl" } }
T{ slice { from 1 } { to 4 } { seq "rofl" } }
T{ slice { to 4 } { seq "rofl" } }
} "r" swap query
]
}
Unit Test: {
{ { "rofl" } }
[
{
T{ slice { from 2 } { to 4 } { seq "rofl" } }
T{ slice { from 3 } { to 4 } { seq "rofl" } }
T{ slice { from 1 } { to 4 } { seq "rofl" } }
T{ slice { to 4 } { seq "rofl" } }
} "o" swap query
]
}
Unit Test: {
{ { "rofl" } }
[
{
T{ slice { from 2 } { to 4 } { seq "rofl" } }
T{ slice { from 3 } { to 4 } { seq "rofl" } }
T{ slice { from 1 } { to 4 } { seq "rofl" } }
T{ slice { to 4 } { seq "rofl" } }
} "f" swap query
]
}
Unit Test: {
{ { "rofl" } }
[
{
T{ slice { from 2 } { to 4 } { seq "rofl" } }
T{ slice { from 3 } { to 4 } { seq "rofl" } }
T{ slice { from 1 } { to 4 } { seq "rofl" } }
T{ slice { to 4 } { seq "rofl" } }
} "l" swap query
]
}
Unit Test: {
{ { } }
[
{
T{ slice { from 2 } { to 4 } { seq "rofl" } }
T{ slice { from 3 } { to 4 } { seq "rofl" } }
T{ slice { from 1 } { to 4 } { seq "rofl" } }
T{ slice { to 4 } { seq "rofl" } }
} "t" swap query
]
}
Loading resource:basis/syndication/syndication-tests.factor
Unit Test: {
{
T{ feed
{ title "Meerkat" }
{ url URL" http://meerkat.oreillynet.com/" }
{ entries
{
T{ entry
{ title "XML: A Disruptive Technology" }
{ url
URL" http://c.moreover.com/click/here.pl?r123"
}
{ description
"\n XML is placing increasingly heavy loads on the existing technical\n infrastructure of the Internet.\n "
}
}
}
}
}
}
[ "vocab:syndication/test/rss1.xml" load-news-file ]
}
Unit Test: {
{
T{ feed
{ title "dive into mark" }
{ url URL" http://example.org/" }
{ entries
{
T{ entry
{ title "Atom draft-07 snapshot" }
{ url
URL" http://example.org/2005/04/02/atom"
}
{ description
"\n <div xmlns=\"http://www.w3.org/1999/xhtml\">\n <p><i>[Update: The Atom draft is finished.]</i></p>\n </div>\n "
}
{ date
T{ timestamp
{ year 2003 }
{ month 12 }
{ day 13 }
{ hour 8 }
{ minute 29 }
{ second 29 }
{ gmt-offset ~duration~ }
}
}
}
}
}
}
}
[ "vocab:syndication/test/atom.xml" load-news-file ]
}
Unit Test: {
{ t }
[
"vocab:syndication/test/atom.xml" load-news-file dup
feed>xml xml>feed =
]
}
Loading resource:basis/system-info/windows/windows-tests.factor
Unit Test: { { t } [ cpus integer? ] }
Unit Test: { { t } [ username string? ] }
Launcher error:
Process was killed as a result of a call to
kill-process, or a timeout
Launch descriptor:
T{ process
{ command
{
"C:\\Users\\jbenedik/builds32/2024-04-25-18-49/factor/factor.com"
"-run=mason.test"
}
}
{ environment H{ } }
{ environment-mode +append-environment+ }
{ stdin +closed+ }
{ stdout "../test-log" }
{ stderr +stdout+ }
{ group +new-group+ }
{ timeout T{ duration { hour 2 } } }
{ status 255 }
{ killed t }
}