✅ cancel should block until the fork completes
✅ cancel should block until the fork completes (stress test)
✅ cancelNow should return immediately, and wait for forks when scope completes
✅ cancelNow should (when followed by a joinEither) catch InterruptedException with which a fork ends

✅ channel with capacity 0 should send and receive two spaced elements
✅ channel with capacity 0 should send and receive many elements, with concurrent senders & receivers
✅ channel with capacity 0 should select from two receives, if the last one has elements
✅ channel with capacity 0 should select from three receives, if the last one has elements
✅ channel with capacity 0 should select a receive from multiple channels
✅ channel with capacity 0 should select a receive until all channels are done
✅ channel with capacity 0 should properly report channel state
✅ channel with capacity 0 should skip channels, which are done immediately
✅ channel with capacity 0 should skip channels, which become done
✅ channel with capacity 0 should not skip channels, which are done immediately, when requested
✅ channel with capacity 0 should not skip channels, which become done, when requested
✅ channel with capacity 1 should send and receive two spaced elements
✅ channel with capacity 1 should send and receive many elements, with concurrent senders & receivers
✅ channel with capacity 1 should select from two receives, if the last one has elements
✅ channel with capacity 1 should select from three receives, if the last one has elements
✅ channel with capacity 1 should select a receive from multiple channels
✅ channel with capacity 1 should select a receive until all channels are done
✅ channel with capacity 1 should properly report channel state
✅ channel with capacity 1 should skip channels, which are done immediately
✅ channel with capacity 1 should skip channels, which become done
✅ channel with capacity 1 should not skip channels, which are done immediately, when requested
✅ channel with capacity 1 should not skip channels, which become done, when requested
✅ channel with capacity 2 should send and receive two spaced elements
✅ channel with capacity 2 should send and receive many elements, with concurrent senders & receivers
✅ channel with capacity 2 should select from two receives, if the last one has elements
✅ channel with capacity 2 should select from three receives, if the last one has elements
✅ channel with capacity 2 should select a receive from multiple channels
✅ channel with capacity 2 should select a receive until all channels are done
✅ channel with capacity 2 should properly report channel state
✅ channel with capacity 2 should skip channels, which are done immediately
✅ channel with capacity 2 should skip channels, which become done
✅ channel with capacity 2 should not skip channels, which are done immediately, when requested
✅ channel with capacity 2 should not skip channels, which become done, when requested
✅ channel with capacity 10000 should send and receive two spaced elements
✅ channel with capacity 10000 should send and receive many elements, with concurrent senders & receivers
✅ channel with capacity 10000 should select from two receives, if the last one has elements
✅ channel with capacity 10000 should select from three receives, if the last one has elements
✅ channel with capacity 10000 should select a receive from multiple channels
✅ channel with capacity 10000 should select a receive until all channels are done
✅ channel with capacity 10000 should properly report channel state
✅ channel with capacity 10000 should skip channels, which are done immediately
✅ channel with capacity 10000 should skip channels, which become done
✅ channel with capacity 10000 should not skip channels, which are done immediately, when requested
✅ channel with capacity 10000 should not skip channels, which become done, when requested
✅ buffered channel should select a send when one is available
✅ channel should receive from a channel until done
✅ channel should not receive from a channel in case of an error
✅ channel should select a receive from a channel if one is not done
✅ direct channel should wait until elements are transmitted
✅ direct channel should select a send when a receive is waiting
✅ direct channel should select a send or receive depending on availability
✅ default should use the default value if the clauses are not satisfiable
✅ default should use the default value if all channels are done
✅ default should not use the default value if a clause is satisfiable
✅ default should not use the default value if the channel is done, and a receiveOrDone clause is used
✅ default should use the default value once a source is done (buffered channel, stress test)

✅ should map over a source as a view
✅ should return done, if all channels are done
✅ should select from sources mapped as view
✅ should filter over a source as a view
✅ should select from sources filtered as a view
✅ should propagate exceptions to the calling select

✅ Source.drop should not drop from the empty source
✅ Source.drop should drop elements from the source
✅ Source.drop should return empty source when more elements than source length was dropped
✅ Source.drop should not drop when 'n == 0'

✅ Source.empty should be done
✅ Source.empty should be empty

✅ Source factory methods should create a source from a fork
✅ Source factory methods should create an iterating source
✅ Source factory methods should unfold a function
✅ Source factory methods should produce a range

