Menu
▾
▴
[Factor-builds] mason on linux-x86-64: 8657a56 -- error
|
From: <fac...@gm...> - 2022-01-23 00:23:05
|
<div><h1>Build report for linux/x86.64</h1>
<table>
<tr><td>Build machine:</td><td>ubuntu</td></tr>
<tr><td>Disk usage:</td><td>29.71Gi used, 62.27Gi avail, 96.95Gi total, 64.23% free</td></tr>
<tr><td>Build directory:</td><td>/home/erg/builds/2022-01-22-15-29</td></tr>
<tr><td>GIT ID:</td><td><a href="http://github.com/factor/factor/commit/8657a568bb822c56d28063cab394094270cf71f9">8657a568bb822c56d28063cab394094270cf71f9</a></td></tr>
</table><h2>Tests failed</h2>
Build output:
<pre>Unit Test: {
[ ]
[
20 [ random-op ] [ ] replicate-as
[ infer in>> length [ random-class ] times ] keep call
drop
]
}
Unit Test: {
[ ]
[
20 [ random-op ] [ ] replicate-as
[ infer in>> length [ random-class ] times ] keep call
drop
]
}
Unit Test: {
[ ]
[
20 [ random-op ] [ ] replicate-as
[ infer in>> length [ random-class ] times ] keep call
drop
]
}
Unit Test: {
[ ]
[
20 [ random-op ] [ ] replicate-as
[ infer in>> length [ random-class ] times ] keep call
drop
]
}
Unit Test: {
[ ]
[
20 [ random-op ] [ ] replicate-as
[ infer in>> length [ random-class ] times ] keep call
drop
]
}
Unit Test: {
[ ]
[
20 [ random-op ] [ ] replicate-as
[ infer in>> length [ random-class ] times ] keep call
drop
]
}
Unit Test: {
[ ]
[
20 [ random-op ] [ ] replicate-as
[ infer in>> length [ random-class ] times ] keep call
drop
]
}
Unit Test: {
[ ]
[
20 [ random-op ] [ ] replicate-as
[ infer in>> length [ random-class ] times ] keep call
drop
]
}
Unit Test: {
[ ]
[
20 [ random-op ] [ ] replicate-as
[ infer in>> length [ random-class ] times ] keep call
drop
]
}
Unit Test: {
[ ]
[
20 [ random-op ] [ ] replicate-as
[ infer in>> length [ random-class ] times ] keep call
drop
]
}
Unit Test: {
[ t ]
[
20 [ random-boolean-op ] [ ] replicate-as dup .
[ infer in>> length [ random-boolean ] replicate dup . ]
keep [ [ [ ] each ] dip call ] 2keep
[ [ boolean>class ] each ] dip
[ boolean-op>class-op ] map call object class= =
]
}
[
and not and not or xor xor not and not xor not xor xor or or
not or xor not
]
{ t f t t t t t t t f f f f t }
Unit Test: {
[ t ]
[
20 [ random-boolean-op ] [ ] replicate-as dup .
[ infer in>> length [ random-boolean ] replicate dup . ]
keep [ [ [ ] each ] dip call ] 2keep
[ [ boolean>class ] each ] dip
[ boolean-op>class-op ] map call object class= =
]
}
[
and not not xor not and not or and xor xor not and or and
xor xor not not and
]
{ t t t f f f f t t t f f t f }
Unit Test: {
[ t ]
[
20 [ random-boolean-op ] [ ] replicate-as dup .
[ infer in>> length [ random-boolean ] replicate dup . ]
keep [ [ [ ] each ] dip call ] 2keep
[ [ boolean>class ] each ] dip
[ boolean-op>class-op ] map call object class= =
]
}
[
and not or not and or and or xor xor and xor not xor
not not not xor xor and
]
{ t f f f t t f f t f f t f f f }
Unit Test: {
[ t ]
[
20 [ random-boolean-op ] [ ] replicate-as dup .
[ infer in>> length [ random-boolean ] replicate dup . ]
keep [ [ [ ] each ] dip call ] 2keep
[ [ boolean>class ] each ] dip
[ boolean-op>class-op ] map call object class= =
]
}
[
xor not or not or and and and and or or or not and and or
not xor or or
]
{ t f t t f t f f f f t t t t t f t }
Unit Test: {
[ t ]
[
20 [ random-boolean-op ] [ ] replicate-as dup .
[ infer in>> length [ random-boolean ] replicate dup . ]
keep [ [ [ ] each ] dip call ] 2keep
[ [ boolean>class ] each ] dip
[ boolean-op>class-op ] map call object class= =
]
}
[
or not xor xor xor not xor not not not not xor and or and or
or not or not
]
{ t f f f t f f t t f t t t }
Unit Test: {
[ t ]
[
20 [ random-boolean-op ] [ ] replicate-as dup .
[ infer in>> length [ random-boolean ] replicate dup . ]
keep [ [ [ ] each ] dip call ] 2keep
[ [ boolean>class ] each ] dip
[ boolean-op>class-op ] map call object class= =
]
}
[
xor and not or or and not not or xor and and not xor xor and
and and or and
]
{ t f t t f t f f f f f f f t f f t }
Unit Test: {
[ t ]
[
20 [ random-boolean-op ] [ ] replicate-as dup .
[ infer in>> length [ random-boolean ] replicate dup . ]
keep [ [ [ ] each ] dip call ] 2keep
[ [ boolean>class ] each ] dip
[ boolean-op>class-op ] map call object class= =
]
}
[
not xor not and xor or and not xor or and not or and or or
not xor or or
]
{ t t f t t f f t t f f f t t f f }
Unit Test: {
[ t ]
[
20 [ random-boolean-op ] [ ] replicate-as dup .
[ infer in>> length [ random-boolean ] replicate dup . ]
keep [ [ [ ] each ] dip call ] 2keep
[ [ boolean>class ] each ] dip
[ boolean-op>class-op ] map call object class= =
]
}
[
and and not and or not or xor and not or or and and xor and
not and or not
]
{ f f f f f t f f t f f t f t f t }
Unit Test: {
[ t ]
[
20 [ random-boolean-op ] [ ] replicate-as dup .
[ infer in>> length [ random-boolean ] replicate dup . ]
keep [ [ [ ] each ] dip call ] 2keep
[ [ boolean>class ] each ] dip
[ boolean-op>class-op ] map call object class= =
]
}
[
xor and or xor not or and and or not or and and xor xor xor
or or xor or
]
{ f f f f f t f t t t f f t t f t f f f }
Unit Test: {
[ t ]
[
20 [ random-boolean-op ] [ ] replicate-as dup .
[ infer in>> length [ random-boolean ] replicate dup . ]
keep [ [ [ ] each ] dip call ] 2keep
[ [ boolean>class ] each ] dip
[ boolean-op>class-op ] map call object class= =
]
}
[
not not not not not not or or and or and not xor or and and
xor or and and
]
{ f f t f f f f t t f t f f f }
Unit Test: {
[ t ]
[
20 [ random-boolean-op ] [ ] replicate-as dup .
[ infer in>> length [ random-boolean ] replicate dup . ]
keep [ [ [ ] each ] dip call ] 2keep
[ [ boolean>class ] each ] dip
[ boolean-op>class-op ] map call object class= =
]
}
[
and and xor xor and xor not or and not or and not not xor
not and xor not xor
]
{ t f t t f t t t t f f f t t f }
Unit Test: {
[ t ]
[
20 [ random-boolean-op ] [ ] replicate-as dup .
[ infer in>> length [ random-boolean ] replicate dup . ]
keep [ [ [ ] each ] dip call ] 2keep
[ [ boolean>class ] each ] dip
[ boolean-op>class-op ] map call object class= =
]
}
[
not xor xor not xor and and not xor not not and and xor
not and not and or xor
]
{ t f f f f f f f f f f f f t }
Unit Test: {
[ t ]
[
20 [ random-boolean-op ] [ ] replicate-as dup .
[ infer in>> length [ random-boolean ] replicate dup . ]
keep [ [ [ ] each ] dip call ] 2keep
[ [ boolean>class ] each ] dip
[ boolean-op>class-op ] map call object class= =
]
}
[
and not or xor or or not xor xor xor xor and or and and and
or not not xor
]
{ t f f f t t f t t t t f f t t f f }
Unit Test: {
[ t ]
[
20 [ random-boolean-op ] [ ] replicate-as dup .
[ infer in>> length [ random-boolean ] replicate dup . ]
keep [ [ [ ] each ] dip call ] 2keep
[ [ boolean>class ] each ] dip
[ boolean-op>class-op ] map call object class= =
]
}
[
and or and and not and or xor and or xor xor not and xor xor
xor and xor or
]
{ f t t t f t f f f t f t f t f t f f f }
Unit Test: {
[ t ]
[
20 [ random-boolean-op ] [ ] replicate-as dup .
[ infer in>> length [ random-boolean ] replicate dup . ]
keep [ [ [ ] each ] dip call ] 2keep
[ [ boolean>class ] each ] dip
[ boolean-op>class-op ] map call object class= =
]
}
[
and and and or and or and xor xor or and or or or
not not and not xor or
]
{ t f f t f t f f f f t f f t f t f t }
Unit Test: {
[ t ]
[
20 [ random-boolean-op ] [ ] replicate-as dup .
[ infer in>> length [ random-boolean ] replicate dup . ]
keep [ [ [ ] each ] dip call ] 2keep
[ [ boolean>class ] each ] dip
[ boolean-op>class-op ] map call object class= =
]
}
[
not or or or xor and not or not not and or not and
not not not and xor not
]
{ t f t f f t f t f t t t }
Unit Test: {
[ t ]
[
20 [ random-boolean-op ] [ ] replicate-as dup .
[ infer in>> length [ random-boolean ] replicate dup . ]
keep [ [ [ ] each ] dip call ] 2keep
[ [ boolean>class ] each ] dip
[ boolean-op>class-op ] map call object class= =
]
}
[
not xor not or or not xor or not xor or not or not or or or
or or and
]
{ t f f f t f f t f t f t f t f }
Unit Test: {
[ t ]
[
20 [ random-boolean-op ] [ ] replicate-as dup .
[ infer in>> length [ random-boolean ] replicate dup . ]
keep [ [ [ ] each ] dip call ] 2keep
[ [ boolean>class ] each ] dip
[ boolean-op>class-op ] map call object class= =
]
}
[
not xor and not not xor xor and not and xor xor xor not and
and and xor and and
]
{ f t f f t f f f f f f f f f f f }
Unit Test: {
[ t ]
[
20 [ random-boolean-op ] [ ] replicate-as dup .
[ infer in>> length [ random-boolean ] replicate dup . ]
keep [ [ [ ] each ] dip call ] 2keep
[ [ boolean>class ] each ] dip
[ boolean-op>class-op ] map call object class= =
]
}
[
and xor or or not not not or xor or xor or and xor xor and
not and xor not
]
{ f t f t t t t t f t t f t f f t }
Unit Test: {
[ t ]
[
20 [ random-boolean-op ] [ ] replicate-as dup .
[ infer in>> length [ random-boolean ] replicate dup . ]
keep [ [ [ ] each ] dip call ] 2keep
[ [ boolean>class ] each ] dip
[ boolean-op>class-op ] map call object class= =
]
}
[
or not xor and or xor or xor or not not not not not not xor
or xor not not
]
{ t t t t f f f t f t t t }
Unit Test: { { { yyy xxx } } [ { xxx yyy } sort-classes ] }
Unit Test: { { { yyy xxx } } [ { yyy xxx } sort-classes ] }
Unit Test: {
{ { number ratio integer } }
[ { ratio number integer } sort-classes ]
}
Unit Test: {
{ { sequence number ratio } }
[ { ratio number sequence } sort-classes ]
}
Unit Test: {
{ t }
[
{ xa xb xc xd xe xf xg xh } sort-classes dup
sort-classes =
]
}
Unit Test: { { { word } } [ generic-class flatten-class ] }
Unit Test: { { sa } [ sa { sa sb sc } min-class ] }
Must Fail: { [ \ + flatten-class ] }</pre>
Launcher error:
<pre>Process exited with error code T{ signal { n 9 } }
Launch descriptor:
T{ process
{ command { "./factor" "-run=mason.test" } }
{ environment H{ } }
{ environment-mode +append-environment+ }
{ stdin +closed+ }
{ stdout "../test-log" }
{ stderr +stdout+ }
{ group +new-group+ }
{ timeout T{ duration { hour 6 } } }
{ status T{ signal { n 9 } } }
}
</pre></div> |
