Test

should exist

should not allow convert to observable if given kind is unknown

should return a Notification

should return a Notification

should return a Notification

should create observable from a next Notification

should create observable from a complete Notification

should create observable from a error Notification

should create new next Notification with value

should create new error Notification

should return static next Notification reference without value

should return static complete Notification reference

should invoke on next

should invoke on error

should invoke on complete

should accept observer for next Notification

should accept observer for error Notification

should accept observer for complete Notification

should accept function for next Notification

should accept function for error Notification

should accept function for complete Notification

should observe for next Notification

should observe for error Notification

should observe for complete Notification

should be constructed with a subscriber function

should send errors thrown in the constructor down the error path

should not send error to error handler for observable have source

should rethrow if sink has syncErrorThrowable = false

should iterate and return a Promise

should reject promise when in error

should allow Promise to be globally configured

should reject promise if nextHandler throws

should handle a synchronous throw from the next handler and tear down

should handle an asynchronous throw from the next handler and tear down

should be synchronous

should work when subscribe is called with no arguments

should not be unsubscribed when other empty subscription completes

should not be unsubscribed when other subscription with same observer completes

should run unsubscription logic when an error is sent synchronously and subscribe is called with no arguments

should run unsubscription logic when an error is sent asynchronously and subscribe is called with no arguments

should return a Subscription that calls the unsubscribe function returned by the subscriber

should run unsubscription logic when an error is thrown sending messages synchronously

should dispose of the subscriber when an error is thrown sending messages synchronously

should ignore next messages after unsubscription

should ignore error messages after unsubscription

should ignore complete messages after unsubscription

should accept an anonymous observer with no functions at all

should ignore next messages after unsubscription

should ignore error messages after unsubscription

should ignore complete messages after unsubscription

should exist

should pipe multiple operations

should return the same observable if there are no arguments

should create an Observable

should provide an observer to the function

should send errors thrown in the passed function down the error path

should be overrideable in a custom Observable type that composes

should compose through multicast and refCount

should compose through multicast with selector function

should compose through combineLatest

should compose through concat

should compose through merge

should compose through race

should compose through zip

should schedule things recursively

should schedule things recursively via this.schedule

should schedule things in the future too

should be reusable after an error is thrown during execution

should pump values right on through itself

should pump values to multiple subscribers

should disallow new subscriber once subject has been disposed

should not allow values to be nexted after it is unsubscribed

should clean out unsubscribed subscribers

should have a static create function that works

should have a static create function that works also to raise errors

should be an Observer which can be given to Observable.subscribe

should be usable as an Observer of a finite delayed Observable

should throw ObjectUnsubscribedError when emit after unsubscribed

should not next after completed

should not next after error

should hide subject

should handle subject never emits

should handle subject completes without emits

should handle subject throws

should handle subject emits

should work with inherited subject

should be exposed

should not eager

should ignore next messages after unsubscription

should ignore error messages after unsubscription

should ignore complete messages after unsubscription

should not be closed when other subscriber with same observer instance completes

should call complete observer without any arguments

should not call error() if next() handler throws an error

should not leak

should not leak when adding a bad custom subscription to a subscription

Should returns the self if the self is passed

Should returns Subscription.EMPTY if it is passed

Should returns Subscription.EMPTY if it is called with void value

Should returns a new Subscription created with teardown function if it is passed a function

Should wrap the AnonymousSubscription and return a subscription that unsubscribes and removes it when unsubbed

Should returns the passed one if passed a AnonymousSubscription having not function unsubscribe member

Should returns the passed one if the self has been unsubscribed

Should unsubscribe the passed one if the self has been unsubscribed

should have rxjs/observable/bindCallback

should have rxjs/observable/bindNodeCallback

should have rxjs/observable/combineLatest

should have rxjs/observable/concat

should have rxjs/observable/defer

should have rxjs/observable/empty

should have rxjs/observable/forkJoin

should have rxjs/observable/from

should have rxjs/observable/fromEvent

should have rxjs/observable/fromEventPattern

should have rxjs/observable/fromPromise

should have rxjs/observable/if

should have rxjs/observable/interval

should have rxjs/observable/merge

should have rxjs/observable/never

should have rxjs/observable/of

should have rxjs/observable/onErrorResumeNext