✅ Source.failed should fail on receive
✅ Source.failed should be in error

✅ Source.fold should throw ChannelClosedException.Error with exception and message that was thrown during retrieval
✅ Source.fold should throw ChannelClosedException.Error for source failed without exception
✅ Source.fold should throw exception thrown in `f` when `f` throws
✅ Source.fold should return `zero` value from fold on the empty source
✅ Source.fold should return fold on non-empty source
✅ Source.fold should drain the source

✅ Source.foreach should iterate over a source
✅ Source.foreach should iterate over a source using for-syntax
✅ Source.foreach should convert source to a list

✅ SourceOps.futureSource should return the original future failure when future fails
✅ SourceOps.futureSource should return the original future failure when future fails with ExecutionException
✅ SourceOps.futureSource should return future's source values

✅ Source.future should return the original future failure when future fails
✅ Source.future should return the original future failure when future fails with ExecutionException
✅ Source.future should return future value

✅ Source.headOption should return None for the empty source
✅ Source.headOption should throw ChannelClosedException.Error with exception and message that was thrown during retrieval
✅ Source.headOption should throw ChannelClosedException.Error for source failed without exception
✅ Source.headOption should return Some element for the non-empty source
✅ Source.headOption should be not idempotent operation

✅ Source.head should throw NoSuchElementException for the empty source
✅ Source.head should throw ChannelClosedException.Error with exception and message that was thrown during retrieval
✅ Source.head should throw ChannelClosedException.Error for source failed without exception
✅ Source.head should return first value from non empty source
✅ Source.head should be not idempotent operation

✅ Source.interleaveAll should interleave no sources
✅ Source.interleaveAll should interleave a single source
✅ Source.interleaveAll should interleave multiple sources
✅ Source.interleaveAll should interleave multiple sources using custom segment size
✅ Source.interleaveAll should interleave multiple sources using custom segment size and complete eagerly

✅ Source.interleave should interleave with an empty source
✅ Source.interleave should interleave two sources with default segment size
✅ Source.interleave should interleave two sources with default segment size and different lengths
✅ Source.interleave should interleave two sources with custom segment size
✅ Source.interleave should interleave two sources with custom segment size and different lengths
✅ Source.interleave should interleave two sources with different lengths and complete eagerly
✅ Source.interleave should when empty, interleave with a non-empty source and complete eagerly
✅ Source.interleave should interleave with an empty source and complete eagerly

✅ Source.intersperse should intersperse with inject only over an empty source
✅ Source.intersperse should intersperse with inject only over a source with one element
✅ Source.intersperse should intersperse with inject only over a source with multiple elements
✅ Source.intersperse should intersperse with start, inject and end over an empty source
✅ Source.intersperse should intersperse with start, inject and end over a source with one element
✅ Source.intersperse should intersperse with start, inject and end over a source with multiple elements

✅ SourceOps.lastOption should return None for the empty source
✅ SourceOps.lastOption should throw ChannelClosedException.Error with exception and message that was thrown during retrieval
✅ SourceOps.lastOption should throw ChannelClosedException.Error for source failed without exception
✅ SourceOps.lastOption should return last element wrapped in Some for the non-empty source
✅ SourceOps.lastOption should drain the source

✅ SourceOps.last should throw NoSuchElementException for the empty source
✅ SourceOps.last should throw ChannelClosedException.Error with exception and message that was thrown during retrieval
✅ SourceOps.last should throw ChannelClosedException.Error for source failed without exception
✅ SourceOps.last should return last element for the non-empty source
✅ SourceOps.last should drain the source

✅ mapPar should map over a source with parallelism limit 1
✅ mapPar should map over a source with parallelism limit 2
✅ mapPar should map over a source with parallelism limit 3
✅ mapPar should map over a source with parallelism limit 4
✅ mapPar should map over a source with parallelism limit 5
✅ mapPar should map over a source with parallelism limit 6
✅ mapPar should map over a source with parallelism limit 7
✅ mapPar should map over a source with parallelism limit 8
✅ mapPar should map over a source with parallelism limit 9
✅ mapPar should map over a source with parallelism limit 10
✅ mapPar should map over a source with parallelism limit 10 (stress test)
✅ mapPar should propagate errors
✅ mapPar should cancel other running forks when there's an error

