1-LastTest.log

1-LastTest.log (text/plain), 142.59 KB, created by Agostino Sarubbo on 2022-12-18 10:28:08 UTC

Start testing: Dec 18 08:24 CET
----------------------------------------------------------
1/5 Testing: kj-tests-run
1/5 Test: kj-tests-run
Command: "/var/tmp/portage/dev-libs/capnproto-0.10.2/work/capnproto-0.10.2/c++_build/src/kj/kj-tests"
Directory: /var/tmp/portage/dev-libs/capnproto-0.10.2/work/capnproto-0.10.2/c++_build/src/kj
"kj-tests-run" start time: Dec 18 08:24 CET
Output:
----------------------------------------------------------
[ TEST ] common-test.c++:30: kj::size() on native arrays
[ PASS ] common-test.c++:30: kj::size() on native arrays (3 μs)
[ TEST ] common-test.c++:62: legacy test: Common/Maybe
[ PASS ] common-test.c++:62: legacy test: Common/Maybe (2 μs)
[ TEST ] common-test.c++:434: legacy test: Common/MaybeConstness
[ PASS ] common-test.c++:434: legacy test: Common/MaybeConstness (0 μs)
[ TEST ] common-test.c++:459: legacy test: Common/MaybeUnwrapOrReturn
[ PASS ] common-test.c++:459: legacy test: Common/MaybeUnwrapOrReturn (2 μs)
[ TEST ] common-test.c++:570: legacy test: Common/Downcast
[ PASS ] common-test.c++:570: legacy test: Common/Downcast (1 μs)
[ TEST ] common-test.c++:592: legacy test: Common/MinMax
[ PASS ] common-test.c++:592: legacy test: Common/MinMax (0 μs)
[ TEST ] common-test.c++:612: legacy test: Common/MinMaxValue
[ PASS ] common-test.c++:612: legacy test: Common/MinMaxValue (0 μs)
[ TEST ] common-test.c++:642: legacy test: Common/Defer
[ PASS ] common-test.c++:642: legacy test: Common/Defer (0 μs)
[ TEST ] common-test.c++:660: legacy test: Common/CanConvert
[ PASS ] common-test.c++:660: legacy test: Common/CanConvert (0 μs)
[ TEST ] common-test.c++:676: legacy test: Common/ArrayAsBytes
[ PASS ] common-test.c++:676: legacy test: Common/ArrayAsBytes (0 μs)
[ TEST ] common-test.c++:795: ArrayPtr operator ==
[ PASS ] common-test.c++:795: ArrayPtr operator == (0 μs)
[ TEST ] common-test.c++:816: kj::range()
[ PASS ] common-test.c++:816: kj::range() (0 μs)
[ TEST ] common-test.c++:830: kj::defer()
[ PASS ] common-test.c++:830: kj::defer() (0 μs)
[ TEST ] memory-test.c++:29: legacy test: Memory/OwnConst
[ PASS ] memory-test.c++:29: legacy test: Memory/OwnConst (3 μs)
[ TEST ] memory-test.c++:40: legacy test: Memory/CanConvert
[ PASS ] memory-test.c++:40: legacy test: Memory/CanConvert (0 μs)
[ TEST ] memory-test.c++:56: legacy test: Memory/AssignNested
[ PASS ] memory-test.c++:56: legacy test: Memory/AssignNested (0 μs)
[ TEST ] memory-test.c++:79: legacy test: Memory/Attach
[ PASS ] memory-test.c++:79: legacy test: Memory/Attach (0 μs)
[ TEST ] memory-test.c++:109: legacy test: Memory/AttachNested
[ PASS ] memory-test.c++:109: legacy test: Memory/AttachNested (0 μs)
[ TEST ] memory-test.c++:139: attachRef
[ PASS ] memory-test.c++:139: attachRef (0 μs)
[ TEST ] memory-test.c++:169: attachVal
[ PASS ] memory-test.c++:169: attachVal (0 μs)
[ TEST ] memory-test.c++:246: legacy test: Memory/OwnVoid
[ PASS ] memory-test.c++:246: legacy test: Memory/OwnVoid (0 μs)
[ TEST ] memory-test.c++:300: legacy test: Memory/OwnConstVoid
[ PASS ] memory-test.c++:300: legacy test: Memory/OwnConstVoid (0 μs)
[ TEST ] memory-test.c++:370: Own<IncompleteType>
[ PASS ] memory-test.c++:370: Own<IncompleteType> (0 μs)
[ TEST ] array-test.c++:90: legacy test: Array/TrivialConstructor
[ PASS ] array-test.c++:90: legacy test: Array/TrivialConstructor (1 μs)
[ TEST ] array-test.c++:114: legacy test: Array/ComplexConstructor
[ PASS ] array-test.c++:114: legacy test: Array/ComplexConstructor (1 μs)
[ TEST ] array-test.c++:126: legacy test: Array/ThrowingConstructor
[ PASS ] array-test.c++:126: legacy test: Array/ThrowingConstructor (72 μs)
[ TEST ] array-test.c++:135: legacy test: Array/ThrowingDestructor
[ PASS ] array-test.c++:135: legacy test: Array/ThrowingDestructor (17 μs)
[ TEST ] array-test.c++:149: legacy test: Array/AraryBuilder
[ PASS ] array-test.c++:149: legacy test: Array/AraryBuilder (0 μs)
[ TEST ] array-test.c++:173: legacy test: Array/AraryBuilderAddAll
[ PASS ] array-test.c++:173: legacy test: Array/AraryBuilderAddAll (20 μs)
[ TEST ] array-test.c++:290: legacy test: Array/HeapCopy
[ PASS ] array-test.c++:290: legacy test: Array/HeapCopy (0 μs)
[ TEST ] array-test.c++:309: legacy test: Array/OwnConst
[ PASS ] array-test.c++:309: legacy test: Array/OwnConst (0 μs)
[ TEST ] array-test.c++:330: legacy test: Array/Map
[ PASS ] array-test.c++:330: legacy test: Array/Map (0 μs)
[ TEST ] array-test.c++:336: legacy test: Array/MapRawArray
[ PASS ] array-test.c++:336: legacy test: Array/MapRawArray (0 μs)
[ TEST ] array-test.c++:346: legacy test: Array/ReleaseAsBytesOrChars
[ PASS ] array-test.c++:346: legacy test: Array/ReleaseAsBytesOrChars (0 μs)
[ TEST ] array-test.c++:382: kj::arr()
[ PASS ] array-test.c++:382: kj::arr() (0 μs)
[ TEST ] array-test.c++:393: kj::arrOf()
[ PASS ] array-test.c++:393: kj::arrOf() (0 μs)
[ TEST ] array-test.c++:413: legacy test: Array/Attach
[ PASS ] array-test.c++:413: legacy test: Array/Attach (0 μs)
[ TEST ] array-test.c++:446: legacy test: Array/AttachNested
[ PASS ] array-test.c++:446: legacy test: Array/AttachNested (0 μs)
[ TEST ] array-test.c++:480: legacy test: Array/AttachFromArrayPtr
[ PASS ] array-test.c++:480: legacy test: Array/AttachFromArrayPtr (0 μs)
[ TEST ] list-test.c++:35: List
[ PASS ] list-test.c++:35: List (0 μs)
[ TEST ] list-test.c++:119: List remove while iterating
[ PASS ] list-test.c++:119: List remove while iterating (0 μs)
[ TEST ] string-test.c++:32: legacy test: String/Str
[ PASS ] string-test.c++:32: legacy test: String/Str (26 μs)
[ TEST ] string-test.c++:64: legacy test: String/Nullptr
[ PASS ] string-test.c++:64: legacy test: String/Nullptr (0 μs)
[ TEST ] string-test.c++:70: legacy test: String/StartsEndsWith
[ PASS ] string-test.c++:70: legacy test: String/StartsEndsWith (0 μs)
[ TEST ] string-test.c++:83: legacy test: String/parseAs
[ PASS ] string-test.c++:83: legacy test: String/parseAs (225 μs)
[ TEST ] string-test.c++:168: legacy test: String/StlInterop
[ PASS ] string-test.c++:168: legacy test: String/StlInterop (0 μs)
[ TEST ] string-test.c++:184: legacy test: String/ToString
[ PASS ] string-test.c++:184: legacy test: String/ToString (0 μs)
[ TEST ] string-test.c++:189: string literals with _kj suffix
[ PASS ] string-test.c++:189: string literals with _kj suffix (0 μs)
[ TEST ] string-test.c++:201: kj::delimited() and kj::strPreallocated()
[ PASS ] string-test.c++:201: kj::delimited() and kj::strPreallocated() (4 μs)
[ TEST ] string-test.c++:220: parsing 'nan' returns canonical NaN value
[ PASS ] string-test.c++:220: parsing 'nan' returns canonical NaN value (0 μs)
[ TEST ] string-test.c++:235: stringify array-of-array
[ PASS ] string-test.c++:235: stringify array-of-array (0 μs)
[ TEST ] string-test.c++:244: ArrayPtr == StringPtr
[ PASS ] string-test.c++:244: ArrayPtr == StringPtr (0 μs)
[ TEST ] string-test.c++:254: String == String
[ PASS ] string-test.c++:254: String == String (0 μs)
[ TEST ] string-test.c++:269: float stringification and parsing is not locale-dependent
kj/string-test.c++:288: Couldn't set locale to es_ES. Skipping this test.
[ PASS ] string-test.c++:269: float stringification and parsing is not locale-dependent (48 μs)
[ TEST ] table-test.c++:46: _::tryReserveSize() works
[ PASS ] table-test.c++:46: _::tryReserveSize() works (0 μs)
[ TEST ] table-test.c++:71: simple table
[ PASS ] table-test.c++:71: simple table (28 μs)
[ TEST ] table-test.c++:203: hash tables when hash is always same
[ PASS ] table-test.c++:203: hash tables when hash is always same (15 μs)
[ TEST ] table-test.c++:285: HashIndex with many erasures doesn't keep growing
[ PASS ] table-test.c++:285: HashIndex with many erasures doesn't keep growing (21373 μs)
[ TEST ] table-test.c++:334: double-index table
[ PASS ] table-test.c++:334: double-index table (40 μs)
[ TEST ] table-test.c++:412: benchmark: kj::Table<uint, HashIndex>
[ PASS ] table-test.c++:412: benchmark: kj::Table<uint, HashIndex> (34610 μs)
[ TEST ] table-test.c++:448: benchmark: std::unordered_set<uint>
[ PASS ] table-test.c++:448: benchmark: std::unordered_set<uint> (39386 μs)
[ TEST ] table-test.c++:488: benchmark: kj::Table<StringPtr, HashIndex>
[ PASS ] table-test.c++:488: benchmark: kj::Table<StringPtr, HashIndex> (87139 μs)
[ TEST ] table-test.c++:533: benchmark: std::unordered_set<StringPtr>
[ PASS ] table-test.c++:533: benchmark: std::unordered_set<StringPtr> (132090 μs)
[ TEST ] table-test.c++:578: B-tree internals
[ PASS ] table-test.c++:578: B-tree internals (0 μs)
[ TEST ] table-test.c++:666: simple tree table
[ PASS ] table-test.c++:666: simple tree table (40 μs)
[ TEST ] table-test.c++:858: large tree table
[ PASS ] table-test.c++:858: large tree table (509577 μs)
[ TEST ] table-test.c++:912: TreeIndex fuzz test
[ PASS ] table-test.c++:912: TreeIndex fuzz test (1507 μs)
[ TEST ] table-test.c++:975: TreeIndex clear() leaves tree in valid state
[ PASS ] table-test.c++:975: TreeIndex clear() leaves tree in valid state (3 μs)
[ TEST ] table-test.c++:996: benchmark: kj::Table<uint, TreeIndex>
[ PASS ] table-test.c++:996: benchmark: kj::Table<uint, TreeIndex> (339333 μs)
[ TEST ] table-test.c++:1033: benchmark: std::set<uint>
[ PASS ] table-test.c++:1033: benchmark: std::set<uint> (168536 μs)
[ TEST ] table-test.c++:1073: benchmark: kj::Table<StringPtr, TreeIndex>
[ PASS ] table-test.c++:1073: benchmark: kj::Table<StringPtr, TreeIndex> (599060 μs)
[ TEST ] table-test.c++:1113: benchmark: std::set<StringPtr>
[ PASS ] table-test.c++:1113: benchmark: std::set<StringPtr> (345527 μs)
[ TEST ] table-test.c++:1158: insertion order index
[ PASS ] table-test.c++:1158: insertion order index (10 μs)
[ TEST ] table-test.c++:1260: insertion order index is movable
[ PASS ] table-test.c++:1260: insertion order index is movable (1 μs)
[ TEST ] table-test.c++:1344: HashIndex rollback on insertion failure
[ PASS ] table-test.c++:1344: HashIndex rollback on insertion failure (2 μs)
[ TEST ] table-test.c++:1376: TreeIndex rollback on insertion failure
[ PASS ] table-test.c++:1376: TreeIndex rollback on insertion failure (3 μs)
[ TEST ] map-test.c++:29: HashMap
[ PASS ] map-test.c++:29: HashMap (7 μs)
[ TEST ] map-test.c++:70: TreeMap
[ PASS ] map-test.c++:70: TreeMap (3 μs)
[ TEST ] map-test.c++:111: TreeMap range
[ PASS ] map-test.c++:111: TreeMap range (3 μs)
[ TEST ] map-test.c++:152: HashMap findOrCreate throws
[ PASS ] map-test.c++:152: HashMap findOrCreate throws (10 μs)
[ TEST ] map-test.c++:193: HashMap eraseAll
[ PASS ] map-test.c++:193: HashMap eraseAll (0 μs)
[ TEST ] map-test.c++:198: TreeMap eraseAll
[ PASS ] map-test.c++:198: TreeMap eraseAll (1 μs)
[ TEST ] exception-test.c++:32: legacy test: Exception/TrimSourceFilename
[ PASS ] exception-test.c++:32: legacy test: Exception/TrimSourceFilename (1 μs)
[ TEST ] exception-test.c++:41: legacy test: Exception/RunCatchingExceptions
[ PASS ] exception-test.c++:41: legacy test: Exception/RunCatchingExceptions (19 μs)
[ TEST ] exception-test.c++:64: legacy test: Exception/RunCatchingExceptionsStdException
[ PASS ] exception-test.c++:64: legacy test: Exception/RunCatchingExceptionsStdException (14 μs)
[ TEST ] exception-test.c++:76: legacy test: Exception/RunCatchingExceptionsOtherException
[ PASS ] exception-test.c++:76: legacy test: Exception/RunCatchingExceptionsOtherException (8 μs)
[ TEST ] exception-test.c++:107: legacy test: Exception/UnwindDetector
[ PASS ] exception-test.c++:107: legacy test: Exception/UnwindDetector (38 μs)
[ TEST ] exception-test.c++:141: legacy test: Exception/ExceptionCallbackMustBeOnStack
[ PASS ] exception-test.c++:141: legacy test: Exception/ExceptionCallbackMustBeOnStack (14 μs)
[ TEST ] exception-test.c++:148: legacy test: Exception/ScopeSuccessFail
[ PASS ] exception-test.c++:148: legacy test: Exception/ScopeSuccessFail (2 μs)
[ TEST ] exception-test.c++:192: getStackTrace() returns correct line number, not line + 1
[ PASS ] exception-test.c++:192: getStackTrace() returns correct line number, not line + 1 (9 μs)
[ TEST ] exception-test.c++:218: InFlightExceptionIterator works
[ PASS ] exception-test.c++:218: InFlightExceptionIterator works (13 μs)
[ TEST ] exception-test.c++:252: computeRelativeTrace
[ PASS ] exception-test.c++:252: computeRelativeTrace (2 μs)
[ TEST ] debug-test.c++:211: legacy test: Debug/Log
[ PASS ] debug-test.c++:211: legacy test: Debug/Log (71 μs)
[ TEST ] debug-test.c++:289: legacy test: Debug/Exception
[ PASS ] debug-test.c++:289: legacy test: Debug/Exception (1 μs)
[ TEST ] debug-test.c++:300: legacy test: Debug/Catch
[ PASS ] debug-test.c++:300: legacy test: Debug/Catch (31 μs)
[ TEST ] debug-test.c++:364: legacy test: Debug/Syscall
[ PASS ] debug-test.c++:364: legacy test: Debug/Syscall (48 μs)
[ TEST ] debug-test.c++:420: legacy test: Debug/Context
[ PASS ] debug-test.c++:420: legacy test: Debug/Context (40 μs)
[ TEST ] debug-test.c++:471: magic assert stringification
[ PASS ] debug-test.c++:471: magic assert stringification (61 μs)
[ TEST ] io-test.c++:34: legacy test: Io/WriteVec
[ PASS ] io-test.c++:34: legacy test: Io/WriteVec (15 μs)
[ TEST ] io-test.c++:61: stringify AutoCloseFd
[ PASS ] io-test.c++:61: stringify AutoCloseFd (2 μs)
[ TEST ] io-test.c++:69: VectorOutputStream
[ PASS ] io-test.c++:69: VectorOutputStream (4 μs)
[ TEST ] io-test.c++:141: InputStream::readAllText() / readAllBytes()
[ PASS ] io-test.c++:141: InputStream::readAllText() / readAllBytes() (6010 μs)
[ TEST ] io-test.c++:179: ArrayOutputStream::write() does not assume adjacent write buffer is its own
[ PASS ] io-test.c++:179: ArrayOutputStream::write() does not assume adjacent write buffer is its own (14 μs)
[ TEST ] mutex-test.c++:65: legacy test: Mutex/MutexGuarded
[ PASS ] mutex-test.c++:65: legacy test: Mutex/MutexGuarded (130483 μs)
[ TEST ] mutex-test.c++:169: legacy test: Mutex/When
[ PASS ] mutex-test.c++:169: legacy test: Mutex/When (42572 μs)
[ TEST ] mutex-test.c++:262: legacy test: Mutex/WhenWithTimeout
[ PASS ] mutex-test.c++:262: legacy test: Mutex/WhenWithTimeout (72948 μs)
[ TEST ] mutex-test.c++:391: legacy test: Mutex/WhenWithTimeoutPreciseTiming
[ PASS ] mutex-test.c++:391: legacy test: Mutex/WhenWithTimeoutPreciseTiming (100056 μs)
[ TEST ] mutex-test.c++:422: legacy test: Mutex/WhenWithTimeoutPreciseTimingAfterInterrupt
[ PASS ] mutex-test.c++:422: legacy test: Mutex/WhenWithTimeoutPreciseTimingAfterInterrupt (100077 μs)
[ TEST ] mutex-test.c++:456: wait()s wake each other
[ PASS ] mutex-test.c++:456: wait()s wake each other (78 μs)
[ TEST ] mutex-test.c++:478: legacy test: Mutex/Lazy
[ PASS ] mutex-test.c++:478: legacy test: Mutex/Lazy (10104 μs)
[ TEST ] mutex-test.c++:503: legacy test: Mutex/LazyException
[ PASS ] mutex-test.c++:503: legacy test: Mutex/LazyException (31 μs)
[ TEST ] mutex-test.c++:568: ExternalMutexGuarded<T> destroy after release
[ PASS ] mutex-test.c++:568: ExternalMutexGuarded<T> destroy after release (0 μs)
[ TEST ] mutex-test.c++:597: ExternalMutexGuarded<T> destroy without release
[ PASS ] mutex-test.c++:597: ExternalMutexGuarded<T> destroy without release (0 μs)
[ TEST ] mutex-test.c++:618: condvar wait with flapping predicate
[ PASS ] mutex-test.c++:618: condvar wait with flapping predicate (10097 μs)
[ TEST ] time-test.c++:41: stringify times
[ PASS ] time-test.c++:41: stringify times (5 μs)
[ TEST ] time-test.c++:61: calendar clocks matches unix time
[ PASS ] time-test.c++:61: calendar clocks matches unix time (10 μs)
[ TEST ] time-test.c++:80: monotonic clocks match each other
[ PASS ] time-test.c++:80: monotonic clocks match each other (1 μs)
[ TEST ] time-test.c++:95: all clocks advance in real time
[ PASS ] time-test.c++:95: all clocks advance in real time (150056 μs)
[ TEST ] threadlocal-test.c++:33: legacy test: ThreadLocal/Basic
[ PASS ] threadlocal-test.c++:33: legacy test: ThreadLocal/Basic (46 μs)
[ TEST ] test-test.c++:29: GlobFilter
[ PASS ] test-test.c++:29: GlobFilter (15 μs)
[ TEST ] std/iostream-test.c++:30: legacy test: StdIoStream/WriteVec
[ PASS ] std/iostream-test.c++:30: legacy test: StdIoStream/WriteVec (33 μs)
[ TEST ] std/iostream-test.c++:56: legacy test: StdIoStream/TryReadToEndOfFile
[ PASS ] std/iostream-test.c++:56: legacy test: StdIoStream/TryReadToEndOfFile (3 μs)
[ TEST ] std/iostream-test.c++:75: legacy test: StdIoStream/ReadToEndOfFile
[ PASS ] std/iostream-test.c++:75: legacy test: StdIoStream/ReadToEndOfFile (29 μs)
123 test(s) passed 
<end of output>
Test time =   2.91 sec
----------------------------------------------------------
Test Passed.
"kj-tests-run" end time: Dec 18 08:24 CET
"kj-tests-run" time elapsed: 00:00:02
----------------------------------------------------------