should have rxjs/observable/pairs

should have rxjs/observable/race

should have rxjs/observable/range

should have rxjs/observable/throw

should have rxjs/observable/timer

should have rxjs/observable/using

should have rxjs/observable/zip

should create an Observable via constructor

should create IteratorObservable via static create function

should not accept null (or truthy-equivalent to null) iterator

should not accept boolean as iterator

should emit members of an array iterator

should finalize generators if the subscription ends

should finalize generators if the subscription and it is scheduled

should emit members of an array iterator on a particular scheduler

should emit characters of a string iterator

should be possible to unsubscribe in the middle of the iteration

should create expose a value property

should create ScalarObservable via static create function

should not schedule further if subscriber unsubscribed

should set _isScalar to true when NOT called with a Scheduler

should set _isScalar to false when called with a Scheduler

should create Observable to be subscribed on specified scheduler

should specify default scheduler if incorrect scheduler specified

should create observable via staic create function

should subscribe after specified delay

should consider negative delay as zero

should pass multiple inner arguments as an array

should pass multiple inner arguments to the selector if there is one

should cache value for next subscription and not call callbackFunc again

should not even call the callbackFn if immediately unsubscribed

should emit undefined from a callback without arguments

should emit one value from a callback

should set callback function context to context of returned function

should emit one value chosen by a selector

should emit an error when the selector throws

should not emit, throw or complete if immediately unsubscribed

should emit undefined from a callback without arguments

should emit one value from a callback

should set callback function context to context of returned function

should error if callback throws

should error if selector throws

should use a selector

should pass multiple inner arguments as an array

should pass multiple inner arguments to the selector if there is one

should cache value for next subscription and not call callbackFunc again

should emit undefined when callback is called without success arguments

should emit one value from a callback

should set context of callback to context of boundCallback

should emit one value chosen by a selector

should raise error from callback

should emit an error when the selector throws

should not emit, throw or complete if immediately unsubscribed

should emit undefined when callback is called without success arguments

should emit one value from a callback

should set context of callback to context of boundCallback

should error if callback throws

should raise error from callback

should error if selector throws

should use a selector

should combineLatest the provided observables

should combine an immediately-scheduled source with an immediately-scheduled second

should accept array of observables

should work with two nevers

should work with never and empty

should work with empty and never

should work with empty and empty

should work with hot-empty and hot-single

should work with hot-single and hot-empty

should work with hot-single and never

should work with never and hot-single

should work with hot and hot

should work with empty and error

should work with error and empty

should work with hot and throw

should work with throw and hot

should work with throw and throw

should work with error and throw

should work with throw and error

should work with never and throw

should work with throw and never

should work with some and throw

should work with throw and some

should handle throw after complete left

should handle throw after complete right

should handle interleaved with tail

should handle two consecutive hot observables

should handle two consecutive hot observables with error left

should handle two consecutive hot observables with error right

should handle selector throwing

should allow unsubscribing early and explicitly

should not break unsubscription chains when unsubscribed explicitly

should support promises

should support observables

should support mixed observables and promises

should support arrays of promises

should support arrays of observables

should return Array<T> when given a single promise

should return Array<T> when given a single observable

should emit elements from multiple sources

should concat the same cold observable multiple times

should not break unsubscription chains when result is unsubscribed explicitly

should complete without emit if both sources are empty

should not complete if first source does not completes

should not complete if second source does not completes

should not complete if both sources do not complete

should raise error when first source is empty, second source raises error

should raise error when first source raises error, second source is empty

should raise first error when both source raise error

should concat if first source emits once, second source is empty

should concat if first source is empty, second source emits once

should not complete if first source does not complete

should emit elements from each source when source emit once

should unsubscribe to inner source if outer is unsubscribed early

should raise error from first source and does not emit from second source

should emit element from first source then raise error from second source

should not emit collapsing element from second source

should return empty if concatenating an empty source

should error immediately if given a just-throw source

should not emit collapsing element from second source

should concat an immediately-scheduled source with an immediately-scheduled second

should use the scheduler even when one Observable is concat'd

should return passed observable if no scheduler was passed

should return RxJS Observable when single lowerCaseO was passed

should create an observable from the provided observable factory

should create an observable from completed

should accept factory returns promise resolves