✅ Source.mapParUnordered should map over a source with parallelism limit 1
✅ Source.mapParUnordered should map over a source with parallelism limit 2
✅ Source.mapParUnordered should map over a source with parallelism limit 3
✅ Source.mapParUnordered should map over a source with parallelism limit 4
✅ Source.mapParUnordered should map over a source with parallelism limit 5
✅ Source.mapParUnordered should map over a source with parallelism limit 6
✅ Source.mapParUnordered should map over a source with parallelism limit 7
✅ Source.mapParUnordered should map over a source with parallelism limit 8
✅ Source.mapParUnordered should map over a source with parallelism limit 9
✅ Source.mapParUnordered should map over a source with parallelism limit 10
✅ Source.mapParUnordered should map over a source with parallelism limit 10 (stress test)
✅ Source.mapParUnordered should propagate errors
✅ Source.mapParUnordered should complete running forks and not start new ones when the mapping function fails
✅ Source.mapParUnordered should complete running forks and not start new ones when the upstream fails
✅ Source.mapParUnordered should cancel running forks when the surrounding scope closes due to an error
✅ Source.mapParUnordered should emit downstream as soon as a value is ready, regardless of the incoming order

✅ Source.mapStatefulConcat should deduplicate
✅ Source.mapStatefulConcat should count consecutive
✅ Source.mapStatefulConcat should propagate errors in the mapping function
✅ Source.mapStatefulConcat should propagate errors in the completion callback

✅ Source.mapStateful should zip with index
✅ Source.mapStateful should calculate a running total
✅ Source.mapStateful should propagate errors in the mapping function
✅ Source.mapStateful should propagate errors in the completion callback

✅ Source.map should map over a source
✅ Source.map should map over a source (stress test)
✅ Source.map should map over a source using for-syntax

✅ SourceOps.orElse should emit elements only from the original source when it is not empty
✅ SourceOps.orElse should emit elements only from the alternative source when the original source is created empty
✅ SourceOps.orElse should emit elements only from the alternative source when the original source is empty
✅ SourceOps.orElse should return failed source when the original source is failed

✅ SourceOps.reduce should throw NoSuchElementException for reduce over the empty source
✅ SourceOps.reduce should throw ChannelClosedException.Error with exception and message that was thrown during retrieval
✅ SourceOps.reduce should throw ChannelClosedException.Error for source failed without exception
✅ SourceOps.reduce should throw exception thrown in `f` when `f` throws
✅ SourceOps.reduce should return first element from reduce over the single element source
✅ SourceOps.reduce should run reduce over on non-empty source
✅ SourceOps.reduce should drain the source

✅ SourceOps.takeLast should throw ChannelClosedException.Error with exception and message that was thrown during retrieval
✅ SourceOps.takeLast should throw ChannelClosedException.Error for source failed without exception
✅ SourceOps.takeLast should fail to takeLast when n < 0
✅ SourceOps.takeLast should return empty list for the empty source
✅ SourceOps.takeLast should return empty list when n == 0 and list is not empty
✅ SourceOps.takeLast should return list with all elements if the source is smaller than requested number
✅ SourceOps.takeLast should return the last n elements from the source
✅ SourceOps.takeLast should drain the source

✅ Source.takeWhile should not take from the empty source
✅ Source.takeWhile should take as long as predicate is satisfied
✅ Source.takeWhile should not take if predicate fails for first or more elements

✅ should tick regularly
✅ should timeout
✅ should zip two sources
✅ should merge two sources
✅ should pipe one source to another
✅ should concatenate sources

✅ Source.throttle should not throttle the empty source
✅ Source.throttle should throttle to specified elements per time units
✅ Source.throttle should fail to throttle when elements <= 0
✅ Source.throttle should fail to throttle when per lower than 1ms

✅ Source.transform should transform a source using a simple map
✅ Source.transform should transform a source using a complex chain of operations
✅ Source.transform should transform an infinite source
✅ Source.transform should transform an infinite source (stress test)

✅ Source.zipAll should not emit any element when both channels are empty
✅ Source.zipAll should emit this element when other channel is empty
✅ Source.zipAll should emit other element when this channel is empty
✅ Source.zipAll should emit matching elements when both channels are of the same size
✅ Source.zipAll should emit default for other channel if this channel is longer
✅ Source.zipAll should emit default for this channel if other channel is longer

✅ collectPar should output the same type as input
✅ collectPar should run computations in parallel
✅ collectPar should run not more computations than limit
✅ collectPar should interrupt other computations in one fails