2/5 Testing: kj-heavy-tests-run
2/5 Test: kj-heavy-tests-run
Command: "/var/tmp/portage/dev-libs/capnproto-0.10.2/work/capnproto-0.10.2/c++_build/src/kj/kj-heavy-tests"
Directory: /var/tmp/portage/dev-libs/capnproto-0.10.2/work/capnproto-0.10.2/c++_build/src/kj
"kj-heavy-tests-run" start time: Dec 18 08:24 CET
Output:
----------------------------------------------------------
[ TEST ] async-test.c++:42: legacy test: Async/GetFunctorStartAddress
[ PASS ] async-test.c++:42: legacy test: Async/GetFunctorStartAddress (6 μs)
[ TEST ] async-test.c++:77: legacy test: Async/EvalVoid
[ PASS ] async-test.c++:77: legacy test: Async/EvalVoid (30 μs)
[ TEST ] async-test.c++:89: legacy test: Async/EvalInt
[ PASS ] async-test.c++:89: legacy test: Async/EvalInt (4 μs)
[ TEST ] async-test.c++:101: legacy test: Async/There
[ PASS ] async-test.c++:101: legacy test: Async/There (2 μs)
[ TEST ] async-test.c++:114: legacy test: Async/ThereVoid
[ PASS ] async-test.c++:114: legacy test: Async/ThereVoid (4 μs)
[ TEST ] async-test.c++:127: legacy test: Async/Exception
[ PASS ] async-test.c++:127: legacy test: Async/Exception (94 μs)
[ TEST ] async-test.c++:139: legacy test: Async/HandleException
[ PASS ] async-test.c++:139: legacy test: Async/HandleException (18 μs)
[ TEST ] async-test.c++:154: legacy test: Async/PropagateException
[ PASS ] async-test.c++:154: legacy test: Async/PropagateException (18 μs)
[ TEST ] async-test.c++:171: legacy test: Async/PropagateExceptionTypeChange
[ PASS ] async-test.c++:171: legacy test: Async/PropagateExceptionTypeChange (16 μs)
[ TEST ] async-test.c++:188: legacy test: Async/Then
[ PASS ] async-test.c++:188: legacy test: Async/Then (0 μs)
[ TEST ] async-test.c++:206: legacy test: Async/Chain
[ PASS ] async-test.c++:206: legacy test: Async/Chain (4 μs)
[ TEST ] async-test.c++:222: legacy test: Async/DeepChain
[ PASS ] async-test.c++:222: legacy test: Async/DeepChain (203 μs)
[ TEST ] async-test.c++:248: legacy test: Async/DeepChain2
[ PASS ] async-test.c++:248: legacy test: Async/DeepChain2 (125 μs)
[ TEST ] async-test.c++:285: legacy test: Async/DeepChain3
[ PASS ] async-test.c++:285: legacy test: Async/DeepChain3 (113 μs)
[ TEST ] async-test.c++:314: legacy test: Async/DeepChain4
[ PASS ] async-test.c++:314: legacy test: Async/DeepChain4 (122 μs)
[ TEST ] async-test.c++:336: legacy test: Async/IgnoreResult
[ PASS ] async-test.c++:336: legacy test: Async/IgnoreResult (1 μs)
[ TEST ] async-test.c++:354: legacy test: Async/SeparateFulfiller
[ PASS ] async-test.c++:354: legacy test: Async/SeparateFulfiller (2 μs)
[ TEST ] async-test.c++:367: legacy test: Async/SeparateFulfillerVoid
[ PASS ] async-test.c++:367: legacy test: Async/SeparateFulfillerVoid (1 μs)
[ TEST ] async-test.c++:380: legacy test: Async/SeparateFulfillerCanceled
[ PASS ] async-test.c++:380: legacy test: Async/SeparateFulfillerCanceled (0 μs)
[ TEST ] async-test.c++:388: legacy test: Async/SeparateFulfillerChained
[ PASS ] async-test.c++:388: legacy test: Async/SeparateFulfillerChained (2 μs)
[ TEST ] async-test.c++:404: legacy test: Async/SeparateFulfillerDiscarded
[ PASS ] async-test.c++:404: legacy test: Async/SeparateFulfillerDiscarded (23 μs)
[ TEST ] async-test.c++:417: legacy test: Async/SeparateFulfillerDiscardedDuringUnwind
[ PASS ] async-test.c++:417: legacy test: Async/SeparateFulfillerDiscardedDuringUnwind (28 μs)
[ TEST ] async-test.c++:432: legacy test: Async/SeparateFulfillerMemoryLeak
[ PASS ] async-test.c++:432: legacy test: Async/SeparateFulfillerMemoryLeak (0 μs)
[ TEST ] async-test.c++:437: legacy test: Async/Ordering
[ PASS ] async-test.c++:437: legacy test: Async/Ordering (13 μs)
[ TEST ] async-test.c++:512: legacy test: Async/Fork
[ PASS ] async-test.c++:512: legacy test: Async/Fork (6 μs)
[ TEST ] async-test.c++:557: legacy test: Async/ForkRef
[ PASS ] async-test.c++:557: legacy test: Async/ForkRef (3 μs)
[ TEST ] async-test.c++:584: legacy test: Async/ForkMaybeRef
[ PASS ] async-test.c++:584: legacy test: Async/ForkMaybeRef (2 μs)
[ TEST ] async-test.c++:612: legacy test: Async/Split
[ PASS ] async-test.c++:612: legacy test: Async/Split (2 μs)
[ TEST ] async-test.c++:627: legacy test: Async/ExclusiveJoin
[ PASS ] async-test.c++:627: legacy test: Async/ExclusiveJoin (7 μs)
[ TEST ] async-test.c++:669: legacy test: Async/ArrayJoin
[ PASS ] async-test.c++:669: legacy test: Async/ArrayJoin (41 μs)
[ TEST ] async-test.c++:688: legacy test: Async/ArrayJoinVoid
[ PASS ] async-test.c++:688: legacy test: Async/ArrayJoinVoid (3 μs)
[ TEST ] async-test.c++:702: legacy test: Async/Canceler
[ PASS ] async-test.c++:702: legacy test: Async/Canceler (33 μs)
[ TEST ] async-test.c++:725: legacy test: Async/CancelerDoubleWrap
[ PASS ] async-test.c++:725: legacy test: Async/CancelerDoubleWrap (1 μs)
[ TEST ] async-test.c++:744: legacy test: Async/TaskSet
[ PASS ] async-test.c++:744: legacy test: Async/TaskSet (19 μs)
[ TEST ] async-test.c++:779: legacy test: Async/LargeTaskSetDestruction
[ PASS ] async-test.c++:779: legacy test: Async/LargeTaskSetDestruction (2821 μs)
[ TEST ] async-test.c++:822: legacy test: Async/TaskSet
[ PASS ] async-test.c++:822: legacy test: Async/TaskSet (3 μs)
[ TEST ] async-test.c++:852: legacy test: Async/TaskSetOnEmpty
[ PASS ] async-test.c++:852: legacy test: Async/TaskSetOnEmpty (1 μs)
[ TEST ] async-test.c++:885: legacy test: Async/Attach
[ PASS ] async-test.c++:885: legacy test: Async/Attach (1 μs)
[ TEST ] async-test.c++:906: legacy test: Async/EagerlyEvaluate
[ PASS ] async-test.c++:906: legacy test: Async/EagerlyEvaluate (2 μs)
[ TEST ] async-test.c++:926: legacy test: Async/Detach
[ PASS ] async-test.c++:926: legacy test: Async/Detach (23 μs)
[ TEST ] async-test.c++:965: legacy test: Async/SetRunnable
[ PASS ] async-test.c++:965: legacy test: Async/SetRunnable (3 μs)
[ TEST ] async-test.c++:1007: legacy test: Async/Poll
[ PASS ] async-test.c++:1007: legacy test: Async/Poll (0 μs)
[ TEST ] async-test.c++:1018: exclusiveJoin both events complete simultaneously
[ PASS ] async-test.c++:1018: exclusiveJoin both events complete simultaneously (1 μs)
[ TEST ] async-test.c++:1036: start a fiber
[ PASS ] async-test.c++:1036: start a fiber (10 μs)
[ TEST ] async-test.c++:1059: fiber promise chaining
[ PASS ] async-test.c++:1059: fiber promise chaining (6 μs)
[ TEST ] async-test.c++:1084: throw from a fiber
[ PASS ] async-test.c++:1084: throw from a fiber (31 μs)
[ TEST ] async-test.c++:1109: cancel a fiber
[ PASS ] async-test.c++:1109: cancel a fiber (25 μs)
[ TEST ] async-test.c++:1144: fiber pool
[ PASS ] async-test.c++:1144: fiber pool (23 μs)
[ TEST ] async-test.c++:1240: fiber pool runSynchronously()
[ PASS ] async-test.c++:1240: fiber pool runSynchronously() (28 μs)
[ TEST ] async-test.c++:1278: fiber pool limit
[ PASS ] async-test.c++:1278: fiber pool limit (121 μs)
[ TEST ] async-test.c++:1338: run event loop on freelisted stacks
[ PASS ] async-test.c++:1338: run event loop on freelisted stacks (13 μs)
[ TEST ] async-test.c++:1450: retryOnDisconnect
[ PASS ] async-test.c++:1450: retryOnDisconnect (27 μs)
[ TEST ] async-xthread-test.c++:52: synchonous simple cross-thread events
[ PASS ] async-xthread-test.c++:52: synchonous simple cross-thread events (198 μs)
[ TEST ] async-xthread-test.c++:102: asynchronous simple cross-thread events
[ PASS ] async-xthread-test.c++:102: asynchronous simple cross-thread events (136 μs)
[ TEST ] async-xthread-test.c++:154: synchonous promise cross-thread events
[ PASS ] async-xthread-test.c++:154: synchonous promise cross-thread events (80 μs)
[ TEST ] async-xthread-test.c++:213: asynchronous promise cross-thread events
[ PASS ] async-xthread-test.c++:213: asynchronous promise cross-thread events (76 μs)
[ TEST ] async-xthread-test.c++:274: cancel cross-thread event before it runs
[ PASS ] async-xthread-test.c++:274: cancel cross-thread event before it runs (10095 μs)
[ TEST ] async-xthread-test.c++:313: cancel cross-thread event while it runs
[ PASS ] async-xthread-test.c++:313: cancel cross-thread event while it runs (10134 μs)
[ TEST ] async-xthread-test.c++:362: cross-thread cancellation in both directions at once
[ PASS ] async-xthread-test.c++:362: cross-thread cancellation in both directions at once (21377 μs)
[ TEST ] async-xthread-test.c++:473: cross-thread cancellation cycle
[ PASS ] async-xthread-test.c++:473: cross-thread cancellation cycle (137 μs)
[ TEST ] async-xthread-test.c++:547: call own thread's executor
[ PASS ] async-xthread-test.c++:547: call own thread's executor (36 μs)
[ TEST ] async-xthread-test.c++:571: synchronous cross-thread event disconnected
[ PASS ] async-xthread-test.c++:571: synchronous cross-thread event disconnected (89 μs)
[ TEST ] async-xthread-test.c++:625: asynchronous cross-thread event disconnected
[ PASS ] async-xthread-test.c++:625: asynchronous cross-thread event disconnected (82 μs)
[ TEST ] async-xthread-test.c++:681: cross-thread event disconnected before it runs
[ PASS ] async-xthread-test.c++:681: cross-thread event disconnected before it runs (50 μs)
[ TEST ] async-xthread-test.c++:725: cross-thread event disconnected without holding Executor ref
[ PASS ] async-xthread-test.c++:725: cross-thread event disconnected without holding Executor ref (64 μs)
[ TEST ] async-xthread-test.c++:775: detached cross-thread event doesn't cause crash
[ PASS ] async-xthread-test.c++:775: detached cross-thread event doesn't cause crash (30230 μs)
[ TEST ] async-xthread-test.c++:831: cross-thread event cancel requested while destination thread being destroyed
[ PASS ] async-xthread-test.c++:831: cross-thread event cancel requested while destination thread being destroyed (10119 μs)
[ TEST ] async-xthread-test.c++:886: cross-thread fulfiller
[ PASS ] async-xthread-test.c++:886: cross-thread fulfiller (68 μs)
[ TEST ] async-xthread-test.c++:913: cross-thread fulfiller rejects
[ PASS ] async-xthread-test.c++:913: cross-thread fulfiller rejects (80 μs)
[ TEST ] async-xthread-test.c++:939: cross-thread fulfiller destroyed
[ PASS ] async-xthread-test.c++:939: cross-thread fulfiller destroyed (65 μs)
[ TEST ] async-xthread-test.c++:967: cross-thread fulfiller canceled
[ PASS ] async-xthread-test.c++:967: cross-thread fulfiller canceled (10109 μs)
[ TEST ] async-xthread-test.c++:1011: cross-thread fulfiller multiple fulfills
[ PASS ] async-xthread-test.c++:1011: cross-thread fulfiller multiple fulfills (168 μs)
[ TEST ] async-unix-test.c++:79: legacy test: AsyncUnixTest/Signals
[ PASS ] async-unix-test.c++:79: legacy test: AsyncUnixTest/Signals (79 μs)
[ TEST ] async-unix-test.c++:93: legacy test: AsyncUnixTest/SignalWithValue
[ PASS ] async-unix-test.c++:93: legacy test: AsyncUnixTest/SignalWithValue (12 μs)
[ TEST ] async-unix-test.c++:128: legacy test: AsyncUnixTest/SignalWithPointerValue
[ PASS ] async-unix-test.c++:128: legacy test: AsyncUnixTest/SignalWithPointerValue (9 μs)
[ TEST ] async-unix-test.c++:164: legacy test: AsyncUnixTest/SignalsMultiListen
[ PASS ] async-unix-test.c++:164: legacy test: AsyncUnixTest/SignalsMultiListen (10 μs)
[ TEST ] async-unix-test.c++:188: legacy test: AsyncUnixTest/SignalsMultiReceive
[ PASS ] async-unix-test.c++:188: legacy test: AsyncUnixTest/SignalsMultiReceive (11 μs)
[ TEST ] async-unix-test.c++:208: legacy test: AsyncUnixTest/SignalsAsync
[ PASS ] async-unix-test.c++:208: legacy test: AsyncUnixTest/SignalsAsync (10106 μs)
[ TEST ] async-unix-test.c++:233: legacy test: AsyncUnixTest/SignalsNoWait
[ PASS ] async-unix-test.c++:233: legacy test: AsyncUnixTest/SignalsNoWait (11 μs)
[ TEST ] async-unix-test.c++:278: legacy test: AsyncUnixTest/ReadObserver
[ PASS ] async-unix-test.c++:278: legacy test: AsyncUnixTest/ReadObserver (16 μs)
[ TEST ] async-unix-test.c++:311: legacy test: AsyncUnixTest/ReadObserverMultiListen
[ PASS ] async-unix-test.c++:311: legacy test: AsyncUnixTest/ReadObserverMultiListen (18 μs)
[ TEST ] async-unix-test.c++:341: legacy test: AsyncUnixTest/ReadObserverMultiReceive
[ PASS ] async-unix-test.c++:341: legacy test: AsyncUnixTest/ReadObserverMultiReceive (8 μs)
[ TEST ] async-unix-test.c++:369: legacy test: AsyncUnixTest/ReadObserverAsync
[ PASS ] async-unix-test.c++:369: legacy test: AsyncUnixTest/ReadObserverAsync (10097 μs)
[ TEST ] async-unix-test.c++:391: legacy test: AsyncUnixTest/ReadObserverNoWait
[ PASS ] async-unix-test.c++:391: legacy test: AsyncUnixTest/ReadObserverNoWait (21 μs)
[ TEST ] async-unix-test.c++:445: legacy test: AsyncUnixTest/WriteObserver
[ PASS ] async-unix-test.c++:445: legacy test: AsyncUnixTest/WriteObserver (3917 μs)
[ TEST ] async-unix-test.c++:493: legacy test: AsyncUnixTest/UrgentObserver
[ PASS ] async-unix-test.c++:493: legacy test: AsyncUnixTest/UrgentObserver (10227 μs)
[ TEST ] async-unix-test.c++:594: legacy test: AsyncUnixTest/SteadyTimers
[ PASS ] async-unix-test.c++:594: legacy test: AsyncUnixTest/SteadyTimers (41253 μs)
[ TEST ] async-unix-test.c++:634: legacy test: AsyncUnixTest/InterruptedTimer
[ PASS ] async-unix-test.c++:634: legacy test: AsyncUnixTest/InterruptedTimer (100084 μs)
[ TEST ] async-unix-test.c++:673: legacy test: AsyncUnixTest/Wake
[ PASS ] async-unix-test.c++:673: legacy test: AsyncUnixTest/Wake (40362 μs)
[ TEST ] async-unix-test.c++:779: legacy test: AsyncUnixTest/ChildProcess
[ PASS ] async-unix-test.c++:779: legacy test: AsyncUnixTest/ChildProcess (1621 μs)
[ TEST ] async-unix-test.c++:826: UnixEventPort whenWriteDisconnected()
[ PASS ] async-unix-test.c++:826: UnixEventPort whenWriteDisconnected() (23 μs)
[ TEST ] async-unix-test.c++:866: UnixEventPort FdObserver(..., flags=0)::whenWriteDisconnected()
[ PASS ] async-unix-test.c++:866: UnixEventPort FdObserver(..., flags=0)::whenWriteDisconnected() (7 μs)
[ TEST ] async-unix-test.c++:895: UnixEventPort poll for signals
[ PASS ] async-unix-test.c++:895: UnixEventPort poll for signals (9 μs)
[ TEST ] async-unix-test.c++:950: UnixEventPort can receive multiple queued instances of an RT signal
[ PASS ] async-unix-test.c++:950: UnixEventPort can receive multiple queued instances of an RT signal (14 μs)
[ TEST ] async-xthread-test.c++:52: synchonous simple cross-thread events
[ PASS ] async-xthread-test.c++:52: synchonous simple cross-thread events (147 μs)
[ TEST ] async-xthread-test.c++:102: asynchronous simple cross-thread events
[ PASS ] async-xthread-test.c++:102: asynchronous simple cross-thread events (110 μs)
[ TEST ] async-xthread-test.c++:154: synchonous promise cross-thread events
[ PASS ] async-xthread-test.c++:154: synchonous promise cross-thread events (82 μs)
[ TEST ] async-xthread-test.c++:213: asynchronous promise cross-thread events
[ PASS ] async-xthread-test.c++:213: asynchronous promise cross-thread events (87 μs)
[ TEST ] async-xthread-test.c++:274: cancel cross-thread event before it runs
[ PASS ] async-xthread-test.c++:274: cancel cross-thread event before it runs (10117 μs)
[ TEST ] async-xthread-test.c++:313: cancel cross-thread event while it runs
[ PASS ] async-xthread-test.c++:313: cancel cross-thread event while it runs (10173 μs)
[ TEST ] async-xthread-test.c++:362: cross-thread cancellation in both directions at once
[ PASS ] async-xthread-test.c++:362: cross-thread cancellation in both directions at once (17411 μs)
[ TEST ] async-xthread-test.c++:473: cross-thread cancellation cycle
[ PASS ] async-xthread-test.c++:473: cross-thread cancellation cycle (144 μs)
[ TEST ] async-xthread-test.c++:547: call own thread's executor
[ PASS ] async-xthread-test.c++:547: call own thread's executor (31 μs)
[ TEST ] async-xthread-test.c++:571: synchronous cross-thread event disconnected
[ PASS ] async-xthread-test.c++:571: synchronous cross-thread event disconnected (86 μs)
[ TEST ] async-xthread-test.c++:625: asynchronous cross-thread event disconnected
[ PASS ] async-xthread-test.c++:625: asynchronous cross-thread event disconnected (89 μs)
[ TEST ] async-xthread-test.c++:681: cross-thread event disconnected before it runs
[ PASS ] async-xthread-test.c++:681: cross-thread event disconnected before it runs (60 μs)
[ TEST ] async-xthread-test.c++:725: cross-thread event disconnected without holding Executor ref
[ PASS ] async-xthread-test.c++:725: cross-thread event disconnected without holding Executor ref (72 μs)
[ TEST ] async-xthread-test.c++:775: detached cross-thread event doesn't cause crash
[ PASS ] async-xthread-test.c++:775: detached cross-thread event doesn't cause crash (30251 μs)
[ TEST ] async-xthread-test.c++:831: cross-thread event cancel requested while destination thread being destroyed
[ PASS ] async-xthread-test.c++:831: cross-thread event cancel requested while destination thread being destroyed (10127 μs)
[ TEST ] async-xthread-test.c++:886: cross-thread fulfiller
[ PASS ] async-xthread-test.c++:886: cross-thread fulfiller (77 μs)
[ TEST ] async-xthread-test.c++:913: cross-thread fulfiller rejects
[ PASS ] async-xthread-test.c++:913: cross-thread fulfiller rejects (104 μs)
[ TEST ] async-xthread-test.c++:939: cross-thread fulfiller destroyed
[ PASS ] async-xthread-test.c++:939: cross-thread fulfiller destroyed (92 μs)
[ TEST ] async-xthread-test.c++:967: cross-thread fulfiller canceled
[ PASS ] async-xthread-test.c++:967: cross-thread fulfiller canceled (10123 μs)
[ TEST ] async-xthread-test.c++:1011: cross-thread fulfiller multiple fulfills
[ PASS ] async-xthread-test.c++:1011: cross-thread fulfiller multiple fulfills (189 μs)
[ TEST ] async-io-test.c++:54: legacy test: AsyncIo/SimpleNetwork
[ PASS ] async-io-test.c++:54: legacy test: AsyncIo/SimpleNetwork (502 μs)
[ TEST ] async-io-test.c++:93: legacy test: AsyncIo/SimpleNetworkAuthentication
[ PASS ] async-io-test.c++:93: legacy test: AsyncIo/SimpleNetworkAuthentication (150 μs)
[ TEST ] async-io-test.c++:174: legacy test: AsyncIo/UnixSocket
[ PASS ] async-io-test.c++:174: legacy test: AsyncIo/UnixSocket (109 μs)
[ TEST ] async-io-test.c++:247: legacy test: AsyncIo/AncillaryMessageHandlerNoMsg
[ PASS ] async-io-test.c++:247: legacy test: AsyncIo/AncillaryMessageHandlerNoMsg (130 μs)
[ TEST ] async-io-test.c++:307: legacy test: AsyncIo/AncillaryMessageHandler
[ PASS ] async-io-test.c++:307: legacy test: AsyncIo/AncillaryMessageHandler (161 μs)
[ TEST ] async-io-test.c++:395: legacy test: AsyncIo/AddressParsing
kj/async-io-test.c++:432: system does not support ipv6; skipping tests
[ PASS ] async-io-test.c++:395: legacy test: AsyncIo/AddressParsing (1346 μs)
[ TEST ] async-io-test.c++:440: legacy test: AsyncIo/OneWayPipe
[ PASS ] async-io-test.c++:440: legacy test: AsyncIo/OneWayPipe (12 μs)
[ TEST ] async-io-test.c++:458: legacy test: AsyncIo/TwoWayPipe
[ PASS ] async-io-test.c++:458: legacy test: AsyncIo/TwoWayPipe (15 μs)
[ TEST ] async-io-test.c++:485: legacy test: AsyncIo/InMemoryCapabilityPipe
[ PASS ] async-io-test.c++:485: legacy test: AsyncIo/InMemoryCapabilityPipe (24 μs)
[ TEST ] async-io-test.c++:526: legacy test: AsyncIo/CapabilityPipe
[ PASS ] async-io-test.c++:526: legacy test: AsyncIo/CapabilityPipe (32 μs)
[ TEST ] async-io-test.c++:565: legacy test: AsyncIo/CapabilityPipeBlockedSendStream
[ PASS ] async-io-test.c++:565: legacy test: AsyncIo/CapabilityPipeBlockedSendStream (3823 μs)
[ TEST ] async-io-test.c++:606: legacy test: AsyncIo/CapabilityPipeMultiStreamMessage
[ PASS ] async-io-test.c++:606: legacy test: AsyncIo/CapabilityPipeMultiStreamMessage (30 μs)
[ TEST ] async-io-test.c++:641: legacy test: AsyncIo/ScmRightsTruncatedOdd
[ PASS ] async-io-test.c++:641: legacy test: AsyncIo/ScmRightsTruncatedOdd (17 μs)
[ TEST ] async-io-test.c++:709: legacy test: AsyncIo/ScmRightsTruncatedEven
[ PASS ] async-io-test.c++:709: legacy test: AsyncIo/ScmRightsTruncatedEven (15 μs)
[ TEST ] async-io-test.c++:799: legacy test: AsyncIo/PipeThread
[ PASS ] async-io-test.c++:799: legacy test: AsyncIo/PipeThread (99 μs)
[ TEST ] async-io-test.c++:819: legacy test: AsyncIo/PipeThreadDisconnects
[ PASS ] async-io-test.c++:819: legacy test: AsyncIo/PipeThreadDisconnects (86 μs)
[ TEST ] async-io-test.c++:842: legacy test: AsyncIo/Timeouts
[ PASS ] async-io-test.c++:842: legacy test: AsyncIo/Timeouts (10075 μs)
[ TEST ] async-io-test.c++:898: legacy test: AsyncIo/Udp
[ PASS ] async-io-test.c++:898: legacy test: AsyncIo/Udp (110 μs)
[ TEST ] async-io-test.c++:1060: legacy test: AsyncIo/AbstractUnixSocket
[ PASS ] async-io-test.c++:1060: legacy test: AsyncIo/AbstractUnixSocket (101 μs)
[ TEST ] async-io-test.c++:1082: CIDR parsing
[ PASS ] async-io-test.c++:1082: CIDR parsing (20 μs)
[ TEST ] async-io-test.c++:1151: NetworkFilter
[ PASS ] async-io-test.c++:1151: NetworkFilter (23 μs)
[ TEST ] async-io-test.c++:1204: Network::restrictPeers()
[ PASS ] async-io-test.c++:1204: Network::restrictPeers() (235 μs)
[ TEST ] async-io-test.c++:1276: AsyncInputStream::readAllText() / readAllBytes()
[ PASS ] async-io-test.c++:1276: AsyncInputStream::readAllText() / readAllBytes() (10253 μs)
[ TEST ] async-io-test.c++:1317: Userland pipe
[ PASS ] async-io-test.c++:1317: Userland pipe (5 μs)
[ TEST ] async-io-test.c++:1340: Userland pipe cancel write
[ PASS ] async-io-test.c++:1340: Userland pipe cancel write (3 μs)
[ TEST ] async-io-test.c++:1361: Userland pipe cancel read
[ PASS ] async-io-test.c++:1361: Userland pipe cancel read (2 μs)
[ TEST ] async-io-test.c++:1377: Userland pipe pumpTo
[ PASS ] async-io-test.c++:1377: Userland pipe pumpTo (6 μs)
[ TEST ] async-io-test.c++:1399: Userland pipe tryPumpFrom
[ PASS ] async-io-test.c++:1399: Userland pipe tryPumpFrom (8 μs)
[ TEST ] async-io-test.c++:1422: Userland pipe pumpTo cancel
[ PASS ] async-io-test.c++:1422: Userland pipe pumpTo cancel (2 μs)
[ TEST ] async-io-test.c++:1442: Userland pipe tryPumpFrom cancel
[ PASS ] async-io-test.c++:1442: Userland pipe tryPumpFrom cancel (2 μs)
[ TEST ] async-io-test.c++:1462: Userland pipe with limit
[ PASS ] async-io-test.c++:1462: Userland pipe with limit (31 μs)
[ TEST ] async-io-test.c++:1489: Userland pipe pumpTo with limit
[ PASS ] async-io-test.c++:1489: Userland pipe pumpTo with limit (24 μs)
[ TEST ] async-io-test.c++:1518: Userland pipe pump into zero-limited pipe, no data to pump
[ PASS ] async-io-test.c++:1518: Userland pipe pump into zero-limited pipe, no data to pump (2 μs)
[ TEST ] async-io-test.c++:1531: Userland pipe pump into zero-limited pipe, data is pumped
[ PASS ] async-io-test.c++:1531: Userland pipe pump into zero-limited pipe, data is pumped (23 μs)
[ TEST ] async-io-test.c++:1544: Userland pipe gather write
[ PASS ] async-io-test.c++:1544: Userland pipe gather write (3 μs)
[ TEST ] async-io-test.c++:1563: Userland pipe gather write split on buffer boundary
[ PASS ] async-io-test.c++:1563: Userland pipe gather write split on buffer boundary (2 μs)
[ TEST ] async-io-test.c++:1583: Userland pipe gather write split mid-first-buffer
[ PASS ] async-io-test.c++:1583: Userland pipe gather write split mid-first-buffer (2 μs)
[ TEST ] async-io-test.c++:1603: Userland pipe gather write split mid-second-buffer
[ PASS ] async-io-test.c++:1603: Userland pipe gather write split mid-second-buffer (2 μs)
[ TEST ] async-io-test.c++:1623: Userland pipe gather write pump
[ PASS ] async-io-test.c++:1623: Userland pipe gather write pump (2 μs)
[ TEST ] async-io-test.c++:1641: Userland pipe gather write pump split on buffer boundary
[ PASS ] async-io-test.c++:1641: Userland pipe gather write pump split on buffer boundary (1 μs)
[ TEST ] async-io-test.c++:1660: Userland pipe gather write pump split mid-first-buffer
[ PASS ] async-io-test.c++:1660: Userland pipe gather write pump split mid-first-buffer (1 μs)
[ TEST ] async-io-test.c++:1679: Userland pipe gather write pump split mid-second-buffer
[ PASS ] async-io-test.c++:1679: Userland pipe gather write pump split mid-second-buffer (1 μs)
[ TEST ] async-io-test.c++:1698: Userland pipe gather write split pump on buffer boundary
[ PASS ] async-io-test.c++:1698: Userland pipe gather write split pump on buffer boundary (4 μs)
[ TEST ] async-io-test.c++:1720: Userland pipe gather write split pump mid-first-buffer
[ PASS ] async-io-test.c++:1720: Userland pipe gather write split pump mid-first-buffer (6 μs)
[ TEST ] async-io-test.c++:1742: Userland pipe gather write split pump mid-second-buffer
[ PASS ] async-io-test.c++:1742: Userland pipe gather write split pump mid-second-buffer (3 μs)
[ TEST ] async-io-test.c++:1764: Userland pipe gather write pumpFrom
[ PASS ] async-io-test.c++:1764: Userland pipe gather write pumpFrom (3 μs)
[ TEST ] async-io-test.c++:1787: Userland pipe gather write pumpFrom split on buffer boundary
[ PASS ] async-io-test.c++:1787: Userland pipe gather write pumpFrom split on buffer boundary (2 μs)
[ TEST ] async-io-test.c++:1811: Userland pipe gather write pumpFrom split mid-first-buffer
[ PASS ] async-io-test.c++:1811: Userland pipe gather write pumpFrom split mid-first-buffer (3 μs)
[ TEST ] async-io-test.c++:1835: Userland pipe gather write pumpFrom split mid-second-buffer
[ PASS ] async-io-test.c++:1835: Userland pipe gather write pumpFrom split mid-second-buffer (3 μs)
[ TEST ] async-io-test.c++:1859: Userland pipe gather write split pumpFrom on buffer boundary
[ PASS ] async-io-test.c++:1859: Userland pipe gather write split pumpFrom on buffer boundary (3 μs)
[ TEST ] async-io-test.c++:1881: Userland pipe gather write split pumpFrom mid-first-buffer
[ PASS ] async-io-test.c++:1881: Userland pipe gather write split pumpFrom mid-first-buffer (3 μs)
[ TEST ] async-io-test.c++:1903: Userland pipe gather write split pumpFrom mid-second-buffer
[ PASS ] async-io-test.c++:1903: Userland pipe gather write split pumpFrom mid-second-buffer (2 μs)
[ TEST ] async-io-test.c++:1925: Userland pipe pumpTo less than write amount
[ PASS ] async-io-test.c++:1925: Userland pipe pumpTo less than write amount (97 μs)
[ TEST ] async-io-test.c++:1953: Userland pipe pumpFrom EOF on abortRead()
[ PASS ] async-io-test.c++:1953: Userland pipe pumpFrom EOF on abortRead() (7 μs)
[ TEST ] async-io-test.c++:1973: Userland pipe EOF fulfills pumpFrom promise
[ PASS ] async-io-test.c++:1973: Userland pipe EOF fulfills pumpFrom promise (5 μs)
[ TEST ] async-io-test.c++:1998: Userland pipe tryPumpFrom to pumpTo for same amount fulfills simultaneously
[ PASS ] async-io-test.c++:1998: Userland pipe tryPumpFrom to pumpTo for same amount fulfills simultaneously (4 μs)
[ TEST ] async-io-test.c++:2018: Userland pipe multi-part write doesn't quit early
[ PASS ] async-io-test.c++:2018: Userland pipe multi-part write doesn't quit early (4 μs)
[ TEST ] async-io-test.c++:2037: Userland pipe BlockedRead gets empty tryPumpFrom
[ PASS ] async-io-test.c++:2037: Userland pipe BlockedRead gets empty tryPumpFrom (3 μs)
[ TEST ] async-io-test.c++:2070: Userland tee
[ PASS ] async-io-test.c++:2070: Userland tee (17 μs)
[ TEST ] async-io-test.c++:2086: Userland nested tee
[ PASS ] async-io-test.c++:2086: Userland nested tee (10 μs)
[ TEST ] async-io-test.c++:2119: Userland tee concurrent read
[ PASS ] async-io-test.c++:2119: Userland tee concurrent read (6 μs)
[ TEST ] async-io-test.c++:2144: Userland tee cancel and restart read
[ PASS ] async-io-test.c++:2144: Userland tee cancel and restart read (5 μs)
[ TEST ] async-io-test.c++:2167: Userland tee cancel read and destroy branch then read other branch
[ PASS ] async-io-test.c++:2167: Userland tee cancel read and destroy branch then read other branch (3 μs)
[ TEST ] async-io-test.c++:2192: Userland tee subsequent other-branch reads are READY_NOW
[ PASS ] async-io-test.c++:2192: Userland tee subsequent other-branch reads are READY_NOW (3 μs)
[ TEST ] async-io-test.c++:2217: Userland tee read EOF propagation
[ PASS ] async-io-test.c++:2217: Userland tee read EOF propagation (5 μs)
[ TEST ] async-io-test.c++:2251: Userland tee read exception propagation
[ PASS ] async-io-test.c++:2251: Userland tee read exception propagation (77 μs)
[ TEST ] async-io-test.c++:2298: Userland tee read exception propagation w/ data loss
[ PASS ] async-io-test.c++:2298: Userland tee read exception propagation w/ data loss (38 μs)
[ TEST ] async-io-test.c++:2326: Userland tee read into different buffer sizes
[ PASS ] async-io-test.c++:2326: Userland tee read into different buffer sizes (3 μs)
[ TEST ] async-io-test.c++:2344: Userland tee reads see max(minBytes...) and min(maxBytes...)
[ PASS ] async-io-test.c++:2344: Userland tee reads see max(minBytes...) and min(maxBytes...) (5 μs)
[ TEST ] async-io-test.c++:2379: Userland tee read stress test
[ PASS ] async-io-test.c++:2379: Userland tee read stress test (13400 μs)
[ TEST ] async-io-test.c++:2407: Userland tee pump
[ PASS ] async-io-test.c++:2407: Userland tee pump (181 μs)
[ TEST ] async-io-test.c++:2450: Userland tee pump slows down reads
[ PASS ] async-io-test.c++:2450: Userland tee pump slows down reads (185 μs)
[ TEST ] async-io-test.c++:2481: Userland tee pump EOF propagation
[ PASS ] async-io-test.c++:2481: Userland tee pump EOF propagation (19 μs)
[ TEST ] async-io-test.c++:2560: Userland tee pump EOF on chunk boundary
[ PASS ] async-io-test.c++:2560: Userland tee pump EOF on chunk boundary (143 μs)
[ TEST ] async-io-test.c++:2594: Userland tee pump read exception propagation
[ PASS ] async-io-test.c++:2594: Userland tee pump read exception propagation (100 μs)
[ TEST ] async-io-test.c++:2678: Userland tee pump write exception propagation
[ PASS ] async-io-test.c++:2678: Userland tee pump write exception propagation (191 μs)
[ TEST ] async-io-test.c++:2710: Userland tee pump cancellation implies write cancellation
[ PASS ] async-io-test.c++:2710: Userland tee pump cancellation implies write cancellation (5 μs)
[ TEST ] async-io-test.c++:2738: Userland tee buffer size limit
[ PASS ] async-io-test.c++:2738: Userland tee buffer size limit (63 μs)
[ TEST ] async-io-test.c++:2834: Userspace OneWayPipe whenWriteDisconnected()
[ PASS ] async-io-test.c++:2834: Userspace OneWayPipe whenWriteDisconnected() (13 μs)
[ TEST ] async-io-test.c++:2849: Userspace TwoWayPipe whenWriteDisconnected()
[ PASS ] async-io-test.c++:2849: Userspace TwoWayPipe whenWriteDisconnected() (2 μs)
[ TEST ] async-io-test.c++:2867: OS OneWayPipe whenWriteDisconnected()
[ PASS ] async-io-test.c++:2867: OS OneWayPipe whenWriteDisconnected() (25 μs)
[ TEST ] async-io-test.c++:2882: OS TwoWayPipe whenWriteDisconnected()
[ PASS ] async-io-test.c++:2882: OS TwoWayPipe whenWriteDisconnected() (18 μs)
[ TEST ] async-io-test.c++:2906: import socket FD that's already broken
[ PASS ] async-io-test.c++:2906: import socket FD that's already broken (9 μs)
[ TEST ] async-io-test.c++:2929: AggregateConnectionReceiver
[ PASS ] async-io-test.c++:2929: AggregateConnectionReceiver (38 μs)
[ TEST ] async-io-test.c++:3015: OS handle pumpTo
[ PASS ] async-io-test.c++:3015: OS handle pumpTo (629 μs)
[ TEST ] async-io-test.c++:3070: OS handle pumpTo small limit
[ PASS ] async-io-test.c++:3070: OS handle pumpTo small limit (24 μs)
[ TEST ] async-io-test.c++:3092: OS handle pumpTo small limit -- write first then read
[ PASS ] async-io-test.c++:3092: OS handle pumpTo small limit -- write first then read (16 μs)
[ TEST ] async-io-test.c++:3119: OS handle pumpTo large limit
[ PASS ] async-io-test.c++:3119: OS handle pumpTo large limit (1000 μs)
[ TEST ] async-io-test.c++:3141: OS handle pumpTo large limit -- write first then read
[ PASS ] async-io-test.c++:3141: OS handle pumpTo large limit -- write first then read (861 μs)
[ TEST ] async-io-test.c++:3187: OS handle pumpTo write buffer is full before pump
[ PASS ] async-io-test.c++:3187: OS handle pumpTo write buffer is full before pump (1674 μs)
[ TEST ] async-io-test.c++:3221: OS handle pumpTo write buffer is full before pump -- and pump ends early
[ PASS ] async-io-test.c++:3221: OS handle pumpTo write buffer is full before pump -- and pump ends early (1613 μs)
[ TEST ] async-io-test.c++:3250: OS handle pumpTo write buffer is full before pump -- and pump hits limit early
[ PASS ] async-io-test.c++:3250: OS handle pumpTo write buffer is full before pump -- and pump hits limit early (1597 μs)
[ TEST ] async-io-test.c++:3278: OS handle pumpTo write buffer is full before pump -- and a lot of data is pumped
[ PASS ] async-io-test.c++:3278: OS handle pumpTo write buffer is full before pump -- and a lot of data is pumped (2062 μs)
[ TEST ] async-queue-test.c++:75: ProducerConsumerQueue with various amounts of producers and consumers
[ PASS ] async-queue-test.c++:75: ProducerConsumerQueue with various amounts of producers and consumers (4146 μs)
[ TEST ] async-queue-test.c++:127: ProducerConsumerQueue with rejectAll()
[ PASS ] async-queue-test.c++:127: ProducerConsumerQueue with rejectAll() (140 μs)
[ TEST ] refcount-test.c++:34: legacy test: Refcount/Basic
[ PASS ] refcount-test.c++:34: legacy test: Refcount/Basic (0 μs)
[ TEST ] string-tree-test.c++:29: legacy test: StringTree/StrTree
[ PASS ] string-tree-test.c++:29: legacy test: StringTree/StrTree (25 μs)
[ TEST ] string-tree-test.c++:47: legacy test: StringTree/DelimitedArray
[ PASS ] string-tree-test.c++:47: legacy test: StringTree/DelimitedArray (1 μs)
[ TEST ] encoding-test.c++:84: encode UTF-8 to UTF-16
[ PASS ] encoding-test.c++:84: encode UTF-8 to UTF-16 (3 μs)
[ TEST ] encoding-test.c++:91: invalid UTF-8 to UTF-16
[ PASS ] encoding-test.c++:91: invalid UTF-8 to UTF-16 (3 μs)
[ TEST ] encoding-test.c++:150: encode UTF-8 to UTF-32
[ PASS ] encoding-test.c++:150: encode UTF-8 to UTF-32 (2 μs)
[ TEST ] encoding-test.c++:157: invalid UTF-8 to UTF-32
[ PASS ] encoding-test.c++:157: invalid UTF-8 to UTF-32 (2 μs)
[ TEST ] encoding-test.c++:195: decode UTF-16 to UTF-8
[ PASS ] encoding-test.c++:195: decode UTF-16 to UTF-8 (2 μs)
[ TEST ] encoding-test.c++:202: invalid UTF-16 to UTF-8
[ PASS ] encoding-test.c++:202: invalid UTF-16 to UTF-8 (1 μs)
[ TEST ] encoding-test.c++:215: decode UTF-32 to UTF-8
[ PASS ] encoding-test.c++:215: decode UTF-32 to UTF-8 (1 μs)
[ TEST ] encoding-test.c++:222: invalid UTF-32 to UTF-8
[ PASS ] encoding-test.c++:222: invalid UTF-32 to UTF-8 (0 μs)
[ TEST ] encoding-test.c++:232: round-trip invalid UTF-16
[ PASS ] encoding-test.c++:232: round-trip invalid UTF-16 (1 μs)
[ TEST ] encoding-test.c++:239: EncodingResult as a Maybe
[ PASS ] encoding-test.c++:239: EncodingResult as a Maybe (0 μs)
[ TEST ] encoding-test.c++:253: encode to wchar_t
[ PASS ] encoding-test.c++:253: encode to wchar_t (1 μs)
[ TEST ] encoding-test.c++:260: decode from wchar_t
[ PASS ] encoding-test.c++:260: decode from wchar_t (1 μs)
[ TEST ] encoding-test.c++:269: hex encoding/decoding
[ PASS ] encoding-test.c++:269: hex encoding/decoding (3 μs)
[ TEST ] encoding-test.c++:288: URI encoding/decoding
[ PASS ] encoding-test.c++:288: URI encoding/decoding (4 μs)
[ TEST ] encoding-test.c++:322: URL component encoding
[ PASS ] encoding-test.c++:322: URL component encoding (5 μs)
[ TEST ] encoding-test.c++:348: application/x-www-form-urlencoded encoding/decoding
[ PASS ] encoding-test.c++:348: application/x-www-form-urlencoded encoding/decoding (3 μs)
[ TEST ] encoding-test.c++:373: C escape encoding/decoding
[ PASS ] encoding-test.c++:373: C escape encoding/decoding (7 μs)
[ TEST ] encoding-test.c++:400: base64 encoding/decoding
[ PASS ] encoding-test.c++:400: base64 encoding/decoding (4 μs)
[ TEST ] encoding-test.c++:489: base64 url encoding
[ PASS ] encoding-test.c++:489: base64 url encoding (1 μs)
[ TEST ] arena-test.c++:62: legacy test: Arena/Object
[ PASS ] arena-test.c++:62: legacy test: Arena/Object (8 μs)
[ TEST ] arena-test.c++:80: legacy test: Arena/TrivialObject
[ PASS ] arena-test.c++:80: legacy test: Arena/TrivialObject (0 μs)
[ TEST ] arena-test.c++:90: legacy test: Arena/OwnObject
[ PASS ] arena-test.c++:90: legacy test: Arena/OwnObject (0 μs)
[ TEST ] arena-test.c++:107: legacy test: Arena/Array
[ PASS ] arena-test.c++:107: legacy test: Arena/Array (1 μs)
[ TEST ] arena-test.c++:124: legacy test: Arena/TrivialArray
[ PASS ] arena-test.c++:124: legacy test: Arena/TrivialArray (0 μs)
[ TEST ] arena-test.c++:133: legacy test: Arena/OwnArray
[ PASS ] arena-test.c++:133: legacy test: Arena/OwnArray (0 μs)
[ TEST ] arena-test.c++:153: legacy test: Arena/ObjectThrow
[ PASS ] arena-test.c++:153: legacy test: Arena/ObjectThrow (23 μs)
[ TEST ] arena-test.c++:168: legacy test: Arena/ArrayThrow
[ PASS ] arena-test.c++:168: legacy test: Arena/ArrayThrow (11 μs)
[ TEST ] arena-test.c++:183: legacy test: Arena/Alignment
[ PASS ] arena-test.c++:183: legacy test: Arena/Alignment (0 μs)
[ TEST ] arena-test.c++:196: legacy test: Arena/EndOfChunk
[ PASS ] arena-test.c++:196: legacy test: Arena/EndOfChunk (0 μs)
[ TEST ] arena-test.c++:222: legacy test: Arena/EndOfChunkAlignment
[ PASS ] arena-test.c++:222: legacy test: Arena/EndOfChunkAlignment (0 μs)
[ TEST ] arena-test.c++:247: legacy test: Arena/TooBig
[ PASS ] arena-test.c++:247: legacy test: Arena/TooBig (0 μs)
[ TEST ] arena-test.c++:266: legacy test: Arena/MultiSegment
[ PASS ] arena-test.c++:266: legacy test: Arena/MultiSegment (0 μs)
[ TEST ] arena-test.c++:282: legacy test: Arena/Constructor
[ PASS ] arena-test.c++:282: legacy test: Arena/Constructor (0 μs)
[ TEST ] arena-test.c++:289: legacy test: Arena/Strings
[ PASS ] arena-test.c++:289: legacy test: Arena/Strings (0 μs)
[ TEST ] units-test.c++:50: legacy test: UnitMeasure/Basics
[ PASS ] units-test.c++:50: legacy test: UnitMeasure/Basics (0 μs)
[ TEST ] units-test.c++:71: legacy test: UnitMeasure/AtLeastUInt
[ PASS ] units-test.c++:71: legacy test: UnitMeasure/AtLeastUInt (0 μs)
[ TEST ] units-test.c++:99: legacy test: UnitMeasure/BoundedConst
[ PASS ] units-test.c++:99: legacy test: UnitMeasure/BoundedConst (0 μs)
[ TEST ] units-test.c++:152: legacy test: UnitMeasure/Bounded
[ PASS ] units-test.c++:152: legacy test: UnitMeasure/Bounded (0 μs)
[ TEST ] units-test.c++:232: legacy test: UnitMeasure/BoundedVsGuardedConst
[ PASS ] units-test.c++:232: legacy test: UnitMeasure/BoundedVsGuardedConst (0 μs)
[ TEST ] units-test.c++:267: legacy test: UnitMeasure/BoundedRange
[ PASS ] units-test.c++:267: legacy test: UnitMeasure/BoundedRange (0 μs)
[ TEST ] units-test.c++:290: legacy test: UnitMeasure/BoundedQuantity
[ PASS ] units-test.c++:290: legacy test: UnitMeasure/BoundedQuantity (0 μs)
[ TEST ] units-test.c++:318: legacy test: UnitMeasure/BoundedMinMax
[ PASS ] units-test.c++:318: legacy test: UnitMeasure/BoundedMinMax (0 μs)
[ TEST ] units-test.c++:353: compare bounded quantities of different bounds
[ PASS ] units-test.c++:353: compare bounded quantities of different bounds (0 μs)
[ TEST ] tuple-test.c++:35: legacy test: Tuple/Tuple
[ PASS ] tuple-test.c++:35: legacy test: Tuple/Tuple (1 μs)
[ TEST ] tuple-test.c++:93: legacy test: Tuple/RefTuple
[ PASS ] tuple-test.c++:93: legacy test: Tuple/RefTuple (0 μs)
[ TEST ] one-of-test.c++:28: legacy test: OneOf/Basic
[ PASS ] one-of-test.c++:28: legacy test: OneOf/Basic (3 μs)
[ TEST ] one-of-test.c++:80: legacy test: OneOf/Copy
[ PASS ] one-of-test.c++:80: legacy test: OneOf/Copy (0 μs)
[ TEST ] one-of-test.c++:101: legacy test: OneOf/Switch
[ PASS ] one-of-test.c++:101: legacy test: OneOf/Switch (0 μs)
[ TEST ] one-of-test.c++:154: legacy test: OneOf/Maybe
[ PASS ] one-of-test.c++:154: legacy test: OneOf/Maybe (0 μs)
[ TEST ] one-of-test.c++:173: OneOf copy/move from alternative variants
[ PASS ] one-of-test.c++:173: OneOf copy/move from alternative variants (0 μs)
[ TEST ] function-test.c++:28: legacy test: Function/Lambda
[ PASS ] function-test.c++:28: legacy test: Function/Lambda (0 μs)
[ TEST ] function-test.c++:57: legacy test: Function/Method
[ PASS ] function-test.c++:57: legacy test: Function/Method (0 μs)
[ TEST ] function-test.c++:100: legacy test: ConstFunction/Method
[ PASS ] function-test.c++:100: legacy test: ConstFunction/Method (0 μs)
[ TEST ] function-test.c++:135: FunctionParam
[ PASS ] function-test.c++:135: FunctionParam (0 μs)
[ TEST ] filesystem-test.c++:29: Path
[ PASS ] filesystem-test.c++:29: Path (33 μs)
[ TEST ] filesystem-test.c++:89: Path comparisons
[ PASS ] filesystem-test.c++:89: Path comparisons (11 μs)
[ TEST ] filesystem-test.c++:130: Path exceptions
[ PASS ] filesystem-test.c++:130: Path exceptions (227 μs)
[ TEST ] filesystem-test.c++:162: Win32 Path
[ PASS ] filesystem-test.c++:162: Win32 Path (23 μs)
[ TEST ] filesystem-test.c++:213: Win32 Path exceptions
[ PASS ] filesystem-test.c++:213: Win32 Path exceptions (241 μs)
[ TEST ] filesystem-test.c++:245: WriteMode operators
[ PASS ] filesystem-test.c++:245: WriteMode operators (0 μs)
[ TEST ] filesystem-test.c++:289: InMemoryFile
[ PASS ] filesystem-test.c++:289: InMemoryFile (25 μs)
[ TEST ] filesystem-test.c++:378: InMemoryFile::copy()
[ PASS ] filesystem-test.c++:378: InMemoryFile::copy() (112 μs)
[ TEST ] filesystem-test.c++:410: File::copy()
[ PASS ] filesystem-test.c++:410: File::copy() (116 μs)
[ TEST ] filesystem-test.c++:442: InMemoryDirectory
[ PASS ] filesystem-test.c++:442: InMemoryDirectory (41 μs)
[ TEST ] filesystem-test.c++:615: InMemoryDirectory symlinks
[ PASS ] filesystem-test.c++:615: InMemoryDirectory symlinks (44 μs)
[ TEST ] filesystem-test.c++:677: InMemoryDirectory link
[ PASS ] filesystem-test.c++:677: InMemoryDirectory link (4 μs)
[ TEST ] filesystem-test.c++:702: InMemoryDirectory copy
[ PASS ] filesystem-test.c++:702: InMemoryDirectory copy (7 μs)
[ TEST ] filesystem-test.c++:729: InMemoryDirectory move
[ PASS ] filesystem-test.c++:729: InMemoryDirectory move (3 μs)
[ TEST ] filesystem-test.c++:750: InMemoryDirectory createTemporary
[ PASS ] filesystem-test.c++:750: InMemoryDirectory createTemporary (0 μs)
[ TEST ] filesystem-disk-test.c++:275: DiskFile
[ PASS ] filesystem-disk-test.c++:275: DiskFile (328 μs)
[ TEST ] filesystem-disk-test.c++:368: DiskFile::copy()
[ PASS ] filesystem-disk-test.c++:368: DiskFile::copy() (336 μs)
[ TEST ] filesystem-disk-test.c++:393: DiskDirectory
[ PASS ] filesystem-disk-test.c++:393: DiskDirectory (1088 μs)
[ TEST ] filesystem-disk-test.c++:541: DiskDirectory symlinks
[ PASS ] filesystem-disk-test.c++:541: DiskDirectory symlinks (617 μs)
[ TEST ] filesystem-disk-test.c++:597: DiskDirectory link
[ PASS ] filesystem-disk-test.c++:597: DiskDirectory link (382 μs)
[ TEST ] filesystem-disk-test.c++:625: DiskDirectory copy
[ PASS ] filesystem-disk-test.c++:625: DiskDirectory copy (704 μs)
[ TEST ] filesystem-disk-test.c++:649: DiskDirectory copy-replace
[ PASS ] filesystem-disk-test.c++:649: DiskDirectory copy-replace (1169 μs)
[ TEST ] filesystem-disk-test.c++:686: DiskDirectory move
[ PASS ] filesystem-disk-test.c++:686: DiskDirectory move (413 μs)
[ TEST ] filesystem-disk-test.c++:705: DiskDirectory move-replace
[ PASS ] filesystem-disk-test.c++:705: DiskDirectory move-replace (578 μs)
[ TEST ] filesystem-disk-test.c++:737: DiskDirectory createTemporary
[ PASS ] filesystem-disk-test.c++:737: DiskDirectory createTemporary (121 μs)
[ TEST ] filesystem-disk-test.c++:747: DiskDirectory replaceSubdir()
[ PASS ] filesystem-disk-test.c++:747: DiskDirectory replaceSubdir() (606 μs)
[ TEST ] filesystem-disk-test.c++:788: DiskDirectory replace directory with file
[ PASS ] filesystem-disk-test.c++:788: DiskDirectory replace directory with file (378 μs)
[ TEST ] filesystem-disk-test.c++:816: DiskDirectory replace file with directory
[ PASS ] filesystem-disk-test.c++:816: DiskDirectory replace file with directory (459 μs)
[ TEST ] filesystem-disk-test.c++:953: DiskFilesystem::computeCurrentPath
kj/filesystem-disk-unix.c++:1703: PWD environment variable doesn't match current directory; pwd = /var/tmp/portage/dev-libs/capnproto-0.10.2/work/capnproto-0.10.2/c++_build/src
[ PASS ] filesystem-disk-test.c++:953: DiskFilesystem::computeCurrentPath (306 μs)
[ TEST ] parse/common-test.c++:32: legacy test: CommonParsers/AnyParser
[ PASS ] parse/common-test.c++:32: legacy test: CommonParsers/AnyParser (0 μs)
[ TEST ] parse/common-test.c++:66: legacy test: CommonParsers/ExactElementParser
[ PASS ] parse/common-test.c++:66: legacy test: CommonParsers/ExactElementParser (0 μs)
[ TEST ] parse/common-test.c++:89: legacy test: CommonParsers/ExactlyConstParser
[ PASS ] parse/common-test.c++:89: legacy test: CommonParsers/ExactlyConstParser (0 μs)
[ TEST ] parse/common-test.c++:112: legacy test: CommonParsers/ConstResultParser
[ PASS ] parse/common-test.c++:112: legacy test: CommonParsers/ConstResultParser (0 μs)
[ TEST ] parse/common-test.c++:126: legacy test: CommonParsers/DiscardParser
[ PASS ] parse/common-test.c++:126: legacy test: CommonParsers/DiscardParser (0 μs)
[ TEST ] parse/common-test.c++:136: legacy test: CommonParsers/SequenceParser
[ PASS ] parse/common-test.c++:136: legacy test: CommonParsers/SequenceParser (0 μs)
[ TEST ] parse/common-test.c++:189: legacy test: CommonParsers/ManyParserCountOnly
[ PASS ] parse/common-test.c++:189: legacy test: CommonParsers/ManyParserCountOnly (0 μs)
[ TEST ] parse/common-test.c++:228: legacy test: CommonParsers/TimesParser
[ PASS ] parse/common-test.c++:228: legacy test: CommonParsers/TimesParser (0 μs)
[ TEST ] parse/common-test.c++:263: legacy test: CommonParsers/TimesParserCountOnly
[ PASS ] parse/common-test.c++:263: legacy test: CommonParsers/TimesParserCountOnly (0 μs)
[ TEST ] parse/common-test.c++:299: legacy test: CommonParsers/ManyParserSubResult
[ PASS ] parse/common-test.c++:299: legacy test: CommonParsers/ManyParserSubResult (0 μs)
[ TEST ] parse/common-test.c++:316: legacy test: CommonParsers/OptionalParser
[ PASS ] parse/common-test.c++:316: legacy test: CommonParsers/OptionalParser (0 μs)
[ TEST ] parse/common-test.c++:362: legacy test: CommonParsers/OneOfParser
[ PASS ] parse/common-test.c++:362: legacy test: CommonParsers/OneOfParser (0 μs)
[ TEST ] parse/common-test.c++:394: legacy test: CommonParsers/TransformParser
[ PASS ] parse/common-test.c++:394: legacy test: CommonParsers/TransformParser (0 μs)
[ TEST ] parse/common-test.c++:416: legacy test: CommonParsers/TransformOrRejectParser
[ PASS ] parse/common-test.c++:416: legacy test: CommonParsers/TransformOrRejectParser (0 μs)
[ TEST ] parse/common-test.c++:447: legacy test: CommonParsers/References
[ PASS ] parse/common-test.c++:447: legacy test: CommonParsers/References (0 μs)
[ TEST ] parse/common-test.c++:487: legacy test: CommonParsers/NotLookingAt
[ PASS ] parse/common-test.c++:487: legacy test: CommonParsers/NotLookingAt (0 μs)
[ TEST ] parse/common-test.c++:505: legacy test: CommonParsers/EndOfInput
[ PASS ] parse/common-test.c++:505: legacy test: CommonParsers/EndOfInput (0 μs)
[ TEST ] parse/char-test.c++:33: legacy test: CharParsers/ExactChar
[ PASS ] parse/char-test.c++:33: legacy test: CharParsers/ExactChar (0 μs)
[ TEST ] parse/char-test.c++:51: legacy test: CharParsers/ExactString
[ PASS ] parse/char-test.c++:51: legacy test: CharParsers/ExactString (0 μs)
[ TEST ] parse/char-test.c++:71: legacy test: CharParsers/CharRange
[ PASS ] parse/char-test.c++:71: legacy test: CharParsers/CharRange (0 μs)
[ TEST ] parse/char-test.c++:135: legacy test: CharParsers/AnyOfChars
[ PASS ] parse/char-test.c++:135: legacy test: CharParsers/AnyOfChars (0 μs)
[ TEST ] parse/char-test.c++:199: legacy test: CharParsers/CharGroupCombo
[ PASS ] parse/char-test.c++:199: legacy test: CharParsers/CharGroupCombo (0 μs)
[ TEST ] parse/char-test.c++:216: legacy test: CharParsers/Identifier
[ PASS ] parse/char-test.c++:216: legacy test: CharParsers/Identifier (4 μs)
[ TEST ] parse/char-test.c++:232: legacy test: CharParsers/Integer
[ PASS ] parse/char-test.c++:232: legacy test: CharParsers/Integer (1 μs)
[ TEST ] parse/char-test.c++:272: legacy test: CharParsers/Number
[ PASS ] parse/char-test.c++:272: legacy test: CharParsers/Number (5 μs)
[ TEST ] parse/char-test.c++:336: legacy test: CharParsers/DoubleQuotedString
[ PASS ] parse/char-test.c++:336: legacy test: CharParsers/DoubleQuotedString (2 μs)
[ TEST ] parse/char-test.c++:376: legacy test: CharParsers/SingleQuotedString
[ PASS ] parse/char-test.c++:376: legacy test: CharParsers/SingleQuotedString (1 μs)
[ TEST ] compat/url-test.c++:50: parse / stringify URL
[ PASS ] compat/url-test.c++:50: parse / stringify URL (67 μs)
[ TEST ] compat/url-test.c++:311: URL percent encoding
[ PASS ] compat/url-test.c++:311: URL percent encoding (9 μs)
[ TEST ] compat/url-test.c++:334: parse / stringify URL w/o decoding
[ PASS ] compat/url-test.c++:334: parse / stringify URL w/o decoding (3 μs)
[ TEST ] compat/url-test.c++:353: URL relative paths
[ PASS ] compat/url-test.c++:353: URL relative paths (6 μs)
[ TEST ] compat/url-test.c++:387: URL for HTTP request
[ PASS ] compat/url-test.c++:387: URL for HTTP request (8 μs)
[ TEST ] compat/url-test.c++:482: parse URL failure
[ PASS ] compat/url-test.c++:482: parse URL failure (2 μs)
[ TEST ] compat/url-test.c++:505: parse relative URL
[ PASS ] compat/url-test.c++:505: parse relative URL (20 μs)
[ TEST ] compat/url-test.c++:547: parse relative URL w/o decoding
[ PASS ] compat/url-test.c++:547: parse relative URL w/o decoding (1 μs)
[ TEST ] compat/url-test.c++:554: parse relative URL failure
[ PASS ] compat/url-test.c++:554: parse relative URL failure (1 μs)
[ TEST ] compat/http-test.c++:58: HttpMethod parse / stringify
[ PASS ] compat/http-test.c++:58: HttpMethod parse / stringify (17 μs)
[ TEST ] compat/http-test.c++:78: HttpHeaderTable
[ PASS ] compat/http-test.c++:78: HttpHeaderTable (18 μs)
[ TEST ] compat/http-test.c++:122: HttpHeaders::parseRequest
[ PASS ] compat/http-test.c++:122: HttpHeaders::parseRequest (18 μs)
[ TEST ] compat/http-test.c++:175: HttpHeaders::parseResponse
[ PASS ] compat/http-test.c++:175: HttpHeaders::parseResponse (6 μs)
[ TEST ] compat/http-test.c++:226: HttpHeaders parse invalid
[ PASS ] compat/http-test.c++:226: HttpHeaders parse invalid (2 μs)
[ TEST ] compat/http-test.c++:299: HttpHeaders require valid HttpHeaderTable
[ PASS ] compat/http-test.c++:299: HttpHeaders require valid HttpHeaderTable (34 μs)
[ TEST ] compat/http-test.c++:341: HttpHeaders validation
[ PASS ] compat/http-test.c++:341: HttpHeaders validation (61 μs)
[ TEST ] compat/http-test.c++:364: HttpHeaders Set-Cookie handling
[ PASS ] compat/http-test.c++:364: HttpHeaders Set-Cookie handling (3 μs)
[ TEST ] compat/http-test.c++:1054: HttpClient requests
[ PASS ] compat/http-test.c++:1054: HttpClient requests (174 μs)
[ TEST ] compat/http-test.c++:1064: HttpClient responses
[ PASS ] compat/http-test.c++:1064: HttpClient responses (1065 μs)
[ TEST ] compat/http-test.c++:1077: HttpClient canceled write
[ PASS ] compat/http-test.c++:1077: HttpClient canceled write (60 μs)
[ TEST ] compat/http-test.c++:1116: HttpClient chunked body gather-write
[ PASS ] compat/http-test.c++:1116: HttpClient chunked body gather-write (9 μs)
[ TEST ] compat/http-test.c++:1151: HttpClient chunked body pump from fixed length stream
[ PASS ] compat/http-test.c++:1151: HttpClient chunked body pump from fixed length stream (11 μs)
[ TEST ] compat/http-test.c++:1196: HttpServer requests
[ PASS ] compat/http-test.c++:1196: HttpServer requests (189 μs)
[ TEST ] compat/http-test.c++:1230: HttpServer responses
[ PASS ] compat/http-test.c++:1230: HttpServer responses (113 μs)
[ TEST ] compat/http-test.c++:1411: HttpClient pipeline
[ PASS ] compat/http-test.c++:1411: HttpClient pipeline (45 μs)
[ TEST ] compat/http-test.c++:1440: HttpClient parallel pipeline
[ PASS ] compat/http-test.c++:1440: HttpClient parallel pipeline (43 μs)
[ TEST ] compat/http-test.c++:1503: HttpServer pipeline
[ PASS ] compat/http-test.c++:1503: HttpServer pipeline (59 μs)
[ TEST ] compat/http-test.c++:1531: HttpServer parallel pipeline
[ PASS ] compat/http-test.c++:1531: HttpServer parallel pipeline (47 μs)
[ TEST ] compat/http-test.c++:1560: HttpClient <-> HttpServer
[ PASS ] compat/http-test.c++:1560: HttpClient <-> HttpServer (85 μs)
[ TEST ] compat/http-test.c++:1586: HttpInputStream requests
[ PASS ] compat/http-test.c++:1586: HttpInputStream requests (62 μs)
[ TEST ] compat/http-test.c++:1624: HttpInputStream responses
[ PASS ] compat/http-test.c++:1624: HttpInputStream responses (21 μs)
[ TEST ] compat/http-test.c++:1664: HttpInputStream bare messages
[ PASS ] compat/http-test.c++:1664: HttpInputStream bare messages (10 μs)
[ TEST ] compat/http-test.c++:1718: WebSocket core protocol
[ PASS ] compat/http-test.c++:1718: WebSocket core protocol (119 μs)
[ TEST ] compat/http-test.c++:1781: WebSocket fragmented
[ PASS ] compat/http-test.c++:1781: WebSocket fragmented (2 μs)
[ TEST ] compat/http-test.c++:1818: WebSocket masked
[ PASS ] compat/http-test.c++:1818: WebSocket masked (3 μs)
[ TEST ] compat/http-test.c++:1845: WebSocket unsolicited pong
[ PASS ] compat/http-test.c++:1845: WebSocket unsolicited pong (1 μs)
[ TEST ] compat/http-test.c++:1871: WebSocket ping
[ PASS ] compat/http-test.c++:1871: WebSocket ping (3 μs)
[ TEST ] compat/http-test.c++:1908: WebSocket ping mid-send
[ PASS ] compat/http-test.c++:1908: WebSocket ping mid-send (685 μs)
[ TEST ] compat/http-test.c++:1990: WebSocket double-ping mid-send
[ PASS ] compat/http-test.c++:1990: WebSocket double-ping mid-send (664 μs)
[ TEST ] compat/http-test.c++:2027: WebSocket ping received during pong send
[ PASS ] compat/http-test.c++:2027: WebSocket ping received during pong send (692 μs)
[ TEST ] compat/http-test.c++:2062: WebSocket pump byte counting
[ PASS ] compat/http-test.c++:2062: WebSocket pump byte counting (33 μs)
[ TEST ] compat/http-test.c++:2103: WebSocket pump disconnect on send
[ PASS ] compat/http-test.c++:2103: WebSocket pump disconnect on send (43 μs)
[ TEST ] compat/http-test.c++:2130: WebSocket pump disconnect on receive
[ PASS ] compat/http-test.c++:2130: WebSocket pump disconnect on receive (31 μs)
[ TEST ] compat/http-test.c++:2287: HttpClient WebSocket handshake
[ PASS ] compat/http-test.c++:2287: HttpClient WebSocket handshake (31 μs)
[ TEST ] compat/http-test.c++:2317: HttpClient WebSocket error
[ PASS ] compat/http-test.c++:2317: HttpClient WebSocket error (11 μs)
[ TEST ] compat/http-test.c++:2363: HttpServer WebSocket handshake
[ PASS ] compat/http-test.c++:2363: HttpServer WebSocket handshake (28 μs)
[ TEST ] compat/http-test.c++:2389: HttpServer WebSocket handshake error
[ PASS ] compat/http-test.c++:2389: HttpServer WebSocket handshake error (22 μs)
[ TEST ] compat/http-test.c++:2417: HttpServer request timeout
[ PASS ] compat/http-test.c++:2417: HttpServer request timeout (14 μs)
[ TEST ] compat/http-test.c++:2442: HttpServer pipeline timeout
[ PASS ] compat/http-test.c++:2442: HttpServer pipeline timeout (20 μs)
[ TEST ] compat/http-test.c++:2495: HttpServer no response
[ PASS ] compat/http-test.c++:2495: HttpServer no response (21 μs)
[ TEST ] compat/http-test.c++:2522: HttpServer disconnected
[ PASS ] compat/http-test.c++:2522: HttpServer disconnected (16 μs)
[ TEST ] compat/http-test.c++:2543: HttpServer overloaded
[ PASS ] compat/http-test.c++:2543: HttpServer overloaded (22 μs)
[ TEST ] compat/http-test.c++:2564: HttpServer unimplemented
[ PASS ] compat/http-test.c++:2564: HttpServer unimplemented (17 μs)
[ TEST ] compat/http-test.c++:2585: HttpServer threw exception
[ PASS ] compat/http-test.c++:2585: HttpServer threw exception (16 μs)
[ TEST ] compat/http-test.c++:2606: HttpServer bad request
[ PASS ] compat/http-test.c++:2606: HttpServer bad request (22 μs)
[ TEST ] compat/http-test.c++:2634: HttpServer invalid method
[ PASS ] compat/http-test.c++:2634: HttpServer invalid method (18 μs)
[ TEST ] compat/http-test.c++:2704: HttpServer no response, custom error handler
[ PASS ] compat/http-test.c++:2704: HttpServer no response, custom error handler (16 μs)
[ TEST ] compat/http-test.c++:2733: HttpServer threw exception, custom error handler
[ PASS ] compat/http-test.c++:2733: HttpServer threw exception, custom error handler (17 μs)
[ TEST ] compat/http-test.c++:2762: HttpServer bad request, custom error handler
[ PASS ] compat/http-test.c++:2762: HttpServer bad request, custom error handler (20 μs)
[ TEST ] compat/http-test.c++:2815: HttpServer threw exception after starting response
[ PASS ] compat/http-test.c++:2815: HttpServer threw exception after starting response (23 μs)
[ TEST ] compat/http-test.c++:2862: HttpServer failed to write complete response but didn't throw
[ PASS ] compat/http-test.c++:2862: HttpServer failed to write complete response but didn't throw (16 μs)
[ TEST ] compat/http-test.c++:2932: HttpFixedLengthEntityWriter correctly implements tryPumpFrom
[ PASS ] compat/http-test.c++:2932: HttpFixedLengthEntityWriter correctly implements tryPumpFrom (23 μs)
[ TEST ] compat/http-test.c++:2988: HttpServer cancels request when client disconnects
[ PASS ] compat/http-test.c++:2988: HttpServer cancels request when client disconnects (12 μs)
[ TEST ] compat/http-test.c++:3051: HttpServer can suspend a request
[ PASS ] compat/http-test.c++:3051: HttpServer can suspend a request (39 μs)
[ TEST ] compat/http-test.c++:3146: HttpServer can suspend and resume pipelined requests
[ PASS ] compat/http-test.c++:3146: HttpServer can suspend and resume pipelined requests (50 μs)
[ TEST ] compat/http-test.c++:3251: HttpServer can suspend a request with no leftover
[ PASS ] compat/http-test.c++:3251: HttpServer can suspend a request with no leftover (23 μs)
[ TEST ] compat/http-test.c++:3332: HttpServer::listenHttpCleanDrain() factory-created services outlive requests
[ PASS ] compat/http-test.c++:3332: HttpServer::listenHttpCleanDrain() factory-created services outlive requests (14 μs)
[ TEST ] compat/http-test.c++:3417: newHttpService from HttpClient
[ PASS ] compat/http-test.c++:3417: newHttpService from HttpClient (108 μs)
[ TEST ] compat/http-test.c++:3459: newHttpService from HttpClient WebSockets
[ PASS ] compat/http-test.c++:3459: newHttpService from HttpClient WebSockets (45 μs)
[ TEST ] compat/http-test.c++:3504: newHttpService from HttpClient WebSockets disconnect
[ PASS ] compat/http-test.c++:3504: newHttpService from HttpClient WebSockets disconnect (34 μs)
[ TEST ] compat/http-test.c++:3545: newHttpClient from HttpService
[ PASS ] compat/http-test.c++:3545: newHttpClient from HttpService (40 μs)
[ TEST ] compat/http-test.c++:3560: newHttpClient from HttpService WebSockets
[ PASS ] compat/http-test.c++:3560: newHttpClient from HttpService WebSockets (19 μs)
[ TEST ] compat/http-test.c++:3574: adapted client/server propagates request exceptions like non-adapted client
[ PASS ] compat/http-test.c++:3574: adapted client/server propagates request exceptions like non-adapted client (88 μs)
[ TEST ] compat/http-test.c++:3669: adapted client waits for service to complete before returning EOF on response stream
[ PASS ] compat/http-test.c++:3669: adapted client waits for service to complete before returning EOF on response stream (7 μs)
[ TEST ] compat/http-test.c++:3673: adapted client waits for service to complete before returning EOF on chunked response
[ PASS ] compat/http-test.c++:3673: adapted client waits for service to complete before returning EOF on chunked response (4 μs)
[ TEST ] compat/http-test.c++:3677: adapted client propagates throw from service after complete response body sent
[ PASS ] compat/http-test.c++:3677: adapted client propagates throw from service after complete response body sent (28 μs)
[ TEST ] compat/http-test.c++:3681: adapted client propagates throw from service after incomplete response body sent
[ PASS ] compat/http-test.c++:3681: adapted client propagates throw from service after incomplete response body sent (40 μs)
[ TEST ] compat/http-test.c++:3685: adapted client propagates throw from service after chunked response body sent
[ PASS ] compat/http-test.c++:3685: adapted client propagates throw from service after chunked response body sent (26 μs)
[ TEST ] compat/http-test.c++:3778: adapted client waits for service to complete before completing upstream close on WebSocket
[ PASS ] compat/http-test.c++:3778: adapted client waits for service to complete before completing upstream close on WebSocket (9 μs)
[ TEST ] compat/http-test.c++:3782: adapted client waits for service to complete before returning downstream close on WebSocket
[ PASS ] compat/http-test.c++:3782: adapted client waits for service to complete before returning downstream close on WebSocket (7 μs)
[ TEST ] compat/http-test.c++:3786: adapted client propagates throw from service after WebSocket upstream close sent
[ PASS ] compat/http-test.c++:3786: adapted client propagates throw from service after WebSocket upstream close sent (27 μs)
[ TEST ] compat/http-test.c++:3790: adapted client propagates throw from service after WebSocket downstream close sent
[ PASS ] compat/http-test.c++:3790: adapted client propagates throw from service after WebSocket downstream close sent (27 μs)
[ TEST ] compat/http-test.c++:3939: HttpClient connection management
[ PASS ] compat/http-test.c++:3939: HttpClient connection management (359 μs)
[ TEST ] compat/http-test.c++:4091: HttpClient disable connection reuse
[ PASS ] compat/http-test.c++:4091: HttpClient disable connection reuse (93 μs)
[ TEST ] compat/http-test.c++:4145: HttpClient concurrency limiting
[ PASS ] compat/http-test.c++:4145: HttpClient concurrency limiting (122 μs)
[ TEST ] compat/http-test.c++:4467: canceling a length stream mid-read correctly discards rest of request
[ PASS ] compat/http-test.c++:4467: canceling a length stream mid-read correctly discards rest of request (28 μs)
[ TEST ] compat/http-test.c++:4517: canceling a chunked stream mid-read correctly discards rest of request
[ PASS ] compat/http-test.c++:4517: canceling a chunked stream mid-read correctly discards rest of request (26 μs)
[ TEST ] compat/http-test.c++:4572: drain() doesn't lose bytes when called at the wrong moment
[ PASS ] compat/http-test.c++:4572: drain() doesn't lose bytes when called at the wrong moment (20 μs)
[ TEST ] compat/http-test.c++:4676: HttpServer.listenHttp() doesn't prematurely terminate if an accepted connection is broken
[ PASS ] compat/http-test.c++:4676: HttpServer.listenHttp() doesn't prematurely terminate if an accepted connection is broken (17 μs)
[ TEST ] compat/gzip-test.c++:133: gzip decompression
[ PASS ] compat/gzip-test.c++:133: gzip decompression (45 μs)
[ TEST ] compat/gzip-test.c++:174: async gzip decompression
[ PASS ] compat/gzip-test.c++:174: async gzip decompression (50 μs)
[ TEST ] compat/gzip-test.c++:234: gzip compression
[ PASS ] compat/gzip-test.c++:234: gzip compression (22 μs)
[ TEST ] compat/gzip-test.c++:276: gzip huge round trip
[ PASS ] compat/gzip-test.c++:276: gzip huge round trip (1728 μs)
[ TEST ] compat/gzip-test.c++:296: async gzip compression
[ PASS ] compat/gzip-test.c++:296: async gzip compression (25 μs)
[ TEST ] compat/gzip-test.c++:346: async gzip huge round trip
[ PASS ] compat/gzip-test.c++:346: async gzip huge round trip (1757 μs)
[ TEST ] compat/tls-test.c++:457: TLS basics
[ PASS ] compat/tls-test.c++:457: TLS basics (9091 μs)
[ TEST ] compat/tls-test.c++:472: TLS peer identity
[ PASS ] compat/tls-test.c++:472: TLS peer identity (5563 μs)
[ TEST ] compat/tls-test.c++:512: TLS multiple messages
[ PASS ] compat/tls-test.c++:512: TLS multiple messages (5583 μs)
[ TEST ] compat/tls-test.c++:552: TLS zero-sized write
[ PASS ] compat/tls-test.c++:552: TLS zero-sized write (5513 μs)
[ TEST ] compat/tls-test.c++:598: TLS full duplex
[ PASS ] compat/tls-test.c++:598: TLS full duplex (55328 μs)
[ TEST ] compat/tls-test.c++:649: TLS SNI
[ PASS ] compat/tls-test.c++:649: TLS SNI (7108 μs)
[ TEST ] compat/tls-test.c++:685: TLS certificate validation
kj/compat/tls-test.c++:682: failed: expected ::kj::_::hasSubstring(e->getDescription(), message); exception description didn't contain expected substring; *e = kj/compat/tls.c++:170: failed: TLS peer's certificate is not trusted; reason = hostname mismatch
stack: 7f13fd8ef7a9 7f13fd8efdca 7f13fd80b2f1 7f13fd8dfb20 56531139aba0 56531139a050 56531127dc89 56531139d046
stack: 56531139e50b 5653113a3467 5653113a35d8 7f13fd7bf49d 7f13fd752e68 7f13fd7c0079 7f13fd7c08c0 7f13fd767e99 7f13fd752e68 7f13fd764341 7f13fd7be4cb 7f13fd33f189 7f13fd33f244 5653111838e0
kj/compat/tls-test.c++:682: failed: expected ::kj::_::hasSubstring(e->getDescription(), message); exception description didn't contain expected substring; *e = kj/compat/tls.c++:170: failed: TLS peer's certificate is not trusted; reason = self-signed certificate
stack: 7f13fd8ef7a9 7f13fd8efdca 7f13fd80b2f1 7f13fd8dfb20 56531139aba0 56531139a050 56531127dc89 56531139d046
stack: 56531139e50b 5653113a3467 5653113a3729 7f13fd7bf49d 7f13fd752e68 7f13fd7c0079 7f13fd7c08c0 7f13fd767e99 7f13fd752e68 7f13fd764341 7f13fd7be4cb 7f13fd33f189 7f13fd33f244 5653111838e0
[ FAIL ] compat/tls-test.c++:685: TLS certificate validation (27495 μs)
[ TEST ] compat/tls-test.c++:703: TLS client certificate verification
[ PASS ] compat/tls-test.c++:703: TLS client certificate verification (40241 μs)
[ TEST ] compat/tls-test.c++:953: TLS receiver basics
[ PASS ] compat/tls-test.c++:953: TLS receiver basics (5546 μs)
[ TEST ] compat/tls-test.c++:967: TLS receiver experiences pre-TLS error
[ PASS ] compat/tls-test.c++:967: TLS receiver experiences pre-TLS error (325 μs)
[ TEST ] compat/tls-test.c++:993: TLS receiver accepts multiple clients
[ PASS ] compat/tls-test.c++:993: TLS receiver accepts multiple clients (102957 μs)
[ TEST ] compat/tls-test.c++:1030: TLS receiver does not stall on client that disconnects before ssl handshake
kj/compat/tls.c++:377: unimplemented bio_ctrl; cmd = 2
[ PASS ] compat/tls-test.c++:1030: TLS receiver does not stall on client that disconnects before ssl handshake (103966 μs)
[ TEST ] compat/tls-test.c++:1076: TLS receiver does not stall on hung client
kj/compat/tls.c++:377: unimplemented bio_ctrl; cmd = 2
[ PASS ] compat/tls-test.c++:1076: TLS receiver does not stall on hung client (103703 μs)
429 test(s) passed 
1 test(s) failed 
<end of output>
Test time =   0.96 sec
----------------------------------------------------------
Test Failed.
"kj-heavy-tests-run" end time: Dec 18 08:24 CET
"kj-heavy-tests-run" time elapsed: 00:00:00
----------------------------------------------------------