should accept factory returns promise rejects

should create an observable from error

should create an observable when factory throws

should allow unsubscribing early and explicitly

should not break unsubscription chains when result is unsubscribed explicitly

should create default XMLHttpRequest for non CORS

should try to create AXObject for XHR in old version of IE

should throw if not able to create XMLHttpRequest

should create XMLHttpRequest for CORS

should try to create XDomainRequest for CORS if XMLHttpRequest is not available

should throw if not able to create CORS request

should set headers

should not set default Content-Type header when no body is sent

should error if createXHR throws

should error if send request throws

should succeed on 200

should fail on 404

should fail on 404

should succeed no settings

should fail no settings

should create an asynchronous request

should create a synchronous request

should work fine when XMLHttpRequest onreadystatechange property is monkey patched

should work fine when XMLHttpRequest ontimeout property is monkey patched

should work fine when XMLHttpRequest onprogress property is monkey patched

should work fine when XMLHttpRequest onerror property is monkey patched

can take string body

can take FormData body

should not fail when FormData is undefined

should send by form-urlencoded format

should send by JSON

should error if send request throws

should succeed on 200

should succeed on 204 No Content

should able to select json response via getJSON

should succeed on 200

should succeed on 204 No Content

should succeed in IE on 204 No Content

should emit progress event when progressSubscriber is specified

should emit progress event when progressSubscriber is specified in IE

should create an AjaxObservable with correct options

should send and receive messages

should allow the user to chain operators

receive multiple messages

should queue messages prior to subscription

should send messages immediately if already open

should close the socket when completed

should close the socket with a code and a reason when errored

should allow resubscription after closure via complete

should allow resubscription after closure via error

should have a default resultSelector that parses message data as JSON

should send and receive messages

should take a protocol and set it properly on the web socket

should take a binaryType and set it properly on the web socket

should take a resultSelector

if the resultSelector fails it should go down the error path

should accept a closingObserver

should accept a closeObserver

should handle constructor errors

should be retryable

should be repeatable

should multiplex over the websocket

should keep the same socket for multiple multiplex subscriptions

should not close the socket until all subscriptions complete

should join the last values of the provided observables into an array

should allow emit null or undefined

should join the last values of the provided observables with selector

should accept single observable

should accept array of observable contains single

should accept single observable with selector

should accept array of observable contains single with selector

should accept lowercase-o observables

should accept empty lowercase-o observables

should accept promise

should accept array of observables

should accept array of observables with selector

should not emit if any of source observable is empty

should complete early if any of source is empty and completes before than others

should complete when all sources are empty

should not complete when only source never completes

should not complete when one of the sources never completes

should complete when one of the sources never completes but other completes without values

should complete if source is not provided

should complete if sources list is empty

should complete when any of source is empty with selector

should emit results by resultselector

should raise error when any of source raises error with empty observable

should raise error when any of source raises error with source that never completes

should raise error when any of source raises error with selector with empty observable

should raise error when source raises error

should raise error when source raises error with selector

should allow unsubscribing early and explicitly

should unsubscribe other Observables, when one of them errors

should support promises

should support observables

should support mixed observables and promises

should support arrays of promises

should support arrays of observables

should return Array<T> when given a single promise

should return Array<T> when given a single observable

should emit one value from a resolved promise

should raise error from a rejected promise

should share the underlying promise with multiple subscribers

should accept already-resolved Promise

should accept PromiseLike object for interoperability

should emit a value from a resolved promise on a separate scheduler

should raise error from a rejected promise on a separate scheduler

should share the underlying promise with multiple subscribers on a separate scheduler

should not emit, throw or complete if immediately unsubscribed

should globally throw unhandled errors on process

should globally throw unhandled errors on window

should throw for non observable object

should return T for ObservableLike objects

should return T for arrays

should setup an event observable on objects with "on" and "off"

should setup an event observable on objects with "addEventListener" and "removeEventListener"

should setup an event observable on objects with "addListener" and "removeListener"

should error on invalid event targets

should pass through options to addEventListener

should pass through events that occur

should pass through events that occur and use the selector if provided

should not fail if no event arguments are passed and the selector does not return

should return a value from the selector if no event arguments are passed

should pass multiple arguments to selector from event emitter

should not throw an exception calling toString on obj with a null prototype