✅ timeout should short-circuit a long computation
✅ timeout should not interrupt a short computation

✅ scoped should throw the exception thrown by a joined fork
✅ supervised should throw the exception thrown in the scope
✅ supervised should throw the exception thrown by a failing fork
✅ supervised should interrupt other forks when there's a failure, add suppressed interrupted exceptions
✅ supervised should interrupt other forks when there's a failure, add suppressed custom exceptions
✅ supervised should not add the original exception as suppressed
✅ supervised should add an exception as suppressed, even if it wraps the original exception
✅ joinEither should catch the exception with which a fork ends

✅ filterPar should output the same type as input
✅ filterPar should run computations in parallel
✅ filterPar should run not more computations than limit
✅ filterPar should interrupt other computations in one fails

✅ foreachPar should run computations in parallel
✅ foreachPar should run not more computations than limit
✅ foreachPar should interrupt other computations in one fails

✅ fork should run two forks concurrently
✅ fork should allow nested forks
✅ fork should allow extension method syntax
✅ fork should interrupt child forks when parents complete

✅ fork locals should properly propagate values
✅ fork locals should propagate values across multiple scopes

✅ mapPar should output the same type as input
✅ mapPar should run computations in parallel
✅ mapPar should run not more computations than limit
✅ mapPar should interrupt other computations in one fails

✅ par should run computations in parallel
✅ par should interrupt other computations in one fails
✅ parLimit should run up to the given number of computations in parallel
✅ parLimit should interrupt other computations in one fails

✅ timeout should short-circuit a long computation
✅ timeout should not interrupt a short computation
✅ timeoutOption should short-circuit a long computation
✅ timeoutOption should race a slower and faster computation
✅ timeoutOption should race a faster and slower computation

✅ useInScope should release resources after allocation
✅ useInScope should release resources in reverse order
✅ useInScope should release resources when there's an exception
✅ useInScope should release resources when there's an exception during releasing
✅ useScoped should release resources after allocation

✅ Backoff retry should retry a function
✅ Backoff retry should retry a failing function forever
✅ Backoff retry should respect maximum delay
✅ Backoff retry should use jitter
✅ Backoff retry should retry an Either
✅ Backoff retry should retry a Try

✅ Delayed retry should retry a function
✅ Delayed retry should retry a failing function forever
✅ Delayed retry should retry an Either
✅ Delayed retry should retry a Try

✅ Immediate retry should retry a succeeding function
✅ Immediate retry should fail fast when a function is not worth retrying
✅ Immediate retry should retry a succeeding function with a custom success condition
✅ Immediate retry should retry a failing function
✅ Immediate retry should retry a failing function forever
✅ Immediate retry should retry a succeeding Either
✅ Immediate retry should fail fast when an Either is not worth retrying
✅ Immediate retry should retry a succeeding Either with a custom success condition
✅ Immediate retry should retry a failing Either
✅ Immediate retry should retry a succeeding Try
✅ Immediate retry should fail fast when a Try is not worth retrying
✅ Immediate retry should retry a succeeding Try with a custom success condition
✅ Immediate retry should retry a failing Try

✅ Jitter should use no jitter
✅ Jitter should use full jitter
✅ Jitter should use equal jitter
✅ Jitter should use decorrelated jitter

✅ Retry syntax should support operations that return a result directly
✅ Retry syntax should support operations that return a Try
✅ Retry syntax should support operations that return an Either

✅ supervised should wait until all forks complete
✅ supervised should not wait until daemon forks complete
✅ supervised should interrupt once any fork ends with an exception
✅ supervised should interrupt main fork once a fork ends with an exception
✅ supervised should not interrupt if an unsupervised fork ends with an exception

✅ should crawl a test data set basic
✅ should crawl a test data set single domain chain
✅ should crawl a test data set multiple domain chain
✅ should crawl a test data set dense links
✅ should crawl a test data set single domain chain (timed)
✅ should crawl a test data set dense links (timed)

✅ should rate limit futures scheduled upfront
✅ should maintain the rate limit in all time windows

✅ should distribute message and connect new clients

✅ should forward messages and recover from failures

✅ source should receive messages from a topic
✅ stage should publish messages to a topic
✅ stage should commit offsets of processed messages
✅ drain should publish messages to a topic
✅ drain should commit offsets of processed messages