3/5 Testing: capnp-tests-run
3/5 Test: capnp-tests-run
Command: "/var/tmp/portage/dev-libs/capnproto-0.10.2/work/capnproto-0.10.2/c++_build/src/capnp/capnp-tests"
Directory: /var/tmp/portage/dev-libs/capnproto-0.10.2/work/capnproto-0.10.2/c++_build/src/capnp
"capnp-tests-run" start time: Dec 18 08:24 CET
Output:
----------------------------------------------------------
[ TEST ] common-test.c++:35: legacy test: Common/Version
[ PASS ] common-test.c++:35: legacy test: Common/Version (3 μs)
[ TEST ] blob-test.c++:34: legacy test: Blob/Text
[ PASS ] blob-test.c++:34: legacy test: Blob/Text (0 μs)
[ TEST ] blob-test.c++:60: legacy test: Blob/Data
[ PASS ] blob-test.c++:60: legacy test: Blob/Data (0 μs)
[ TEST ] blob-test.c++:79: legacy test: Blob/Compare
[ PASS ] blob-test.c++:79: legacy test: Blob/Compare (0 μs)
[ TEST ] blob-test.c++:117: legacy test: Blob/StlInterop
[ PASS ] blob-test.c++:117: legacy test: Blob/StlInterop (3 μs)
[ TEST ] endian-test.c++:33: legacy test: Endian/Byte
[ PASS ] endian-test.c++:33: legacy test: Endian/Byte (0 μs)
[ TEST ] endian-test.c++:54: legacy test: Endian/TwoBytes
[ PASS ] endian-test.c++:54: legacy test: Endian/TwoBytes (0 μs)
[ TEST ] endian-test.c++:71: legacy test: Endian/FourBytes
[ PASS ] endian-test.c++:71: legacy test: Endian/FourBytes (0 μs)
[ TEST ] endian-test.c++:86: legacy test: Endian/EightBytes
[ PASS ] endian-test.c++:86: legacy test: Endian/EightBytes (0 μs)
[ TEST ] endian-test.c++:33: legacy test: Endian/Byte
[ PASS ] endian-test.c++:33: legacy test: Endian/Byte (0 μs)
[ TEST ] endian-test.c++:54: legacy test: Endian/TwoBytes
[ PASS ] endian-test.c++:54: legacy test: Endian/TwoBytes (0 μs)
[ TEST ] endian-test.c++:71: legacy test: Endian/FourBytes
[ PASS ] endian-test.c++:71: legacy test: Endian/FourBytes (0 μs)
[ TEST ] endian-test.c++:86: legacy test: Endian/EightBytes
[ PASS ] endian-test.c++:86: legacy test: Endian/EightBytes (0 μs)
[ TEST ] layout-test.c++:52: legacy test: WireFormat/SimpleRawDataStruct
[ PASS ] layout-test.c++:52: legacy test: WireFormat/SimpleRawDataStruct (5 μs)
[ TEST ] layout-test.c++:289: legacy test: WireFormat/StructRoundTrip_OneSegment
[ PASS ] layout-test.c++:289: legacy test: WireFormat/StructRoundTrip_OneSegment (34 μs)
[ TEST ] layout-test.c++:327: legacy test: WireFormat/StructRoundTrip_OneSegmentPerAllocation
[ PASS ] layout-test.c++:327: legacy test: WireFormat/StructRoundTrip_OneSegmentPerAllocation (9 μs)
[ TEST ] layout-test.c++:366: legacy test: WireFormat/StructRoundTrip_MultipleSegmentsWithMultipleAllocations
[ PASS ] layout-test.c++:366: legacy test: WireFormat/StructRoundTrip_MultipleSegmentsWithMultipleAllocations (2 μs)
[ TEST ] layout-test.c++:399: legacy test: WireFormat/NanPatching
[ PASS ] layout-test.c++:399: legacy test: WireFormat/NanPatching (0 μs)
[ TEST ] any-test.c++:31: legacy test: Any/AnyPointer
[ PASS ] any-test.c++:31: legacy test: Any/AnyPointer (62 μs)
[ TEST ] any-test.c++:109: legacy test: Any/AnyStruct
[ PASS ] any-test.c++:109: legacy test: Any/AnyStruct (10 μs)
[ TEST ] any-test.c++:181: legacy test: Any/AnyList
[ PASS ] any-test.c++:181: legacy test: Any/AnyList (4 μs)
[ TEST ] any-test.c++:229: legacy test: Any/AnyStructListCapInSchema
[ PASS ] any-test.c++:229: legacy test: Any/AnyStructListCapInSchema (85 μs)
[ TEST ] any-test.c++:285: Builder::isStruct() does not corrupt segment pointer
[ PASS ] any-test.c++:285: Builder::isStruct() does not corrupt segment pointer (6 μs)
[ TEST ] any-test.c++:307: legacy test: Any/Equals
[ PASS ] any-test.c++:307: legacy test: Any/Equals (55 μs)
[ TEST ] any-test.c++:357: Bit list with nonzero pad bits
[ PASS ] any-test.c++:357: Bit list with nonzero pad bits (7 μs)
[ TEST ] any-test.c++:380: Pointer list unequal to struct list
[ PASS ] any-test.c++:380: Pointer list unequal to struct list (0 μs)
[ TEST ] any-test.c++:405: Truncating non-null pointer fields does not preserve equality
[ PASS ] any-test.c++:405: Truncating non-null pointer fields does not preserve equality (0 μs)
[ TEST ] message-test.c++:33: legacy test: Message/MallocBuilderWithFirstSegment
[ PASS ] message-test.c++:33: legacy test: Message/MallocBuilderWithFirstSegment (2 μs)
[ TEST ] message-test.c++:65: legacy test: Message/MessageBuilderInit
[ PASS ] message-test.c++:65: legacy test: Message/MessageBuilderInit (9 μs)
[ TEST ] message-test.c++:93: legacy test: Message/MessageBuilderInitMultiSegment
[ PASS ] message-test.c++:93: legacy test: Message/MessageBuilderInitMultiSegment (12 μs)
[ TEST ] message-test.c++:123: legacy test: Message/MessageBuilderInitSpaceAvailable
[ PASS ] message-test.c++:123: legacy test: Message/MessageBuilderInitSpaceAvailable (5 μs)
[ TEST ] message-test.c++:154: legacy test: Message/ReadWriteDataStruct
[ PASS ] message-test.c++:154: legacy test: Message/ReadWriteDataStruct (4 μs)
[ TEST ] message-test.c++:171: clone()
[ PASS ] message-test.c++:171: clone() (13 μs)
[ TEST ] message-test.c++:180: disallow unaligned
[ PASS ] message-test.c++:180: disallow unaligned (70 μs)
[ TEST ] encoding-test.c++:35: legacy test: Encoding/AllTypes
[ PASS ] encoding-test.c++:35: legacy test: Encoding/AllTypes (8 μs)
[ TEST ] encoding-test.c++:54: legacy test: Encoding/AllTypesMultiSegment
[ PASS ] encoding-test.c++:54: legacy test: Encoding/AllTypesMultiSegment (21 μs)
[ TEST ] encoding-test.c++:66: legacy test: Encoding/Defaults
[ PASS ] encoding-test.c++:66: legacy test: Encoding/Defaults (10 μs)
[ TEST ] encoding-test.c++:77: legacy test: Encoding/DefaultInitialization
[ PASS ] encoding-test.c++:77: legacy test: Encoding/DefaultInitialization (16 μs)
[ TEST ] encoding-test.c++:91: legacy test: Encoding/DefaultInitializationMultiSegment
[ PASS ] encoding-test.c++:91: legacy test: Encoding/DefaultInitializationMultiSegment (21 μs)
[ TEST ] encoding-test.c++:107: legacy test: Encoding/DefaultsFromEmptyMessage
[ PASS ] encoding-test.c++:107: legacy test: Encoding/DefaultsFromEmptyMessage (2 μs)
[ TEST ] encoding-test.c++:117: legacy test: Encoding/Unions
[ PASS ] encoding-test.c++:117: legacy test: Encoding/Unions (2 μs)
[ TEST ] encoding-test.c++:194: legacy test: Encoding/UnionLayout
[ PASS ] encoding-test.c++:194: legacy test: Encoding/UnionLayout (11 μs)
[ TEST ] encoding-test.c++:250: legacy test: Encoding/UnnamedUnion
[ PASS ] encoding-test.c++:250: legacy test: Encoding/UnnamedUnion (5 μs)
[ TEST ] encoding-test.c++:281: legacy test: Encoding/Groups
[ PASS ] encoding-test.c++:281: legacy test: Encoding/Groups (1 μs)
[ TEST ] encoding-test.c++:319: legacy test: Encoding/InterleavedGroups
[ PASS ] encoding-test.c++:319: legacy test: Encoding/InterleavedGroups (1 μs)
[ TEST ] encoding-test.c++:385: legacy test: Encoding/UnionDefault
[ PASS ] encoding-test.c++:385: legacy test: Encoding/UnionDefault (4 μs)
[ TEST ] encoding-test.c++:432: legacy test: Encoding/ListDefaults
[ PASS ] encoding-test.c++:432: legacy test: Encoding/ListDefaults (6 μs)
[ TEST ] encoding-test.c++:441: legacy test: Encoding/BuildListDefaults
[ PASS ] encoding-test.c++:441: legacy test: Encoding/BuildListDefaults (3 μs)
[ TEST ] encoding-test.c++:451: legacy test: Encoding/SmallStructLists
[ PASS ] encoding-test.c++:451: legacy test: Encoding/SmallStructLists (9 μs)
[ TEST ] encoding-test.c++:520: legacy test: Encoding/SetListToEmpty
[ PASS ] encoding-test.c++:520: legacy test: Encoding/SetListToEmpty (6 μs)
[ TEST ] encoding-test.c++:615: legacy test: Encoding/ListUpgrade
[ PASS ] encoding-test.c++:615: legacy test: Encoding/ListUpgrade (33 μs)
[ TEST ] encoding-test.c++:671: legacy test: Encoding/BitListDowngrade
[ PASS ] encoding-test.c++:671: legacy test: Encoding/BitListDowngrade (33 μs)
[ TEST ] encoding-test.c++:710: legacy test: Encoding/BitListDowngradeFromStruct
[ PASS ] encoding-test.c++:710: legacy test: Encoding/BitListDowngradeFromStruct (23 μs)
[ TEST ] encoding-test.c++:747: legacy test: Encoding/BitListUpgrade
[ PASS ] encoding-test.c++:747: legacy test: Encoding/BitListUpgrade (23 μs)
[ TEST ] encoding-test.c++:780: legacy test: Encoding/UpgradeStructInBuilder
[ PASS ] encoding-test.c++:780: legacy test: Encoding/UpgradeStructInBuilder (2 μs)
[ TEST ] encoding-test.c++:887: legacy test: Encoding/UpgradeStructInBuilderMultiSegment
[ PASS ] encoding-test.c++:887: legacy test: Encoding/UpgradeStructInBuilderMultiSegment (4 μs)
[ TEST ] encoding-test.c++:994: legacy test: Encoding/UpgradeStructInBuilderFarPointers
[ PASS ] encoding-test.c++:994: legacy test: Encoding/UpgradeStructInBuilderFarPointers (0 μs)
[ TEST ] encoding-test.c++:1016: legacy test: Encoding/UpgradeStructInBuilderDoubleFarPointers
[ PASS ] encoding-test.c++:1016: legacy test: Encoding/UpgradeStructInBuilderDoubleFarPointers (0 μs)
[ TEST ] encoding-test.c++:1089: legacy test: Encoding/UpgradeListInBuilder
[ PASS ] encoding-test.c++:1089: legacy test: Encoding/UpgradeListInBuilder (462 μs)
[ TEST ] encoding-test.c++:1325: legacy test: Encoding/UpgradeUnion
[ PASS ] encoding-test.c++:1325: legacy test: Encoding/UpgradeUnion (0 μs)
[ TEST ] encoding-test.c++:1345: legacy test: Encoding/NestedTypes
[ PASS ] encoding-test.c++:1345: legacy test: Encoding/NestedTypes (0 μs)
[ TEST ] encoding-test.c++:1359: legacy test: Encoding/Imports
[ PASS ] encoding-test.c++:1359: legacy test: Encoding/Imports (12 μs)
[ TEST ] encoding-test.c++:1380: legacy test: Encoding/Using
[ PASS ] encoding-test.c++:1380: legacy test: Encoding/Using (0 μs)
[ TEST ] encoding-test.c++:1387: legacy test: Encoding/StructSetters
[ PASS ] encoding-test.c++:1387: legacy test: Encoding/StructSetters (12 μs)
[ TEST ] encoding-test.c++:1413: legacy test: Encoding/OneBitStructSetters
[ PASS ] encoding-test.c++:1413: legacy test: Encoding/OneBitStructSetters (0 μs)
[ TEST ] encoding-test.c++:1435: legacy test: Encoding/ListSetters
[ PASS ] encoding-test.c++:1435: legacy test: Encoding/ListSetters (12 μs)
[ TEST ] encoding-test.c++:1528: legacy test: Encoding/ZeroOldObject
[ PASS ] encoding-test.c++:1528: legacy test: Encoding/ZeroOldObject (5 μs)
[ TEST ] encoding-test.c++:1546: legacy test: Encoding/Has
[ PASS ] encoding-test.c++:1546: legacy test: Encoding/Has (1 μs)
[ TEST ] encoding-test.c++:1574: legacy test: Encoding/VoidListAmplification
[ PASS ] encoding-test.c++:1574: legacy test: Encoding/VoidListAmplification (32 μs)
[ TEST ] encoding-test.c++:1590: legacy test: Encoding/EmptyStructListAmplification
[ PASS ] encoding-test.c++:1590: legacy test: Encoding/EmptyStructListAmplification (32 μs)
[ TEST ] encoding-test.c++:1611: legacy test: Encoding/Constants
[ PASS ] encoding-test.c++:1611: legacy test: Encoding/Constants (9 μs)
[ TEST ] encoding-test.c++:1713: legacy test: Encoding/AnyPointerConstants
[ PASS ] encoding-test.c++:1713: legacy test: Encoding/AnyPointerConstants (0 μs)
[ TEST ] encoding-test.c++:1723: legacy test: Encoding/GlobalConstants
[ PASS ] encoding-test.c++:1723: legacy test: Encoding/GlobalConstants (1 μs)
[ TEST ] encoding-test.c++:1743: legacy test: Encoding/Embeds
[ PASS ] encoding-test.c++:1743: legacy test: Encoding/Embeds (222 μs)
[ TEST ] encoding-test.c++:1767: legacy test: Encoding/HasEmptyStruct
[ PASS ] encoding-test.c++:1767: legacy test: Encoding/HasEmptyStruct (1 μs)
[ TEST ] encoding-test.c++:1782: legacy test: Encoding/HasEmptyList
[ PASS ] encoding-test.c++:1782: legacy test: Encoding/HasEmptyList (0 μs)
[ TEST ] encoding-test.c++:1797: legacy test: Encoding/HasEmptyStructList
[ PASS ] encoding-test.c++:1797: legacy test: Encoding/HasEmptyStructList (0 μs)
[ TEST ] encoding-test.c++:1812: legacy test: Encoding/NameAnnotation
[ PASS ] encoding-test.c++:1812: legacy test: Encoding/NameAnnotation (0 μs)
[ TEST ] encoding-test.c++:1853: legacy test: Encoding/DefaultFloatPlusNan
[ PASS ] encoding-test.c++:1853: legacy test: Encoding/DefaultFloatPlusNan (0 μs)
[ TEST ] encoding-test.c++:1867: legacy test: Encoding/WholeFloatDefault
[ PASS ] encoding-test.c++:1867: legacy test: Encoding/WholeFloatDefault (0 μs)
[ TEST ] encoding-test.c++:1877: legacy test: Encoding/Generics
[ PASS ] encoding-test.c++:1877: legacy test: Encoding/Generics (25 μs)
[ TEST ] encoding-test.c++:1936: legacy test: Encoding/GenericDefaults
[ PASS ] encoding-test.c++:1936: legacy test: Encoding/GenericDefaults (1 μs)
[ TEST ] encoding-test.c++:1950: legacy test: Encoding/UnionInGenerics
[ PASS ] encoding-test.c++:1950: legacy test: Encoding/UnionInGenerics (0 μs)
[ TEST ] encoding-test.c++:1974: legacy test: Encoding/DefaultListBuilder
[ PASS ] encoding-test.c++:1974: legacy test: Encoding/DefaultListBuilder (0 μs)
[ TEST ] encoding-test.c++:1983: legacy test: Encoding/ListSize
[ PASS ] encoding-test.c++:1983: legacy test: Encoding/ListSize (3 μs)
[ TEST ] encoding-test.c++:2009: list.setWithCaveats(i, list[i]) doesn't corrupt contents
[ PASS ] encoding-test.c++:2009: list.setWithCaveats(i, list[i]) doesn't corrupt contents (10 μs)
[ TEST ] orphan-test.c++:31: legacy test: Orphans/Structs
[ PASS ] orphan-test.c++:31: legacy test: Orphans/Structs (8 μs)
[ TEST ] orphan-test.c++:51: legacy test: Orphans/EmptyStruct
[ PASS ] orphan-test.c++:51: legacy test: Orphans/EmptyStruct (1 μs)
[ TEST ] orphan-test.c++:62: legacy test: Orphans/EmptyStructOverwrite
[ PASS ] orphan-test.c++:62: legacy test: Orphans/EmptyStructOverwrite (0 μs)
[ TEST ] orphan-test.c++:74: legacy test: Orphans/AdoptNullStruct
[ PASS ] orphan-test.c++:74: legacy test: Orphans/AdoptNullStruct (0 μs)
[ TEST ] orphan-test.c++:85: legacy test: Orphans/Lists
[ PASS ] orphan-test.c++:85: legacy test: Orphans/Lists (5 μs)
[ TEST ] orphan-test.c++:105: legacy test: Orphans/StructLists
[ PASS ] orphan-test.c++:105: legacy test: Orphans/StructLists (2 μs)
[ TEST ] orphan-test.c++:133: legacy test: Orphans/Text
[ PASS ] orphan-test.c++:133: legacy test: Orphans/Text (2 μs)
[ TEST ] orphan-test.c++:153: legacy test: Orphans/Data
[ PASS ] orphan-test.c++:153: legacy test: Orphans/Data (1 μs)
[ TEST ] orphan-test.c++:173: legacy test: Orphans/NoCrossMessageTransfers
[ PASS ] orphan-test.c++:173: legacy test: Orphans/NoCrossMessageTransfers (28 μs)
[ TEST ] orphan-test.c++:184: legacy test: Orphans/OrphanageStruct
[ PASS ] orphan-test.c++:184: legacy test: Orphans/OrphanageStruct (2 μs)
[ TEST ] orphan-test.c++:195: legacy test: Orphans/OrphanageList
[ PASS ] orphan-test.c++:195: legacy test: Orphans/OrphanageList (1 μs)
[ TEST ] orphan-test.c++:211: legacy test: Orphans/OrphanageText
[ PASS ] orphan-test.c++:211: legacy test: Orphans/OrphanageText (1 μs)
[ TEST ] orphan-test.c++:223: legacy test: Orphans/OrphanageData
[ PASS ] orphan-test.c++:223: legacy test: Orphans/OrphanageData (1 μs)
[ TEST ] orphan-test.c++:238: legacy test: Orphans/OrphanageStructCopy
[ PASS ] orphan-test.c++:238: legacy test: Orphans/OrphanageStructCopy (9 μs)
[ TEST ] orphan-test.c++:252: legacy test: Orphans/OrphanageListCopy
[ PASS ] orphan-test.c++:252: legacy test: Orphans/OrphanageListCopy (1 μs)
[ TEST ] orphan-test.c++:267: legacy test: Orphans/OrphanageTextCopy
[ PASS ] orphan-test.c++:267: legacy test: Orphans/OrphanageTextCopy (1 μs)
[ TEST ] orphan-test.c++:277: legacy test: Orphans/OrphanageDataCopy
[ PASS ] orphan-test.c++:277: legacy test: Orphans/OrphanageDataCopy (1 μs)
[ TEST ] orphan-test.c++:287: legacy test: Orphans/ZeroOut
[ PASS ] orphan-test.c++:287: legacy test: Orphans/ZeroOut (4 μs)
[ TEST ] orphan-test.c++:302: legacy test: Orphans/StructAnyPointer
[ PASS ] orphan-test.c++:302: legacy test: Orphans/StructAnyPointer (3 μs)
[ TEST ] orphan-test.c++:321: legacy test: Orphans/ListAnyPointer
[ PASS ] orphan-test.c++:321: legacy test: Orphans/ListAnyPointer (0 μs)
[ TEST ] orphan-test.c++:341: legacy test: Orphans/DynamicStruct
[ PASS ] orphan-test.c++:341: legacy test: Orphans/DynamicStruct (70 μs)
[ TEST ] orphan-test.c++:367: legacy test: Orphans/DynamicList
[ PASS ] orphan-test.c++:367: legacy test: Orphans/DynamicList (2 μs)
[ TEST ] orphan-test.c++:391: legacy test: Orphans/DynamicStructList
[ PASS ] orphan-test.c++:391: legacy test: Orphans/DynamicStructList (5 μs)
[ TEST ] orphan-test.c++:419: legacy test: Orphans/OrphanageDynamicStruct
[ PASS ] orphan-test.c++:419: legacy test: Orphans/OrphanageDynamicStruct (61 μs)
[ TEST ] orphan-test.c++:431: legacy test: Orphans/OrphanageDynamicList
[ PASS ] orphan-test.c++:431: legacy test: Orphans/OrphanageDynamicList (2 μs)
[ TEST ] orphan-test.c++:445: legacy test: Orphans/OrphanageDynamicStructCopy
[ PASS ] orphan-test.c++:445: legacy test: Orphans/OrphanageDynamicStructCopy (26 μs)
[ TEST ] orphan-test.c++:461: legacy test: Orphans/OrphanageDynamicListCopy
[ PASS ] orphan-test.c++:461: legacy test: Orphans/OrphanageDynamicListCopy (1 μs)
[ TEST ] orphan-test.c++:477: legacy test: Orphans/DynamicStructAs
[ PASS ] orphan-test.c++:477: legacy test: Orphans/DynamicStructAs (73 μs)
[ TEST ] orphan-test.c++:519: legacy test: Orphans/DynamicListAs
[ PASS ] orphan-test.c++:519: legacy test: Orphans/DynamicListAs (2 μs)
[ TEST ] orphan-test.c++:561: legacy test: Orphans/DynamicAnyPointer
[ PASS ] orphan-test.c++:561: legacy test: Orphans/DynamicAnyPointer (27 μs)
[ TEST ] orphan-test.c++:576: legacy test: Orphans/DynamicDisown
[ PASS ] orphan-test.c++:576: legacy test: Orphans/DynamicDisown (31 μs)
[ TEST ] orphan-test.c++:603: legacy test: Orphans/DynamicDisownGroup
[ PASS ] orphan-test.c++:603: legacy test: Orphans/DynamicDisownGroup (14 μs)
[ TEST ] orphan-test.c++:628: legacy test: Orphans/OrphanageFromBuilder
[ PASS ] orphan-test.c++:628: legacy test: Orphans/OrphanageFromBuilder (13 μs)
[ TEST ] orphan-test.c++:675: legacy test: Orphans/StructsZerodAfterUse
[ PASS ] orphan-test.c++:675: legacy test: Orphans/StructsZerodAfterUse (3 μs)
[ TEST ] orphan-test.c++:694: legacy test: Orphans/ListsZerodAfterUse
[ PASS ] orphan-test.c++:694: legacy test: Orphans/ListsZerodAfterUse (0 μs)
[ TEST ] orphan-test.c++:713: legacy test: Orphans/EmptyListsZerodAfterUse
[ PASS ] orphan-test.c++:713: legacy test: Orphans/EmptyListsZerodAfterUse (0 μs)
[ TEST ] orphan-test.c++:732: legacy test: Orphans/StructListsZerodAfterUse
[ PASS ] orphan-test.c++:732: legacy test: Orphans/StructListsZerodAfterUse (6 μs)
[ TEST ] orphan-test.c++:755: legacy test: Orphans/EmptyStructListsZerodAfterUse
[ PASS ] orphan-test.c++:755: legacy test: Orphans/EmptyStructListsZerodAfterUse (0 μs)
[ TEST ] orphan-test.c++:774: legacy test: Orphans/TextZerodAfterUse
[ PASS ] orphan-test.c++:774: legacy test: Orphans/TextZerodAfterUse (0 μs)
[ TEST ] orphan-test.c++:793: legacy test: Orphans/DataZerodAfterUse
[ PASS ] orphan-test.c++:793: legacy test: Orphans/DataZerodAfterUse (0 μs)
[ TEST ] orphan-test.c++:812: legacy test: Orphans/FarPointer
[ PASS ] orphan-test.c++:812: legacy test: Orphans/FarPointer (14 μs)
[ TEST ] orphan-test.c++:827: legacy test: Orphans/UpgradeStruct
[ PASS ] orphan-test.c++:827: legacy test: Orphans/UpgradeStruct (2 μs)
[ TEST ] orphan-test.c++:852: legacy test: Orphans/UpgradeStructList
[ PASS ] orphan-test.c++:852: legacy test: Orphans/UpgradeStructList (1 μs)
[ TEST ] orphan-test.c++:881: legacy test: Orphans/DisownNull
[ PASS ] orphan-test.c++:881: legacy test: Orphans/DisownNull (2 μs)
[ TEST ] orphan-test.c++:920: legacy test: Orphans/ReferenceExternalData
[ PASS ] orphan-test.c++:920: legacy test: Orphans/ReferenceExternalData (53 μs)
[ TEST ] orphan-test.c++:988: legacy test: Orphans/ReferenceExternalData_NoZeroOnSet
[ PASS ] orphan-test.c++:988: legacy test: Orphans/ReferenceExternalData_NoZeroOnSet (0 μs)
[ TEST ] orphan-test.c++:1010: legacy test: Orphans/ReferenceExternalData_NoZeroImmediateAbandon
[ PASS ] orphan-test.c++:1010: legacy test: Orphans/ReferenceExternalData_NoZeroImmediateAbandon (0 μs)
[ TEST ] orphan-test.c++:1029: legacy test: Orphans/TruncateData
[ PASS ] orphan-test.c++:1029: legacy test: Orphans/TruncateData (2 μs)
[ TEST ] orphan-test.c++:1050: legacy test: Orphans/ExtendData
[ PASS ] orphan-test.c++:1050: legacy test: Orphans/ExtendData (0 μs)
[ TEST ] orphan-test.c++:1072: legacy test: Orphans/ExtendDataCopy
[ PASS ] orphan-test.c++:1072: legacy test: Orphans/ExtendDataCopy (0 μs)
[ TEST ] orphan-test.c++:1098: legacy test: Orphans/ExtendDataFromEmpty
[ PASS ] orphan-test.c++:1098: legacy test: Orphans/ExtendDataFromEmpty (0 μs)
[ TEST ] orphan-test.c++:1112: legacy test: Orphans/TruncateText
[ PASS ] orphan-test.c++:1112: legacy test: Orphans/TruncateText (1 μs)
[ TEST ] orphan-test.c++:1133: legacy test: Orphans/ExtendText
[ PASS ] orphan-test.c++:1133: legacy test: Orphans/ExtendText (0 μs)
[ TEST ] orphan-test.c++:1155: legacy test: Orphans/ExtendTextCopy
[ PASS ] orphan-test.c++:1155: legacy test: Orphans/ExtendTextCopy (0 μs)
[ TEST ] orphan-test.c++:1181: legacy test: Orphans/ExtendTextFromEmpty
[ PASS ] orphan-test.c++:1181: legacy test: Orphans/ExtendTextFromEmpty (0 μs)
[ TEST ] orphan-test.c++:1195: legacy test: Orphans/TruncatePrimitiveList
[ PASS ] orphan-test.c++:1195: legacy test: Orphans/TruncatePrimitiveList (0 μs)
[ TEST ] orphan-test.c++:1224: legacy test: Orphans/ExtendPrimitiveList
[ PASS ] orphan-test.c++:1224: legacy test: Orphans/ExtendPrimitiveList (0 μs)
[ TEST ] orphan-test.c++:1253: legacy test: Orphans/ExtendPrimitiveListCopy
[ PASS ] orphan-test.c++:1253: legacy test: Orphans/ExtendPrimitiveListCopy (0 μs)
[ TEST ] orphan-test.c++:1285: legacy test: Orphans/ExtendPointerListFromEmpty
[ PASS ] orphan-test.c++:1285: legacy test: Orphans/ExtendPointerListFromEmpty (0 μs)
[ TEST ] orphan-test.c++:1299: legacy test: Orphans/TruncatePointerList
[ PASS ] orphan-test.c++:1299: legacy test: Orphans/TruncatePointerList (2 μs)
[ TEST ] orphan-test.c++:1336: legacy test: Orphans/ExtendPointerList
[ PASS ] orphan-test.c++:1336: legacy test: Orphans/ExtendPointerList (2 μs)
[ TEST ] orphan-test.c++:1373: legacy test: Orphans/ExtendPointerListCopy
[ PASS ] orphan-test.c++:1373: legacy test: Orphans/ExtendPointerListCopy (2 μs)
[ TEST ] orphan-test.c++:1412: legacy test: Orphans/ExtendPointerListFromEmpty
[ PASS ] orphan-test.c++:1412: legacy test: Orphans/ExtendPointerListFromEmpty (0 μs)
[ TEST ] orphan-test.c++:1426: legacy test: Orphans/TruncateStructList
[ PASS ] orphan-test.c++:1426: legacy test: Orphans/TruncateStructList (8 μs)
[ TEST ] orphan-test.c++:1472: legacy test: Orphans/ExtendStructList
[ PASS ] orphan-test.c++:1472: legacy test: Orphans/ExtendStructList (7 μs)
[ TEST ] orphan-test.c++:1516: legacy test: Orphans/ExtendStructListCopy
[ PASS ] orphan-test.c++:1516: legacy test: Orphans/ExtendStructListCopy (12 μs)
[ TEST ] orphan-test.c++:1563: legacy test: Orphans/ExtendStructListFromEmpty
[ PASS ] orphan-test.c++:1563: legacy test: Orphans/ExtendStructListFromEmpty (1 μs)
[ TEST ] orphan-test.c++:1587: legacy test: Orphans/ConcatenatePrimitiveLists
[ PASS ] orphan-test.c++:1587: legacy test: Orphans/ConcatenatePrimitiveLists (1 μs)
[ TEST ] orphan-test.c++:1608: legacy test: Orphans/ConcatenateBitLists
[ PASS ] orphan-test.c++:1608: legacy test: Orphans/ConcatenateBitLists (0 μs)
[ TEST ] orphan-test.c++:1629: legacy test: Orphans/ConcatenatePointerLists
[ PASS ] orphan-test.c++:1629: legacy test: Orphans/ConcatenatePointerLists (2 μs)
[ TEST ] orphan-test.c++:1651: legacy test: Orphans/ConcatenateStructLists
[ PASS ] orphan-test.c++:1651: legacy test: Orphans/ConcatenateStructLists (2 μs)
[ TEST ] orphan-test.c++:1710: legacy test: Orphans/ConcatenateStructListsUpgradeFromPrimitive
[ PASS ] orphan-test.c++:1710: legacy test: Orphans/ConcatenateStructListsUpgradeFromPrimitive (1 μs)
[ TEST ] serialize-test.c++:76: legacy test: Serialize/FlatArray
[ PASS ] serialize-test.c++:76: legacy test: Serialize/FlatArray (42 μs)
[ TEST ] serialize-test.c++:124: legacy test: Serialize/FlatArrayOddSegmentCount
[ PASS ] serialize-test.c++:124: legacy test: Serialize/FlatArrayOddSegmentCount (30 μs)
[ TEST ] serialize-test.c++:163: legacy test: Serialize/FlatArrayEvenSegmentCount
[ PASS ] serialize-test.c++:163: legacy test: Serialize/FlatArrayEvenSegmentCount (31 μs)
[ TEST ] serialize-test.c++:224: legacy test: Serialize/InputStream
[ PASS ] serialize-test.c++:224: legacy test: Serialize/InputStream (5 μs)
[ TEST ] serialize-test.c++:236: legacy test: Serialize/InputStreamScratchSpace
[ PASS ] serialize-test.c++:236: legacy test: Serialize/InputStreamScratchSpace (5 μs)
[ TEST ] serialize-test.c++:249: legacy test: Serialize/InputStreamLazy
[ PASS ] serialize-test.c++:249: legacy test: Serialize/InputStreamLazy (2 μs)
[ TEST ] serialize-test.c++:261: legacy test: Serialize/InputStreamOddSegmentCount
[ PASS ] serialize-test.c++:261: legacy test: Serialize/InputStreamOddSegmentCount (5 μs)
[ TEST ] serialize-test.c++:273: legacy test: Serialize/InputStreamOddSegmentCountLazy
[ PASS ] serialize-test.c++:273: legacy test: Serialize/InputStreamOddSegmentCountLazy (4 μs)
[ TEST ] serialize-test.c++:285: legacy test: Serialize/InputStreamEvenSegmentCount
[ PASS ] serialize-test.c++:285: legacy test: Serialize/InputStreamEvenSegmentCount (5 μs)
[ TEST ] serialize-test.c++:297: legacy test: Serialize/InputStreamEvenSegmentCountLazy
[ PASS ] serialize-test.c++:297: legacy test: Serialize/InputStreamEvenSegmentCountLazy (5 μs)
[ TEST ] serialize-test.c++:309: legacy test: Serialize/InputStreamToBuilder
[ PASS ] serialize-test.c++:309: legacy test: Serialize/InputStreamToBuilder (6 μs)
[ TEST ] serialize-test.c++:341: legacy test: Serialize/WriteMessage
[ PASS ] serialize-test.c++:341: legacy test: Serialize/WriteMessage (6 μs)
[ TEST ] serialize-test.c++:353: legacy test: Serialize/WriteMessageOddSegmentCount
[ PASS ] serialize-test.c++:353: legacy test: Serialize/WriteMessageOddSegmentCount (2 μs)
[ TEST ] serialize-test.c++:365: legacy test: Serialize/WriteMessageEvenSegmentCount
[ PASS ] serialize-test.c++:365: legacy test: Serialize/WriteMessageEvenSegmentCount (3 μs)
[ TEST ] serialize-test.c++:400: legacy test: Serialize/FileDescriptors
[ PASS ] serialize-test.c++:400: legacy test: Serialize/FileDescriptors (87 μs)
[ TEST ] serialize-test.c++:441: legacy test: Serialize/RejectTooManySegments
[ PASS ] serialize-test.c++:441: legacy test: Serialize/RejectTooManySegments (28 μs)
[ TEST ] serialize-test.c++:461: legacy test: Serialize/RejectHugeMessage
[ PASS ] serialize-test.c++:461: legacy test: Serialize/RejectHugeMessage (15 μs)
[ TEST ] serialize-packed-test.c++:201: legacy test: Packed/SimplePacking
[ PASS ] serialize-packed-test.c++:201: legacy test: Packed/SimplePacking (28 μs)
[ TEST ] serialize-packed-test.c++:255: legacy test: Packed/RoundTrip
[ PASS ] serialize-packed-test.c++:255: legacy test: Packed/RoundTrip (12 μs)
[ TEST ] serialize-packed-test.c++:268: legacy test: Packed/RoundTripScratchSpace
[ PASS ] serialize-packed-test.c++:268: legacy test: Packed/RoundTripScratchSpace (6 μs)
[ TEST ] serialize-packed-test.c++:282: legacy test: Packed/RoundTripLazy
[ PASS ] serialize-packed-test.c++:282: legacy test: Packed/RoundTripLazy (13 μs)
[ TEST ] serialize-packed-test.c++:295: legacy test: Packed/RoundTripOddSegmentCount
[ PASS ] serialize-packed-test.c++:295: legacy test: Packed/RoundTripOddSegmentCount (10 μs)
[ TEST ] serialize-packed-test.c++:308: legacy test: Packed/RoundTripOddSegmentCountLazy
[ PASS ] serialize-packed-test.c++:308: legacy test: Packed/RoundTripOddSegmentCountLazy (18 μs)
[ TEST ] serialize-packed-test.c++:321: legacy test: Packed/RoundTripEvenSegmentCount
[ PASS ] serialize-packed-test.c++:321: legacy test: Packed/RoundTripEvenSegmentCount (9 μs)
[ TEST ] serialize-packed-test.c++:334: legacy test: Packed/RoundTripEvenSegmentCountLazy
[ PASS ] serialize-packed-test.c++:334: legacy test: Packed/RoundTripEvenSegmentCountLazy (17 μs)
[ TEST ] serialize-packed-test.c++:347: legacy test: Packed/RoundTripTwoMessages
[ PASS ] serialize-packed-test.c++:347: legacy test: Packed/RoundTripTwoMessages (7 μs)
[ TEST ] serialize-packed-test.c++:374: legacy test: Packed/RoundTripAllZero
[ PASS ] serialize-packed-test.c++:374: legacy test: Packed/RoundTripAllZero (2 μs)
[ TEST ] serialize-packed-test.c++:392: legacy test: Packed/RoundTripAllZeroScratchSpace
[ PASS ] serialize-packed-test.c++:392: legacy test: Packed/RoundTripAllZeroScratchSpace (1 μs)
[ TEST ] serialize-packed-test.c++:406: legacy test: Packed/RoundTripAllZeroLazy
[ PASS ] serialize-packed-test.c++:406: legacy test: Packed/RoundTripAllZeroLazy (1 μs)
[ TEST ] serialize-packed-test.c++:419: legacy test: Packed/RoundTripAllZeroOddSegmentCount
[ PASS ] serialize-packed-test.c++:419: legacy test: Packed/RoundTripAllZeroOddSegmentCount (2 μs)
[ TEST ] serialize-packed-test.c++:432: legacy test: Packed/RoundTripAllZeroOddSegmentCountLazy
[ PASS ] serialize-packed-test.c++:432: legacy test: Packed/RoundTripAllZeroOddSegmentCountLazy (2 μs)
[ TEST ] serialize-packed-test.c++:445: legacy test: Packed/RoundTripAllZeroEvenSegmentCount
[ PASS ] serialize-packed-test.c++:445: legacy test: Packed/RoundTripAllZeroEvenSegmentCount (2 μs)
[ TEST ] serialize-packed-test.c++:458: legacy test: Packed/RoundTripAllZeroEvenSegmentCountLazy
[ PASS ] serialize-packed-test.c++:458: legacy test: Packed/RoundTripAllZeroEvenSegmentCountLazy (2 μs)
[ TEST ] serialize-packed-test.c++:473: legacy test: Packed/RoundTripHugeString
[ PASS ] serialize-packed-test.c++:473: legacy test: Packed/RoundTripHugeString (3 μs)
[ TEST ] serialize-packed-test.c++:489: legacy test: Packed/RoundTripHugeStringScratchSpace
[ PASS ] serialize-packed-test.c++:489: legacy test: Packed/RoundTripHugeStringScratchSpace (2 μs)
[ TEST ] serialize-packed-test.c++:506: legacy test: Packed/RoundTripHugeStringLazy
[ PASS ] serialize-packed-test.c++:506: legacy test: Packed/RoundTripHugeStringLazy (3 μs)
[ TEST ] serialize-packed-test.c++:522: legacy test: Packed/RoundTripHugeStringOddSegmentCount
[ PASS ] serialize-packed-test.c++:522: legacy test: Packed/RoundTripHugeStringOddSegmentCount (3 μs)
[ TEST ] serialize-packed-test.c++:538: legacy test: Packed/RoundTripHugeStringOddSegmentCountLazy
[ PASS ] serialize-packed-test.c++:538: legacy test: Packed/RoundTripHugeStringOddSegmentCountLazy (3 μs)
[ TEST ] serialize-packed-test.c++:554: legacy test: Packed/RoundTripHugeStringEvenSegmentCount
[ PASS ] serialize-packed-test.c++:554: legacy test: Packed/RoundTripHugeStringEvenSegmentCount (3 μs)
[ TEST ] serialize-packed-test.c++:570: legacy test: Packed/RoundTripHugeStringEvenSegmentCountLazy
[ PASS ] serialize-packed-test.c++:570: legacy test: Packed/RoundTripHugeStringEvenSegmentCountLazy (3 μs)
[ TEST ] canonicalize-test.c++:34: canonicalize yields canonical message
[ PASS ] canonicalize-test.c++:34: canonicalize yields canonical message (19 μs)
[ TEST ] canonicalize-test.c++:50: canonicalize succeeds on empty struct
[ PASS ] canonicalize-test.c++:50: canonicalize succeeds on empty struct (1 μs)
[ TEST ] canonicalize-test.c++:57: data word with only its most significant bit set does not get truncated
[ PASS ] canonicalize-test.c++:57: data word with only its most significant bit set does not get truncated (1 μs)
[ TEST ] canonicalize-test.c++:79: INLINE_COMPOSITE data word with only its most significant bit set does not get truncated
[ PASS ] canonicalize-test.c++:79: INLINE_COMPOSITE data word with only its most significant bit set does not get truncated (1 μs)
[ TEST ] canonicalize-test.c++:107: canonical non-null empty struct field
[ PASS ] canonicalize-test.c++:107: canonical non-null empty struct field (0 μs)
[ TEST ] canonicalize-test.c++:127: for pointers to empty structs, preorder is not canonical
[ PASS ] canonicalize-test.c++:127: for pointers to empty structs, preorder is not canonical (0 μs)
[ TEST ] canonicalize-test.c++:148: isCanonical requires pointer preorder
[ PASS ] canonicalize-test.c++:148: isCanonical requires pointer preorder (0 μs)
[ TEST ] canonicalize-test.c++:168: isCanonical requires dense packing
[ PASS ] canonicalize-test.c++:168: isCanonical requires dense packing (0 μs)
[ TEST ] canonicalize-test.c++:184: isCanonical rejects multi-segment messages
[ PASS ] canonicalize-test.c++:184: isCanonical rejects multi-segment messages (0 μs)
[ TEST ] canonicalize-test.c++:206: isCanonical rejects zero segment messages
[ PASS ] canonicalize-test.c++:206: isCanonical rejects zero segment messages (0 μs)
[ TEST ] canonicalize-test.c++:212: isCanonical requires truncation of 0-valued struct fields
[ PASS ] canonicalize-test.c++:212: isCanonical requires truncation of 0-valued struct fields (0 μs)
[ TEST ] canonicalize-test.c++:227: isCanonical rejects unused trailing words
[ PASS ] canonicalize-test.c++:227: isCanonical rejects unused trailing words (0 μs)
[ TEST ] canonicalize-test.c++:244: isCanonical accepts empty inline composite list of zero-sized structs
[ PASS ] canonicalize-test.c++:244: isCanonical accepts empty inline composite list of zero-sized structs (0 μs)
[ TEST ] canonicalize-test.c++:261: isCanonical rejects inline composite list with inaccurate word-length
[ PASS ] canonicalize-test.c++:261: isCanonical rejects inline composite list with inaccurate word-length (0 μs)
[ TEST ] canonicalize-test.c++:289: upgraded lists can be canonicalized
[ PASS ] canonicalize-test.c++:289: upgraded lists can be canonicalized (0 μs)
[ TEST ] canonicalize-test.c++:313: isCanonical requires truncation of 0-valued struct fields in all list members
[ PASS ] canonicalize-test.c++:313: isCanonical requires truncation of 0-valued struct fields in all list members (0 μs)
[ TEST ] canonicalize-test.c++:336: primitive list with nonzero padding
[ PASS ] canonicalize-test.c++:336: primitive list with nonzero padding (0 μs)
[ TEST ] canonicalize-test.c++:363: bit list with nonzero padding
[ PASS ] canonicalize-test.c++:363: bit list with nonzero padding (0 μs)
[ TEST ] fuzz-test.c++:172: fuzz-test struct pointer
[ PASS ] fuzz-test.c++:172: fuzz-test struct pointer (654770 μs)
[ TEST ] fuzz-test.c++:193: fuzz-test list pointer
[ PASS ] fuzz-test.c++:193: fuzz-test list pointer (690460 μs)
[ TEST ] fuzz-test.c++:218: fuzz-test struct list pointer
[ PASS ] fuzz-test.c++:218: fuzz-test struct list pointer (3610511 μs)
[ TEST ] fuzz-test.c++:242: fuzz-test text pointer
[ PASS ] fuzz-test.c++:242: fuzz-test text pointer (707451 μs)
[ TEST ] fuzz-test.c++:251: fuzz-test far pointer
[ PASS ] fuzz-test.c++:251: fuzz-test far pointer (1324754 μs)
[ TEST ] fuzz-test.c++:265: fuzz-test double-far pointer
[ PASS ] fuzz-test.c++:265: fuzz-test double-far pointer (1049396 μs)
222 test(s) passed 
<end of output>
Test time =   8.04 sec
----------------------------------------------------------
Test Passed.
"capnp-tests-run" end time: Dec 18 08:24 CET
"capnp-tests-run" time elapsed: 00:00:08
----------------------------------------------------------