should call addHandler on subscription

should call removeHandler on unsubscription

should work without optional removeHandler

should deliver return value of addHandler to removeHandler as signal

should send errors in addHandler down the error path

should accept a selector that maps outgoing values

should send errors in the selector down the error path

should use result selector

should allow omit condition

should stop producing when unsubscribed

should accept a scheduler

should allow minimal possible options

should emit error if result selector throws

should emit error if result selector throws on scheduler

should emit error after first value if iterate function throws

should emit error after first value if iterate function throws on scheduler

should emit error if condition function throws

should emit error if condition function throws on scheduler

should subscribe to thenSource when the conditional returns true

should subscribe to elseSource when the conditional returns false

should complete without an elseSource when the conditional returns false

should raise error when conditional throws

should accept resolved promise as thenSource

should accept resolved promise as elseSource

should accept rejected promise as elseSource

should accept rejected promise as thenSource

should set up an interval

should specify default scheduler if incorrect scheduler specified

should emit when relative interval set to zero

should consider negative interval as zero

should emit values until unsubscribed

should create an observable emitting periodically with the AsapScheduler

should create an observable emitting periodically with the QueueScheduler

should create an observable emitting periodically with the AnimationFrameScheduler

should merge cold and cold

should return itself when try to merge single observable

should merge hot and hot

should merge hot and cold

should merge parallel emissions

should merge empty and empty

should merge three empties

should merge never and empty

should merge never and never

should merge empty and throw

should merge hot and throw

should merge never and throw

should merge empty and eventual error

should merge hot and error

should merge never and error

should merge single lowerCaseO into RxJS Observable

should merge two lowerCaseO into RxJS Observable

should merge single lowerCaseO into RxJS Observable

should handle concurrency limits

should handle scheduler

should handle scheduler with concurrency limits

should use the scheduler even when one Observable is merged

should create an observable from the provided values

should return a scalar observable if only passed one value

should return a scalar observable if only passed one value and a scheduler

should return an array observable if passed many values

should return an empty observable if passed no values

should return an empty observable if passed only a scheduler

should emit one value

should handle an Observable as the only value

should handle many Observable as the given values

should continue with observables

should continue array of observables

should complete single observable throws

should create an observable without scheduler

should work with empty object

should race a single observable

should race cold and cold

should race with array of observable

should race hot and hot

should race hot and cold

should race 2nd and 1st

should race emit and complete

should allow unsubscribing early and explicitly

should not break unsubscription chains when unsubscribed explicitly

should never emit when given non emitting sources

should throw when error occurs mid stream

should throw when error occurs before a winner is found

handle empty

handle never

handle throw

should synchronously create a range of values by default

should accept a scheduler

should create a RangeObservable

should accept a scheduler

should complete if index >= count

should next out another value and increment the index and start

should emit one value

should create expose a error property

should create ErrorObservable via static create function

should accept scheduler

should schedule a value of 0 then complete

should emit a single value immediately

should start after delay and periodically emit values

should start immediately and periodically emit values

should stop emiting values when subscription is done

should schedule a value at a specified Date

should start after delay and periodically emit values

should dispose of the resource when the subscription is disposed

should accept factory returns promise resolves

should accept factory returns promise rejects

should raise error when resource factory throws

should raise error when observable factory throws

should combine a source with a second

should zip the provided observables

should end once one observable completes and its buffer is empty

should combine two observables and selector

should work with n-ary symmetric

should work with n-ary symmetric selector

should work with n-ary symmetric array selector

should work with some data asymmetric 1

should work with some data asymmetric 2

should work with some data symmetric

should work with selector throws

should work with right completes first

should work with two nevers

should work with never and empty

should work with empty and never

should work with empty and empty

should work with empty and non-empty

should work with non-empty and empty

should work with never and non-empty

should work with non-empty and never

should work with empty and error

should work with error and empty

should work with error

should work with never and error

should work with error and never

should work with error and error

should work with two sources that eventually raise errors

should work with two sources that eventually raise errors (swapped)

should work with error and some

should combine an immediately-scheduled source with an immediately-scheduled second

should support observables

should support mixed observables and promises

should support arrays of promises

should support arrays of observables

should return Array<T> when given a single promise

should return Array<T> when given a single observable

should zip them with values

should only call next as needed

should work with never observable and empty iterable

should work with empty observable and empty iterable

should work with empty observable and non-empty iterable

should work with non-empty observable and empty iterable

should work with never observable and non-empty iterable

should work with non-empty observable and non-empty iterable

should work with non-empty observable and empty iterable

should work with observable which raises error and non-empty iterable

should work with non-empty many observable and non-empty many iterable

should work with non-empty observable and non-empty iterable selector that throws

should delay the source if values are not emitted often enough

should audit with duration Observable using next to close the duration

should interrupt source and duration when result is unsubscribed early

should not break unsubscription chains when result is unsubscribed explicitly

should handle a busy producer emitting a regular repeating sequence

should mirror source if durations are always empty

should mirror source if durations are Observable.empty()

should emit no values if duration is a never

should unsubscribe duration Observable when source raise error

should raise error as soon as just-throw duration is used

should audit using durations of constying lengths

should propagate error from duration Observable

should propagate error thrown from durationSelector function

should complete when source does not emit

should raise error when source does not emit and raises error

should handle an empty source

should handle a never source

should handle a throw source

should audit by promise resolves

should raise error when promise rejects

should auditTime events by 50 time units

should auditTime events multiple times

should delay the source if values are not emitted often enough

should handle a busy producer emitting a regular repeating sequence

should complete when source does not emit

should raise error when source does not emit and raises error

should handle an empty source

should handle a never source

should handle a throw source

should not complete when source does not complete

should not break unsubscription chains when result is unsubscribed explicitly

should auditTime values until source raises error

should work with empty and empty selector

should work with empty and non-empty selector

should work with non-empty and empty selector

should work with never and never selector

should work with never and empty selector

should work with empty and never selector

should work with non-empty and throw selector

should work with throw and non-empty selector

should work with error

should work with error and non-empty selector

should work with selector

should work with selector completed

should allow unsubscribing the result Observable early

should not break unsubscription chains when unsubscribed explicitly

should work with non-empty and selector error

should work with non-empty and empty selector error

should work with non-empty and selector error

should unsubscribe notifier when source unsubscribed

should unsubscribe notifier when source unsubscribed

should emit buffers at buffersize of intervals if not specified