4/5 Testing: capnp-heavy-tests-run
4/5 Test: capnp-heavy-tests-run
Command: "/var/tmp/portage/dev-libs/capnproto-0.10.2/work/capnproto-0.10.2/c++_build/src/capnp/capnp-heavy-tests"
Directory: /var/tmp/portage/dev-libs/capnproto-0.10.2/work/capnproto-0.10.2/c++_build/src/capnp
"capnp-heavy-tests-run" start time: Dec 18 08:24 CET
Output:
----------------------------------------------------------
[ TEST ] endian-reverse-test.c++:36: legacy test: EndianReverse/Byte
[ PASS ] endian-reverse-test.c++:36: legacy test: EndianReverse/Byte (4 μs)
[ TEST ] endian-reverse-test.c++:57: legacy test: EndianReverse/TwoBytes
[ PASS ] endian-reverse-test.c++:57: legacy test: EndianReverse/TwoBytes (0 μs)
[ TEST ] endian-reverse-test.c++:74: legacy test: EndianReverse/FourBytes
[ PASS ] endian-reverse-test.c++:74: legacy test: EndianReverse/FourBytes (0 μs)
[ TEST ] endian-reverse-test.c++:89: legacy test: EndianReverse/EightBytes
[ PASS ] endian-reverse-test.c++:89: legacy test: EndianReverse/EightBytes (0 μs)
[ TEST ] capability-test.c++:43: legacy test: Capability/Basic
[ PASS ] capability-test.c++:43: legacy test: Capability/Basic (309 μs)
[ TEST ] capability-test.c++:83: legacy test: Capability/CapabilityList
[ PASS ] capability-test.c++:83: legacy test: Capability/CapabilityList (17 μs)
[ TEST ] capability-test.c++:116: legacy test: Capability/Inheritance
[ PASS ] capability-test.c++:116: legacy test: Capability/Inheritance (11 μs)
[ TEST ] capability-test.c++:145: legacy test: Capability/Pipelining
[ PASS ] capability-test.c++:145: legacy test: Capability/Pipelining (49 μs)
[ TEST ] capability-test.c++:181: use pipeline after dropping response
[ PASS ] capability-test.c++:181: use pipeline after dropping response (20 μs)
[ TEST ] capability-test.c++:218: context.setPipeline
[ PASS ] capability-test.c++:218: context.setPipeline (23 μs)
[ TEST ] capability-test.c++:248: legacy test: Capability/TailCall
[ PASS ] capability-test.c++:248: legacy test: Capability/TailCall (37 μs)
[ TEST ] capability-test.c++:282: legacy test: Capability/AsyncCancelation
[ PASS ] capability-test.c++:282: legacy test: Capability/AsyncCancelation (12 μs)
[ TEST ] capability-test.c++:324: legacy test: Capability/DynamicClient
[ PASS ] capability-test.c++:324: legacy test: Capability/DynamicClient (134 μs)
[ TEST ] capability-test.c++:365: legacy test: Capability/DynamicClientInheritance
[ PASS ] capability-test.c++:365: legacy test: Capability/DynamicClientInheritance (77 μs)
[ TEST ] capability-test.c++:402: legacy test: Capability/DynamicClientPipelining
[ PASS ] capability-test.c++:402: legacy test: Capability/DynamicClientPipelining (36 μs)
[ TEST ] capability-test.c++:441: legacy test: Capability/DynamicClientPipelineAnyCap
[ PASS ] capability-test.c++:441: legacy test: Capability/DynamicClientPipelineAnyCap (24 μs)
[ TEST ] capability-test.c++:518: legacy test: Capability/DynamicServer
[ PASS ] capability-test.c++:518: legacy test: Capability/DynamicServer (93 μs)
[ TEST ] capability-test.c++:589: legacy test: Capability/DynamicServerInheritance
[ PASS ] capability-test.c++:589: legacy test: Capability/DynamicServerInheritance (36 μs)
[ TEST ] capability-test.c++:675: legacy test: Capability/DynamicServerPipelining
[ PASS ] capability-test.c++:675: legacy test: Capability/DynamicServerPipelining (30 μs)
[ TEST ] capability-test.c++:738: legacy test: Capability/DynamicServerTailCall
[ PASS ] capability-test.c++:738: legacy test: Capability/DynamicServerTailCall (27 μs)
[ TEST ] capability-test.c++:798: legacy test: Capability/AnyPointersAndOrphans
[ PASS ] capability-test.c++:798: legacy test: Capability/AnyPointersAndOrphans (56 μs)
[ TEST ] capability-test.c++:862: legacy test: Capability/Lists
[ PASS ] capability-test.c++:862: legacy test: Capability/Lists (34 μs)
[ TEST ] capability-test.c++:901: legacy test: Capability/KeywordMethods
[ PASS ] capability-test.c++:901: legacy test: Capability/KeywordMethods (6 μs)
[ TEST ] capability-test.c++:927: legacy test: Capability/Generics
[ PASS ] capability-test.c++:927: legacy test: Capability/Generics (4 μs)
[ TEST ] capability-test.c++:957: legacy test: Capability/Generics2
[ PASS ] capability-test.c++:957: legacy test: Capability/Generics2 (0 μs)
[ TEST ] capability-test.c++:964: legacy test: Capability/ImplicitParams
[ PASS ] capability-test.c++:964: legacy test: Capability/ImplicitParams (2 μs)
[ TEST ] capability-test.c++:988: legacy test: Capability/CapabilityServerSet
[ PASS ] capability-test.c++:988: legacy test: Capability/CapabilityServerSet (20 μs)
[ TEST ] capability-test.c++:1082: legacy test: Capability/ThisCap
[ PASS ] capability-test.c++:1082: legacy test: Capability/ThisCap (9 μs)
[ TEST ] capability-test.c++:1110: legacy test: Capability/TransferCap
[ PASS ] capability-test.c++:1110: legacy test: Capability/TransferCap (10 μs)
[ TEST ] capability-test.c++:1134: Promise<RemotePromise<T>> automatically reduces to RemotePromise<T>
[ PASS ] capability-test.c++:1134: Promise<RemotePromise<T>> automatically reduces to RemotePromise<T> (8 μs)
[ TEST ] capability-test.c++:1154: Promise<RemotePromise<T>> automatically reduces to RemotePromise<T> with pipelining
[ PASS ] capability-test.c++:1154: Promise<RemotePromise<T>> automatically reduces to RemotePromise<T> with pipelining (20 μs)
[ TEST ] capability-test.c++:1183: clone() with caps
[ PASS ] capability-test.c++:1183: clone() with caps (11 μs)
[ TEST ] capability-test.c++:1204: Streaming calls block subsequent calls
[ PASS ] capability-test.c++:1204: Streaming calls block subsequent calls (21 μs)
[ TEST ] capability-test.c++:1277: Streaming calls can be canceled
[ PASS ] capability-test.c++:1277: Streaming calls can be canceled (13 μs)
[ TEST ] capability-test.c++:1338: Streaming call throwing cascades to following calls
[ PASS ] capability-test.c++:1338: Streaming call throwing cascades to following calls (91 μs)
[ TEST ] membrane-test.c++:188: call local object inside membrane
[ PASS ] membrane-test.c++:188: call local object inside membrane (67 μs)
[ TEST ] membrane-test.c++:195: call local promise inside membrane
[ PASS ] membrane-test.c++:195: call local promise inside membrane (70 μs)
[ TEST ] membrane-test.c++:202: call local resolved promise inside membrane
[ PASS ] membrane-test.c++:202: call local resolved promise inside membrane (64 μs)
[ TEST ] membrane-test.c++:211: call local object outside membrane
[ PASS ] membrane-test.c++:211: call local object outside membrane (34 μs)
[ TEST ] membrane-test.c++:218: call local capability that has passed into and back out of membrane
[ PASS ] membrane-test.c++:218: call local capability that has passed into and back out of membrane (49 μs)
[ TEST ] membrane-test.c++:227: call local promise pointing into membrane that eventually resolves to outside
[ PASS ] membrane-test.c++:227: call local promise pointing into membrane that eventually resolves to outside (70 μs)
[ TEST ] membrane-test.c++:236: apply membrane using copyOutOfMembrane() on struct
[ PASS ] membrane-test.c++:236: apply membrane using copyOutOfMembrane() on struct (38 μs)
[ TEST ] membrane-test.c++:250: apply membrane using copyOutOfMembrane() on list
[ PASS ] membrane-test.c++:250: apply membrane using copyOutOfMembrane() on list (35 μs)
[ TEST ] membrane-test.c++:264: apply membrane using copyOutOfMembrane() on AnyPointer
[ PASS ] membrane-test.c++:264: apply membrane using copyOutOfMembrane() on AnyPointer (34 μs)
[ TEST ] membrane-test.c++:279: MembraneHook::whenMoreResolved returns same value even when called concurrently.
[ PASS ] membrane-test.c++:279: MembraneHook::whenMoreResolved returns same value even when called concurrently. (11 μs)
[ TEST ] membrane-test.c++:332: call remote object inside membrane
[ PASS ] membrane-test.c++:332: call remote object inside membrane (391 μs)
[ TEST ] membrane-test.c++:339: call remote promise inside membrane
[ PASS ] membrane-test.c++:339: call remote promise inside membrane (260 μs)
[ TEST ] membrane-test.c++:346: call remote resolved promise inside membrane
[ PASS ] membrane-test.c++:346: call remote resolved promise inside membrane (75 μs)
[ TEST ] membrane-test.c++:355: call remote object outside membrane
[ PASS ] membrane-test.c++:355: call remote object outside membrane (166 μs)
[ TEST ] membrane-test.c++:362: call remote capability that has passed into and back out of membrane
[ PASS ] membrane-test.c++:362: call remote capability that has passed into and back out of membrane (283 μs)
[ TEST ] membrane-test.c++:371: call remote promise pointing into membrane that eventually resolves to outside
[ PASS ] membrane-test.c++:371: call remote promise pointing into membrane that eventually resolves to outside (333 μs)
[ TEST ] membrane-test.c++:380: revoke membrane
[ PASS ] membrane-test.c++:380: revoke membrane (158 μs)
[ TEST ] schema-test.c++:41: legacy test: Schema/Structs
[ PASS ] schema-test.c++:41: legacy test: Schema/Structs (56 μs)
[ TEST ] schema-test.c++:81: legacy test: Schema/FieldLookupOutOfOrder
[ PASS ] schema-test.c++:81: legacy test: Schema/FieldLookupOutOfOrder (2 μs)
[ TEST ] schema-test.c++:107: legacy test: Schema/Unions
[ PASS ] schema-test.c++:107: legacy test: Schema/Unions (5 μs)
[ TEST ] schema-test.c++:132: legacy test: Schema/Enums
[ PASS ] schema-test.c++:132: legacy test: Schema/Enums (44 μs)
[ TEST ] schema-test.c++:164: legacy test: Schema/Lists
[ PASS ] schema-test.c++:164: legacy test: Schema/Lists (215 μs)
[ TEST ] schema-test.c++:253: legacy test: Schema/UnnamedUnion
[ PASS ] schema-test.c++:253: legacy test: Schema/UnnamedUnion (1 μs)
[ TEST ] schema-test.c++:264: legacy test: Schema/NullSchemas
[ PASS ] schema-test.c++:264: legacy test: Schema/NullSchemas (1 μs)
[ TEST ] schema-test.c++:281: legacy test: Schema/Interfaces
[ PASS ] schema-test.c++:281: legacy test: Schema/Interfaces (36 μs)
[ TEST ] schema-test.c++:322: legacy test: Schema/Generics
[ PASS ] schema-test.c++:322: legacy test: Schema/Generics (9 μs)
[ TEST ] schema-loader-test.c++:33: legacy test: SchemaLoader/Load
[ PASS ] schema-loader-test.c++:33: legacy test: SchemaLoader/Load (321 μs)
[ TEST ] schema-loader-test.c++:59: legacy test: SchemaLoader/LoadLateUnion
[ PASS ] schema-loader-test.c++:59: legacy test: SchemaLoader/LoadLateUnion (26 μs)
[ TEST ] schema-loader-test.c++:77: legacy test: SchemaLoader/LoadUnnamedUnion
[ PASS ] schema-loader-test.c++:77: legacy test: SchemaLoader/LoadUnnamedUnion (3 μs)
[ TEST ] schema-loader-test.c++:91: legacy test: SchemaLoader/Use
[ PASS ] schema-loader-test.c++:91: legacy test: SchemaLoader/Use (233 μs)
[ TEST ] schema-loader-test.c++:192: legacy test: SchemaLoader/Upgrade
[ PASS ] schema-loader-test.c++:192: legacy test: SchemaLoader/Upgrade (72 μs)
[ TEST ] schema-loader-test.c++:212: legacy test: SchemaLoader/Downgrade
[ PASS ] schema-loader-test.c++:212: legacy test: SchemaLoader/Downgrade (83 μs)
[ TEST ] schema-loader-test.c++:229: legacy test: SchemaLoader/Incompatible
[ PASS ] schema-loader-test.c++:229: legacy test: SchemaLoader/Incompatible (69 μs)
[ TEST ] schema-loader-test.c++:236: legacy test: SchemaLoader/Enumerate
[ PASS ] schema-loader-test.c++:236: legacy test: SchemaLoader/Enumerate (7 μs)
[ TEST ] schema-loader-test.c++:250: legacy test: SchemaLoader/EnumerateNoPlaceholders
[ PASS ] schema-loader-test.c++:250: legacy test: SchemaLoader/EnumerateNoPlaceholders (26 μs)
[ TEST ] schema-loader-test.c++:297: legacy test: SchemaLoader/LazyLoad
[ PASS ] schema-loader-test.c++:297: legacy test: SchemaLoader/LazyLoad (20 μs)
[ TEST ] schema-loader-test.c++:314: legacy test: SchemaLoader/LazyLoadGetDependency
[ PASS ] schema-loader-test.c++:314: legacy test: SchemaLoader/LazyLoadGetDependency (37 μs)
[ TEST ] schema-loader-test.c++:333: legacy test: SchemaLoader/Generics
[ PASS ] schema-loader-test.c++:333: legacy test: SchemaLoader/Generics (130 μs)
[ TEST ] schema-loader-test.c++:392: legacy test: SchemaLoader/LoadStreaming
[ PASS ] schema-loader-test.c++:392: legacy test: SchemaLoader/LoadStreaming (11 μs)
[ TEST ] schema-parser-test.c++:63: legacy test: SchemaParser/Basic
[ PASS ] schema-parser-test.c++:63: legacy test: SchemaParser/Basic (361 μs)
[ TEST ] schema-parser-test.c++:156: legacy test: SchemaParser/Constants
[ PASS ] schema-parser-test.c++:156: legacy test: SchemaParser/Constants (178 μs)
[ TEST ] schema-parser-test.c++:212: legacy test: SchemaParser/SourceInfo
[ PASS ] schema-parser-test.c++:212: legacy test: SchemaParser/SourceInfo (129 μs)
[ TEST ] dynamic-test.c++:47: legacy test: DynamicApi/Build
[ PASS ] dynamic-test.c++:47: legacy test: DynamicApi/Build (95 μs)
[ TEST ] dynamic-test.c++:58: legacy test: DynamicApi/Read
[ PASS ] dynamic-test.c++:58: legacy test: DynamicApi/Read (65 μs)
[ TEST ] dynamic-test.c++:69: legacy test: DynamicApi/Defaults
[ PASS ] dynamic-test.c++:69: legacy test: DynamicApi/Defaults (26 μs)
[ TEST ] dynamic-test.c++:77: legacy test: DynamicApi/DefaultsBuilder
[ PASS ] dynamic-test.c++:77: legacy test: DynamicApi/DefaultsBuilder (93 μs)
[ TEST ] dynamic-test.c++:93: legacy test: DynamicApi/Zero
[ PASS ] dynamic-test.c++:93: legacy test: DynamicApi/Zero (36 μs)
[ TEST ] dynamic-test.c++:103: legacy test: DynamicApi/ListListsBuild
[ PASS ] dynamic-test.c++:103: legacy test: DynamicApi/ListListsBuild (38 μs)
[ TEST ] dynamic-test.c++:114: legacy test: DynamicApi/ListListsRead
[ PASS ] dynamic-test.c++:114: legacy test: DynamicApi/ListListsRead (32 μs)
[ TEST ] dynamic-test.c++:125: legacy test: DynamicApi/AnyPointers
[ PASS ] dynamic-test.c++:125: legacy test: DynamicApi/AnyPointers (105 μs)
[ TEST ] dynamic-test.c++:194: legacy test: DynamicApi/DynamicAnyPointers
[ PASS ] dynamic-test.c++:194: legacy test: DynamicApi/DynamicAnyPointers (115 μs)
[ TEST ] dynamic-test.c++:256: legacy test: DynamicApi/DynamicAnyStructs
[ PASS ] dynamic-test.c++:256: legacy test: DynamicApi/DynamicAnyStructs (0 μs)
[ TEST ] dynamic-test.c++:272: legacy test: DynamicApi/UnionsRead
[ PASS ] dynamic-test.c++:272: legacy test: DynamicApi/UnionsRead (7 μs)
[ TEST ] dynamic-test.c++:331: legacy test: DynamicApi/UnionsWrite
[ PASS ] dynamic-test.c++:331: legacy test: DynamicApi/UnionsWrite (40 μs)
[ TEST ] dynamic-test.c++:358: legacy test: DynamicApi/UnnamedUnion
[ PASS ] dynamic-test.c++:358: legacy test: DynamicApi/UnnamedUnion (113 μs)
[ TEST ] dynamic-test.c++:394: legacy test: DynamicApi/ConversionFailures
[ PASS ] dynamic-test.c++:394: legacy test: DynamicApi/ConversionFailures (77 μs)
[ TEST ] dynamic-test.c++:411: legacy test: DynamicApi/LateUnion
[ PASS ] dynamic-test.c++:411: legacy test: DynamicApi/LateUnion (1 μs)
[ TEST ] dynamic-test.c++:419: legacy test: DynamicApi/Has
[ PASS ] dynamic-test.c++:419: legacy test: DynamicApi/Has (4 μs)
[ TEST ] dynamic-test.c++:441: legacy test: DynamicApi/HasWhenEmpty
[ PASS ] dynamic-test.c++:441: legacy test: DynamicApi/HasWhenEmpty (3 μs)
[ TEST ] dynamic-test.c++:458: legacy test: DynamicApi/SetEnumFromNative
[ PASS ] dynamic-test.c++:458: legacy test: DynamicApi/SetEnumFromNative (3 μs)
[ TEST ] dynamic-test.c++:468: legacy test: DynamicApi/SetDataFromText
[ PASS ] dynamic-test.c++:468: legacy test: DynamicApi/SetDataFromText (1 μs)
[ TEST ] dynamic-test.c++:476: legacy test: DynamicApi/BuilderAssign
[ PASS ] dynamic-test.c++:476: legacy test: DynamicApi/BuilderAssign (2 μs)
[ TEST ] stringify-test.c++:33: legacy test: Stringify/KjStringification
[ PASS ] stringify-test.c++:33: legacy test: Stringify/KjStringification (171 μs)
[ TEST ] stringify-test.c++:257: legacy test: Stringify/PrettyPrint
[ PASS ] stringify-test.c++:257: legacy test: Stringify/PrettyPrint (163 μs)
[ TEST ] stringify-test.c++:471: legacy test: Stringify/PrettyPrintAdvanced
[ PASS ] stringify-test.c++:471: legacy test: Stringify/PrettyPrintAdvanced (52 μs)
[ TEST ] stringify-test.c++:581: legacy test: Stringify/Unions
[ PASS ] stringify-test.c++:581: legacy test: Stringify/Unions (13 μs)
[ TEST ] stringify-test.c++:605: legacy test: Stringify/UnionDefaults
[ PASS ] stringify-test.c++:605: legacy test: Stringify/UnionDefaults (11 μs)
[ TEST ] stringify-test.c++:629: legacy test: Stringify/UnnamedUnions
[ PASS ] stringify-test.c++:629: legacy test: Stringify/UnnamedUnions (17 μs)
[ TEST ] stringify-test.c++:672: legacy test: Stringify/StructUnions
[ PASS ] stringify-test.c++:672: legacy test: Stringify/StructUnions (3 μs)
[ TEST ] stringify-test.c++:683: legacy test: Stringify/MoreValues
[ PASS ] stringify-test.c++:683: legacy test: Stringify/MoreValues (6 μs)
[ TEST ] stringify-test.c++:693: legacy test: Stringify/Generics
[ PASS ] stringify-test.c++:693: legacy test: Stringify/Generics (3 μs)
[ TEST ] serialize-async-test.c++:217: legacy test: SerializeAsyncTest/ParseAsync
[ PASS ] serialize-async-test.c++:217: legacy test: SerializeAsyncTest/ParseAsync (50766 μs)
[ TEST ] serialize-async-test.c++:236: legacy test: SerializeAsyncTest/ParseAsyncOddSegmentCount
[ PASS ] serialize-async-test.c++:236: legacy test: SerializeAsyncTest/ParseAsyncOddSegmentCount (167035 μs)
[ TEST ] serialize-async-test.c++:255: legacy test: SerializeAsyncTest/ParseAsyncEvenSegmentCount
[ PASS ] serialize-async-test.c++:255: legacy test: SerializeAsyncTest/ParseAsyncEvenSegmentCount (258038 μs)
[ TEST ] serialize-async-test.c++:274: legacy test: SerializeAsyncTest/WriteAsync
[ PASS ] serialize-async-test.c++:274: legacy test: SerializeAsyncTest/WriteAsync (295 μs)
[ TEST ] serialize-async-test.c++:299: legacy test: SerializeAsyncTest/WriteAsyncOddSegmentCount
[ PASS ] serialize-async-test.c++:299: legacy test: SerializeAsyncTest/WriteAsyncOddSegmentCount (203 μs)
[ TEST ] serialize-async-test.c++:324: legacy test: SerializeAsyncTest/WriteAsyncEvenSegmentCount
[ PASS ] serialize-async-test.c++:324: legacy test: SerializeAsyncTest/WriteAsyncEvenSegmentCount (196 μs)
[ TEST ] serialize-async-test.c++:349: legacy test: SerializeAsyncTest/WriteMultipleMessagesAsync
[ PASS ] serialize-async-test.c++:349: legacy test: SerializeAsyncTest/WriteMultipleMessagesAsync (687 μs)
[ TEST ] serialize-text-test.c++:35: TextCodec TestAllTypes
[ PASS ] serialize-text-test.c++:35: TextCodec TestAllTypes (1555 μs)
[ TEST ] serialize-text-test.c++:69: TextCodec TestDefaults
[ PASS ] serialize-text-test.c++:69: TextCodec TestDefaults (572 μs)
[ TEST ] serialize-text-test.c++:82: TextCodec TestListDefaults
[ PASS ] serialize-text-test.c++:82: TextCodec TestListDefaults (222 μs)
[ TEST ] serialize-text-test.c++:95: TextCodec raw text
[ PASS ] serialize-text-test.c++:95: TextCodec raw text (27 μs)
[ TEST ] serialize-text-test.c++:129: TextCodec parse error
[ PASS ] serialize-text-test.c++:129: TextCodec parse error (58 μs)
[ TEST ] rpc-test.c++:492: legacy test: Rpc/Basic
[ PASS ] rpc-test.c++:492: legacy test: Rpc/Basic (201 μs)
[ TEST ] rpc-test.c++:533: legacy test: Rpc/Pipelining
[ PASS ] rpc-test.c++:533: legacy test: Rpc/Pipelining (91 μs)
[ TEST ] rpc-test.c++:569: RPC context.setPipeline
[ PASS ] rpc-test.c++:569: RPC context.setPipeline (61 μs)
[ TEST ] rpc-test.c++:598: legacy test: Rpc/Release
[ PASS ] rpc-test.c++:598: legacy test: Rpc/Release (60 μs)
[ TEST ] rpc-test.c++:626: legacy test: Rpc/ReleaseOnCancel
[ PASS ] rpc-test.c++:626: legacy test: Rpc/ReleaseOnCancel (38 μs)
[ TEST ] rpc-test.c++:655: legacy test: Rpc/TailCall
[ PASS ] rpc-test.c++:655: legacy test: Rpc/TailCall (101 μs)
[ TEST ] rpc-test.c++:732: legacy test: Rpc/TailCallCancel
[ PASS ] rpc-test.c++:732: legacy test: Rpc/TailCallCancel (46 μs)
[ TEST ] rpc-test.c++:763: legacy test: Rpc/TailCallCancelRace
[ PASS ] rpc-test.c++:763: legacy test: Rpc/TailCallCancelRace (46 μs)
[ TEST ] rpc-test.c++:801: legacy test: Rpc/Cancellation
[ PASS ] rpc-test.c++:801: legacy test: Rpc/Cancellation (40 μs)
[ TEST ] rpc-test.c++:842: legacy test: Rpc/PromiseResolve
[ PASS ] rpc-test.c++:842: legacy test: Rpc/PromiseResolve (104 μs)
[ TEST ] rpc-test.c++:880: legacy test: Rpc/RetainAndRelease
[ PASS ] rpc-test.c++:880: legacy test: Rpc/RetainAndRelease (128 μs)
[ TEST ] rpc-test.c++:943: legacy test: Rpc/Cancel
[ PASS ] rpc-test.c++:943: legacy test: Rpc/Cancel (55 μs)
[ TEST ] rpc-test.c++:974: legacy test: Rpc/SendTwice
[ PASS ] rpc-test.c++:974: legacy test: Rpc/SendTwice (90 μs)
[ TEST ] rpc-test.c++:1022: legacy test: Rpc/Embargo
[ PASS ] rpc-test.c++:1022: legacy test: Rpc/Embargo (125 μs)
[ TEST ] rpc-test.c++:1059: legacy test: Rpc/EmbargoUnwrap
[ PASS ] rpc-test.c++:1059: legacy test: Rpc/EmbargoUnwrap (129 μs)
[ TEST ] rpc-test.c++:1120: legacy test: Rpc/EmbargoError
[ PASS ] rpc-test.c++:1120: legacy test: Rpc/EmbargoError (190 μs)
[ TEST ] rpc-test.c++:1164: legacy test: Rpc/EmbargoNull
[ PASS ] rpc-test.c++:1164: legacy test: Rpc/EmbargoNull (62 μs)
[ TEST ] rpc-test.c++:1192: legacy test: Rpc/CallBrokenPromise
[ PASS ] rpc-test.c++:1192: legacy test: Rpc/CallBrokenPromise (120 μs)
[ TEST ] rpc-test.c++:1245: legacy test: Rpc/Abort
[ PASS ] rpc-test.c++:1245: legacy test: Rpc/Abort (41 μs)
[ TEST ] rpc-test.c++:1271: loopback bootstrap()
[ PASS ] rpc-test.c++:1271: loopback bootstrap() (11 μs)
[ TEST ] rpc-test.c++:1291: method throws exception
[ PASS ] rpc-test.c++:1291: method throws exception (38 μs)
[ TEST ] rpc-test.c++:1308: method throws exception won't redundantly add remote exception prefix
[ PASS ] rpc-test.c++:1308: method throws exception won't redundantly add remote exception prefix (33 μs)
[ TEST ] rpc-test.c++:1325: method throws exception with trace encoder
[ PASS ] rpc-test.c++:1325: method throws exception with trace encoder (38 μs)
[ TEST ] rpc-test.c++:1346: when OutgoingRpcMessage::send() throws, we don't leak exports
[ PASS ] rpc-test.c++:1346: when OutgoingRpcMessage::send() throws, we don't leak exports (153 μs)
[ TEST ] rpc-test.c++:1460: export the same promise twice
[ PASS ] rpc-test.c++:1460: export the same promise twice (131 μs)
[ TEST ] rpc-twoparty-test.c++:130: legacy test: TwoPartyNetwork/Basic
[ PASS ] rpc-twoparty-test.c++:130: legacy test: TwoPartyNetwork/Basic (614 μs)
[ TEST ] rpc-twoparty-test.c++:230: legacy test: TwoPartyNetwork/Pipelining
[ PASS ] rpc-twoparty-test.c++:230: legacy test: TwoPartyNetwork/Pipelining (321 μs)
[ TEST ] rpc-twoparty-test.c++:327: legacy test: TwoPartyNetwork/Release
[ PASS ] rpc-twoparty-test.c++:327: legacy test: TwoPartyNetwork/Release (30535 μs)
[ TEST ] rpc-twoparty-test.c++:380: legacy test: TwoPartyNetwork/Abort
[ PASS ] rpc-twoparty-test.c++:380: legacy test: TwoPartyNetwork/Abort (191 μs)
[ TEST ] rpc-twoparty-test.c++:411: legacy test: TwoPartyNetwork/ConvenienceClasses
[ PASS ] rpc-twoparty-test.c++:411: legacy test: TwoPartyNetwork/ConvenienceClasses (257 μs)
[ TEST ] rpc-twoparty-test.c++:439: legacy test: TwoPartyNetwork/HugeMessage
[ PASS ] rpc-twoparty-test.c++:439: legacy test: TwoPartyNetwork/HugeMessage (405 μs)
[ TEST ] rpc-twoparty-test.c++:510: legacy test: TwoPartyNetwork/BootstrapFactory
[ PASS ] rpc-twoparty-test.c++:510: legacy test: TwoPartyNetwork/BootstrapFactory (181 μs)
[ TEST ] rpc-twoparty-test.c++:524: send FD over RPC
[ PASS ] rpc-twoparty-test.c++:524: send FD over RPC (193 μs)
[ TEST ] rpc-twoparty-test.c++:571: FD per message limit
[ PASS ] rpc-twoparty-test.c++:571: FD per message limit (132 μs)
[ TEST ] rpc-twoparty-test.c++:669: Streaming over RPC
[ PASS ] rpc-twoparty-test.c++:669: Streaming over RPC (770 μs)
[ TEST ] rpc-twoparty-test.c++:735: Streaming over RPC then unwrap with CapabilitySet
[ PASS ] rpc-twoparty-test.c++:735: Streaming over RPC then unwrap with CapabilitySet (15071 μs)
[ TEST ] rpc-twoparty-test.c++:828: promise cap resolves between starting request and sending it
[ PASS ] rpc-twoparty-test.c++:828: promise cap resolves between starting request and sending it (83 μs)
[ TEST ] rpc-twoparty-test.c++:860: write error propagates to read error
[ PASS ] rpc-twoparty-test.c++:860: write error propagates to read error (95 μs)
[ TEST ] ez-rpc-test.c++:32: legacy test: EzRpc/Basic
[ PASS ] ez-rpc-test.c++:32: legacy test: EzRpc/Basic (581 μs)
[ TEST ] ez-rpc-test.c++:49: legacy test: EzRpc/DeprecatedNames
[ PASS ] ez-rpc-test.c++:49: legacy test: EzRpc/DeprecatedNames (457 μs)
[ TEST ] compiler/lexer-test.c++:70: legacy test: Lexer/Tokens
[ PASS ] compiler/lexer-test.c++:70: legacy test: Lexer/Tokens (139 μs)
[ TEST ] compiler/lexer-test.c++:189: legacy test: Lexer/Statements
[ PASS ] compiler/lexer-test.c++:189: legacy test: Lexer/Statements (53 μs)
[ TEST ] compiler/lexer-test.c++:236: legacy test: Lexer/DocComments
[ PASS ] compiler/lexer-test.c++:236: legacy test: Lexer/DocComments (93 μs)
[ TEST ] compiler/lexer-test.c++:361: legacy test: Lexer/Utf8Bom
[ PASS ] compiler/lexer-test.c++:361: legacy test: Lexer/Utf8Bom (9 μs)
[ TEST ] compiler/type-id-test.c++:30: type ID generation hasn't changed
[ PASS ] compiler/type-id-test.c++:30: type ID generation hasn't changed (4 μs)
[ TEST ] compat/json-test.c++:34: basic json encoding
[ PASS ] compat/json-test.c++:34: basic json encoding (63 μs)
[ TEST ] compat/json-test.c++:143: encode all types
[ PASS ] compat/json-test.c++:143: encode all types (507 μs)
[ TEST ] compat/json-test.c++:170: encode union
[ PASS ] compat/json-test.c++:170: encode union (25 μs)
[ TEST ] compat/json-test.c++:187: decode all types
[ PASS ] compat/json-test.c++:187: decode all types (1048 μs)
[ TEST ] compat/json-test.c++:345: decode test message
[ PASS ] compat/json-test.c++:345: decode test message (681 μs)
[ TEST ] compat/json-test.c++:360: basic json decoding
[ PASS ] compat/json-test.c++:360: basic json decoding (465 μs)
[ TEST ] compat/json-test.c++:611: maximum nesting depth
[ PASS ] compat/json-test.c++:611: maximum nesting depth (42 μs)
[ TEST ] compat/json-test.c++:650: unknown fields
[ PASS ] compat/json-test.c++:650: unknown fields (92 μs)
[ TEST ] compat/json-test.c++:730: register custom encoding handlers
[ PASS ] compat/json-test.c++:730: register custom encoding handlers (12 μs)
[ TEST ] compat/json-test.c++:748: register custom roundtrip handler
[ PASS ] compat/json-test.c++:748: register custom roundtrip handler (19 μs)
[ TEST ] compat/json-test.c++:789: register field handler
[ PASS ] compat/json-test.c++:789: register field handler (10 μs)
[ TEST ] compat/json-test.c++:837: register capability handler
[ PASS ] compat/json-test.c++:837: register capability handler (0 μs)
[ TEST ] compat/json-test.c++:910: rename fields
[ PASS ] compat/json-test.c++:910: rename fields (234 μs)
[ TEST ] compat/json-test.c++:995: base64 union encoded correctly
[ PASS ] compat/json-test.c++:995: base64 union encoded correctly (8 μs)
[ TEST ] compat/websocket-rpc-test.c++:27: WebSocketMessageStream
[ PASS ] compat/websocket-rpc-test.c++:27: WebSocketMessageStream (64 μs)
[ TEST ] compat/websocket-rpc-test.c++:81: WebSocketMessageStreamByteCount
[ PASS ] compat/websocket-rpc-test.c++:81: WebSocketMessageStreamByteCount (9 μs)
179 test(s) passed 
<end of output>
Test time =   0.55 sec
----------------------------------------------------------
Test Passed.
"capnp-heavy-tests-run" end time: Dec 18 08:24 CET
"capnp-heavy-tests-run" time elapsed: 00:00:00
----------------------------------------------------------

5/5 Testing: capnp-evolution-tests-run
5/5 Test: capnp-evolution-tests-run
Command: "/var/tmp/portage/dev-libs/capnproto-0.10.2/work/capnproto-0.10.2/c++_build/src/capnp/capnp-evolution-tests"
Directory: /var/tmp/portage/dev-libs/capnproto-0.10.2/work/capnproto-0.10.2/c++_build/src/capnp
"capnp-evolution-tests-run" start time: Dec 18 08:24 CET
Output:
----------------------------------------------------------
Randomly testing backwards-compatibility scenarios with seed: 1671348287
<end of output>
Test time =   0.14 sec
----------------------------------------------------------
Test Passed.
"capnp-evolution-tests-run" end time: Dec 18 08:24 CET
"capnp-evolution-tests-run" time elapsed: 00:00:00
----------------------------------------------------------

End testing: Dec 18 08:24 CET