should buffer properly (issue #2062)

should emit partial buffers if source completes before reaching specified buffer count

should emit full buffer then last partial buffer if source completes

should emit buffers at intervals, but stop when result is unsubscribed early

should not break unsubscription chains when result is unsubscribed explicitly

should raise error if source raise error before reaching specified buffer count

should emit buffers with specified skip count when skip count is less than window count

should emit buffers with specified skip count when skip count is more than window count

should emit buffers at intervals test 2

should emit buffers at intervals or when the buffer is full

should emit buffers at intervals or when the buffer is full test 2

should emit buffers that have been created at intervals and close after the specified delay

should emit buffers with timeSpan 100 and creationInterval 70

should emit buffers but handle source ending with an error

should emit buffers and allow result to unsubscribed early

should not break unsubscription chains when result is unsubscribed explicitly

should handle empty

should handle never

should handle throw

should handle errors

should not throw when subscription synchronously unsubscribed after emit

should not have errors when take follows and maxBufferSize is provided

should emit buffers using constying cold closings

should emit buffers using constying hot closings

should emit buffers using constying empty delayed closings

should emit buffers using constying cold closings, outer unsubscribed early

should not break unsubscription chains when result is unsubscribed explicitly

should propagate error thrown from closingSelector

should propagate error emitted from a closing

should propagate error emitted late from a closing

should handle errors

should handle empty source

should handle throw

should handle never

should handle a never opening Observable

should handle a never closing Observable

should handle opening Observable that just throws

should accept openings resolved promise

should accept openings rejected promise

should accept closing selector that returns a resolved promise

should accept closing selector that returns a rejected promise

should handle empty closing observable

should emit buffers using constying cold closings

should emit buffers using constying hot closings

should emit buffers using constying empty delayed closings

should emit buffers using constying cold closings, outer unsubscribed early

should not break unsubscription chains when result is unsubscribed explicitly

should propagate error thrown from closingSelector

should propagate error emitted from a closing

should propagate error emitted late from a closing

should handle errors

should handle empty

should handle throw

should handle never

should handle an inner never

should NOT handle hot inner empty

should handle inner throw

should handle disposing of source

should catch error and replace it with Observable.of()

should catch error and replace it with a cold Observable

should allow unsubscribing explicitly and early

should not break unsubscription chain when unsubscribed explicitly

should unsubscribe from a caught hot caught observable when unsubscribed explicitly

should unsubscribe from a caught cold caught observable when unsubscribed explicitly

should catch error and replace it with a hot Observable

should catch and replace a Observable.throw() as the source

should mirror the source if it does not raise errors

should complete if you return Observable.empty()

should raise error if you return Observable.throw()

should never terminate if you return Observable.never()

should pass the error as the first argument

should accept selector returns any ObservableInput

should chain a throw from a promise using throw

should chain a throw from a promise using Observable.throw

should chain a throw from a promise using Observable.throw

should work with two nevers

should work with never and empty

should work with empty and never

should work with empty and empty

should work with hot-empty and hot-single

should work with hot-single and hot-empty

should work with hot-single and never

should work with never and hot-single

should work with hot and hot

should allow unsubscribing early and explicitly

should not break unsubscription chains when unsubscribed explicitly

should combine 3 observables

should work with empty and error

should work with error and empty

should work with hot and throw

should work with throw and hot

should work with throw and throw

should work with error and throw

should work with throw and error

should work with never and throw

should work with throw and never

should work with some and throw

should work with throw and some

should handle throw after complete left

should handle throw after complete right

should handle interleaved with tail

should handle two consecutive hot observables

should handle two consecutive hot observables with error left

should handle two consecutive hot observables with error right

should handle selector throwing

should combine two observables

should combine two immediately-scheduled observables

should work with two nevers

should work with never and empty

should work with empty and never

should work with empty and empty

should work with hot-empty and hot-single

should work with hot-single and hot-empty

should work with hot-single and never

should work with never and hot-single

should work with hot and hot

should accept array of observables

should work with empty and error

should work with error and empty

should work with hot and throw

should work with throw and hot

should work with throw and throw

should work with error and throw

should work with throw and error

should work with never and throw

should work with throw and never

should work with some and throw

should work with throw and some

should handle throw after complete left

should handle throw after complete right

should handle interleaved with tail

should handle two consecutive hot observables

should handle two consecutive hot observables with error left

should handle two consecutive hot observables with error right

should handle selector throwing

should allow unsubscribing early and explicitly

should not break unsubscription chains when unsubscribed explicitly

should emit unique array instances with the default projection

should work properly with scalar observables

should complete without emit if both sources are empty

should not complete if first source does not completes

should not complete if second source does not completes

should not complete if both sources do not complete

should raise error when first source is empty, second source raises error

should raise error when first source raises error, second source is empty

should raise first error when both source raise error

should concat if first source emits once, second source is empty

should concat if first source is empty, second source emits once

should not complete if first source does not complete

should emit elements from each source when source emit once

should unsubscribe to inner source if outer is unsubscribed early

should not break unsubscription chains when result is unsubscribed explicitly

should raise error from first source and does not emit from second source

should emit element from first source then raise error from second source

should not emit collapsing element from second source

should accept scheduler with multiple observables

should accept scheduler without observable parameters

should emit self without parameters

should concat sources from promise

should concat and raise error from promise

should concat all observables in an observable

should throw if any child observable throws

should concat merging a hot observable of non-overlapped observables

should raise error if inner observable raises error

should raise error if outer observable raises error

should complete without emit if both sources are empty

should not complete if first source does not completes

should not complete if second source does not completes

should not complete if both sources do not complete

should raise error when first source is empty, second source raises error

should raise error when first source raises error, second source is empty

should raise first error when both source raise error

should concat if first source emits once, second source is empty

should concat if first source is empty, second source emits once

should not complete if first source does not complete

should emit elements from each source when source emit once

should unsubscribe to inner source if outer is unsubscribed early

should not break unsubscription chains when result is unsubscribed explicitly

should raise error from first source and does not emit from second source

should emit element from first source then raise error from second source

should not emit collapsing element from second source

should be able to work on a different scheduler

should concatAll a nested observable with a single inner observable

should concatAll a nested observable with a single inner observable, and a scheduler

should concatenate many regular interval inners

should concatMap many outer values to many inner values

should handle an empty source

should handle a never source

should error immediately if given a just-throw source

should return a silenced version of the source if the mapped inner is empty

should return a never if the mapped inner is never

should propagate errors if the mapped inner is a just-throw Observable

should concatMap many outer to many inner, complete late

should concatMap many outer to many inner, outer never completes

should concatMap many outer to many inner, inner never completes

should concatMap many outer to many inner, and inner throws

should concatMap many outer to many inner, and outer throws

should concatMap many outer to many inner, both inner and outer throw

should concatMap many complex, where all inners are finite

should concatMap many complex, all inners finite except one

should concatMap many complex, inners finite, outer does not complete

should concatMap many complex, all inners finite, and outer throws

should concatMap many complex, all inners complete except one throws

should concatMap many complex, all inners finite, outer is unsubscribed early

should not break unsubscription chains when result is unsubscribed explicitly

should concatMap many complex, all inners finite, project throws

should concatMap many outer to an array for each value

should concatMap many outer to inner arrays, using resultSelector

should concatMap many outer to inner arrays, and outer throws

should concatMap many outer to inner arrays, resultSelector, outer throws

should mergeMap many outer to inner arrays, outer unsubscribed early

should concatMap many outer to inner arrays, resultSelector, outer unsubscribed

should concatMap many outer to inner arrays, project throws

should concatMap many outer to inner arrays, resultSelector throws

should concatMap many outer to inner arrays, resultSelector, project throws

should map values to constant resolved promises and concatenate

should map values to constant rejected promises and concatenate

should map values to resolved promises and concatenate

should map values to rejected promises and concatenate

should concatMap values to resolved promises with resultSelector

should concatMap values to rejected promises with resultSelector

should concatMapTo many outer values to many inner values

should handle an empty source

should handle a never source

should error immediately if given a just-throw source

should return a silenced version of the source if the mapped inner is empty

should return a never if the mapped inner is never

should propagate errors if the mapped inner is a just-throw Observable

should concatMapTo many outer to many inner, complete late

should concatMapTo many outer to many inner, outer never completes

should not break unsubscription chains when result is unsubscribed explicitly

should concatMapTo many outer to many inner, inner never completes

should concatMapTo many outer to many inner, and inner throws

should concatMapTo many outer to many inner, and outer throws

should concatMapTo many outer to many inner, both inner and outer throw

should concatMapTo many outer to an array

should concatMapTo many outer to inner arrays, using resultSelector

should concatMapTo many outer to inner arrays, and outer throws

should concatMapTo many outer to inner arrays, resultSelector, outer throws

should mergeMap many outer to inner arrays, outer unsubscribed early

should concatMapTo many outer to inner arrays, resultSelector, outer unsubscribed

should concatMapTo many outer to inner arrays, resultSelector throws

should map values to constant resolved promises and concatenate

should map values to constant rejected promises and concatenate

should concatMapTo values to resolved promises with resultSelector

should concatMapTo values to rejected promises with resultSelector

should be never when source is never

should be zero when source is empty

should be never when source doesn't complete

should be zero when source doesn't have values

should count the unique value of an observable

should count the values of an ongoing hot observable

should count a range() source observable

should count a range().skip(1) source observable

should count a range().take(1) source observable

should work with error

should work with throw

should handle an always-true predicate on an empty hot observable

should handle an always-false predicate on an empty hot observable

should handle an always-true predicate on a simple hot observable

should handle an always-false predicate on a simple hot observable

should allow unsubscribing early and explicitly

should not break unsubscription chains when result is unsubscribed explicitly

should handle a match-all predicate on observable with many values

should handle a match-none predicate on observable with many values

should handle an always-true predicate on observable that throws

should handle an always-false predicate on observable that throws

should handle an always-true predicate on a hot never-observable

should handle a predicate that throws, on observable with many values

should delay all element by selector observable

should debounce by selector observable

should complete when source does not emit

should complete when source is empty

should raise error when source does not emit and raises error

should raise error when source throws

should allow unsubscribing early and explicitly

should not break unsubscription chains when unsubscribed explicitly

should debounce and does not complete when source does not completes

should not completes when source does not completes

should not completes when source never completes

should delay all element until source raises error

should debounce all elements while source emits by selector observable

should debounce all element while source emits by selector observable until raises error

should delay element by same selector observable emits multiple

should debounce by selector observable emits multiple

should debounce by selector observable until source completes

should raise error when selector observable raises error

should raise error when source raises error with selector observable

should raise error when selector function throws

should mirror the source when given an empty selector Observable

should ignore all values except last, when given a never selector Observable

should delay element by selector observable completes when it does not emits

should debounce by selector observable completes when it does not emits

should delay by promise resolves

should raises error when promise rejects

should delay all element by the specified time

should debounce and delay element by the specified time

should complete when source does not emit

should complete when source is empty

should raise error when source does not emit and raises error

should raise error when source throws

should allow unsubscribing early and explicitly

should not break unsubscription chains when unsubscribed explicitly

should debounce and does not complete when source does not completes

should not completes when source does not completes

should not completes when source never completes

should delay all element until source raises error

should debounce all elements while source emits within given time

should debounce all element while source emits within given time until raises error

should return the argument if Observable is empty

should return null if the Observable is empty and no arguments

should return the Observable if not empty with a default value

should return the Observable if not empty with no default value

should allow unsubscribing early and explicitly

should not break unsubscription chains when unsubscribed explicitly

should error if the Observable errors

should delay by absolute time period

should delay by absolute time period after subscription

should raise error when source raises error

should raise error when source raises error

should raise error when source raises error after subscription

should delay when source does not emits

should delay when source is empty

should not complete when source does not completes

should not break unsubscription chains when result is unsubscribed explicitly

should not complete when source never completes

should delay by selector

should raise error if source raises error

should raise error if selector raises error

should delay by selector and completes after value emits

should delay by selector completes if selector does not emits

should not emit if selector never emits

should delay by first value from selector

should delay by selector does not completes

should raise error if selector throws

should start subscription when subscription delay emits

should start subscription when subscription delay completes without emit value

should raise error when subscription delay raises error

should complete when duration selector returns synchronous observable

should dematerialize a happy stream

should dematerialize a sad stream

should dematerialize stream does not completes

should dematerialize stream never completes

should dematerialize stream does not emit

should dematerialize empty stream

should dematerialize stream throws

should allow unsubscribing early and explicitly

should not break unsubscription chains when unsubscribed explicitly

should dematerialize and completes when stream compltes with complete notification

should dematerialize and completes when stream emits complete notification

should distinguish between values

should distinguish between values and does not completes

should not completes if source never completes

should not completes if source does not completes

should complete if source is empty

should complete if source does not emit

should emit if source emits single element only

should emit if source is scalar

should raises error if source raises error

should raises error if source throws

should not omit if source elements are all different

should allow unsubscribing early and explicitly

should not break unsubscription chains when unsubscribed explicitly

should emit once if source elements are all same

should distinguish values by key

should raises error when selector throws

should support a flushing stream

should raise error if flush raises error

should unsubscribe from the flushing stream when the main stream is unsubbed

should allow opting in to default comparator with flush

should distinguish between values

should distinguish between values and does not completes

should not completes if source never completes

should not completes if source does not completes

should complete if source is empty

should complete if source does not emit

should emit if source emits single element only

should emit if source is scalar

should raises error if source raises error

should raises error if source throws

should not omit if source elements are all different

should allow unsubscribing early and explicitly

should not break unsubscription chains when unsubscribed explicitly

should emit once if source elements are all same

should emit once if comparator returns true always regardless of source emits

should emit all if comparator returns false always regardless of source emits

should distinguish values by comparator

should raises error when comparator throws

should use the keySelector to pick comparator values

should raises error when keySelector throws

should distinguish between values

should distinguish between values and does not completes

should distinguish between values with key

should not compare if source does not have element with key

should not completes if source never completes

should not completes if source does not completes

should complete if source is empty

should complete if source does not emit

should emit if source emits single element only

should emit if source is scalar

should raises error if source raises error

should raises error if source throws

should not omit if source elements are all different

should allow unsubscribing early and explicitly

should not break unsubscription chains when unsubscribed explicitly

should emit once if source elements are all same

should emit once if comparer returns true always regardless of source emits

should emit all if comparer returns false always regardless of source emits

should distinguish values by selector