Home Manual Reference Source Test Repository

Test

Description Identifier Count

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 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 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

-
spec-js/Observable-spec.js -
spec-js/Observable-spec.js -
spec-js/Observable-spec.js -

should accept an anonymous observer with no functions at all

-
spec-js/Observable-spec.js -

should ignore next messages after unsubscription

-

should ignore error messages after unsubscription

-

should ignore complete messages after unsubscription

-

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

-
spec-js/Observable-spec.js -

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

-
spec-js/Subject-spec.js -
spec-js/Subject-spec.js -
spec-js/Subject-spec.js -
spec-js/Subject-spec.js -

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 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 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

-
spec-js/observables/IteratorObservable-spec.js -

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

-
spec-js/observables/concat-spec.js -

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

-
spec-js/observables/concat-spec.js -

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

-
spec-js/observables/concat-spec.js -
spec-js/observables/concat-spec.js -

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

-
spec-js/observables/concat-spec.js -

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 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 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 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 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 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

-
spec-js/observables/from-spec.js -
spec-js/observables/from-spec.js -

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 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

-
spec-js/observables/zip-spec.js -

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 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

-
spec-js/operators/bufferTime-spec.js -

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

-
spec-js/operators/bufferTime-spec.js -

should not throw when subscription synchronously unsubscribed after emit

-

should not have errors when take follows and maxBufferSize is provided

-
spec-js/operators/bufferToggle-spec.js -

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

-
spec-js/operators/catch-spec.js -
spec-js/operators/catch-spec.js -

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 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

-
spec-js/operators/concat-spec.js -

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

-
spec-js/operators/concat-spec.js -
spec-js/operators/concat-spec.js -

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

-
spec-js/operators/concatAll-spec.js -

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

-
spec-js/operators/concatAll-spec.js -
spec-js/operators/concatAll-spec.js -

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 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

-

should raises error when comparer throws

-

should next with a callback

-

should error with a callback

-

should handle everything with an observer

-

should handle everything with a Subject

-

should handle an error with a callback

-

should handle an error with observer

-

should handle complete with observer

-

should handle next with observer

-

should raise error if next handler raises error

-

should raise error if error handler raises error

-

should raise error if complete handler raises error

-

should allow unsubscribing explicitly and early

-

should not break unsubscription chains when result is unsubscribed explicitly

-

should mirror multiple values and complete

-

should mirror multiple values and terminate with error

-

should return first element by zero-based index

-

should return non-first element by zero-based index

-

should return last element by zero-based index

-

should raise error if source is Empty Observable

-

should propagate error if source is Throw Observable

-

should return Never if source is Never Observable

-

should allow unsubscribing early and explicitly

-

should not break unsubscription chains when result Observable is unsubscribed

-

should throw if index is smaller than zero

-

should raise error if index is out of range but does not have default value

-

should return default value if index is out of range

-

should accept thisArg with scalar observables

-

should accept thisArg with array observables

-

should accept thisArg with ordinary observables

-

should emit true if source is empty

-

should emit false if single source of element does not match with predicate

-

should emit false if none of element does not match with predicate

-

should return false if only some of element matches with predicate

-

should allow unsubscribing early and explicitly

-

should not break unsubscription chains when result Observable is unsubscribed

-

should propagate error if predicate eventually throws

-

should emit true if single source element match with predicate

-

should emit true if Scalar source matches with predicate

-

should emit false if Scalar source does not match with predicate

-

should propagate error if predicate throws on Scalar source

-

should emit true if Array source matches with predicate

-

should emit false if Array source does not match with predicate

-

should propagate error if predicate eventually throws on Array source

-

should emit true if all source element matches with predicate

-

should raise error if source raises error

-

should not completes if source never emits

-

should emit true if source element matches with predicate after subscription

-

should emit false if source element does not match with predicate after subscription

-

should raise error if source raises error after subscription

-

should emit true if source does not emit after subscription

-

should switch to first immediately-scheduled inner Observable

-

should handle throw

-

should handle empty

-

should handle never

-

should handle a hot observable of observables

-

should handle a hot observable of observables, outer is unsubscribed early

-

should not break unsubscription chains when result is unsubscribed explicitly

-

should handle a hot observable of observables, inner never completes

-

should handle a synchronous switch and stay on the first inner observable

-

should handle a hot observable of observables, one inner throws

-

should handle a hot observable of observables, outer throws

-

should handle an empty hot observable

-

should handle a never hot observable

-

should complete not before the outer completes

-

should handle an observable of promises

-

should handle an observable of promises, where one rejects

-

should handle outer throw

-

should handle outer empty

-

should handle outer never

-

should raise error if project throws

-

should raise error if selector throws

-

should switch with a selector function

-

should switch inner cold observables, outer is unsubscribed early

-

should not break unsubscription chains when result is unsubscribed explicitly

-

should switch inner cold observables, inner never completes

-

should handle a synchronous switch an stay on the first inner observable

-

should switch inner cold observables, one inner throws

-

should switch inner hot observables

-

should switch inner empty and empty

-

should switch inner empty and never

-

should never switch inner never

-

should switch inner empty and throw

-

should handle outer error

-

should switch with resultSelector goodness

-

should work with scheduler

-

should map and recursively flatten

-

should map and recursively flatten, and handle event raised error

-

should map and recursively flatten, and propagate error thrown from projection

-

should allow unsubscribing early

-

should not break unsubscription chains when result is unsubscribed explicitly

-

should allow concurrent expansions

-

should allow configuring the concurrency limit parameter to 1

-

should allow configuring the concurrency limit parameter to 2

-

should ignore concurrency limit if it is not passed

-

should map and recursively flatten with scalars

-

should recursively flatten promises

-

should recursively flatten Arrays

-

should recursively flatten lowercase-o observables

-

should work when passing undefined for the optional arguments

-

should filter in only prime numbers

-

should filter with an always-true predicate

-

should filter with an always-false predicate

-

should filter in only prime numbers, source unsubscribes early

-

should filter in only prime numbers, source throws

-

should filter in only prime numbers, but predicate throws

-

should filter in only prime numbers, predicate with index

-

should invoke predicate once for each checked value

-
spec-js/operators/filter-spec.js -

should filter in only prime numbers, predicate with index, source throws

-

should filter in only prime numbers, predicate with index and throws

-

should compose with another filter to allow multiples of six

-

should be able to accept and use a thisArg

-

should be able to use filter and map composed

-

should propagate errors from the source

-

should support Observable.empty

-

should support Observable.never

-

should support Observable.throw

-

should send errors down the error path

-

should not break unsubscription chain when unsubscribed explicitly

-

should support type guards without breaking previous behavior

-

should call finally after complete

-

should call finally after error

-

should call finally upon disposal

-
spec-js/operators/finally-spec.js -

should call two finally instances in succession on a shared Observable

-

should handle empty

-

should handle never

-

should handle throw

-

should handle basic hot observable

-

should handle basic cold observable

-

should handle basic error

-

should handle unsubscription

-

should throw if not provided a function

-

should not emit if source does not emit

-

should return undefined if source is empty to match predicate

-

should return matching element from source emits single element

-

should return matching element from source emits multiple elements

-

should work with a custom thisArg

-

should return undefined if element does not match with predicate

-

should allow unsubscribing early and explicitly

-

should not break unsubscription chains when result is unsubscribed explicitly

-

should raise if source raise error while element does not match with predicate

-

should raise error if predicate throws error

-

should support type guards without breaking previous behavior

-

should not emit if source does not emit

-

should return negative index if source is empty to match predicate

-

should return index of element from source emits single element

-

should return index of matching element from source emits multiple elements

-

should work with a custom thisArg

-

should return negative index if element does not match with predicate

-

should allow unsubscribing early and explicitly

-

should not break unsubscription chains when result is unsubscribed explicitly

-

should raise if source raise error while element does not match with predicate

-

should raise error if predicate throws error

-

should take the first value of an observable with one value

-

should error on empty

-

should return the default value if source observable was empty

-

should only emit one value in recursive cases

-

should propagate error from the source observable

-

should go on forever on never

-

should allow unsubscribing early and explicitly

-

should not break unsubscription chains when result is unsubscribed explicitly

-

should return first value that matches a predicate

-

should return first value that matches a predicate for odd numbers

-

should error when no value matches the predicate

-

should return the default value when no value matches the predicate

-

should propagate error when no value matches the predicate

-

should return first value that matches the index in the predicate

-

should propagate error from predicate

-

should support a result selector argument

-

should raise error when result selector throws

-

should support type guards without breaking previous behavior

-

should group values

-

should group values with an element selector

-

should group values with a duration selector

-

should group values with a subject selector

-

should handle an empty Observable

-

should handle a never Observable

-

should handle a just-throw Observable

-

should handle an Observable with a single value

-

should group values with a keySelector

-

should emit GroupObservables

-

should group values with a keySelector, assert GroupSubject key

-

should group values with a keySelector, but outer throws

-

should group values with a keySelector, inners propagate error from outer

-

should allow outer to be unsubscribed early

-

should unsubscribe from the source when the outer and inner subscriptions are disposed

-

should not break unsubscription chain when unsubscribed explicitly

-

should group values with a keySelector which eventually throws

-
spec-js/operators/groupBy-spec.js -

should allow the outer to be unsubscribed early but inners continue

-

should allow an inner to be unsubscribed early but other inners continue

-

should allow inners to be unsubscribed early at different times

-

should allow subscribing late to an inner Observable, outer completes

-

should allow subscribing late to an inner Observable, outer throws

-

should allow subscribing late to inner, unsubscribe outer early

-

should allow using a keySelector, elementSelector, and durationSelector

-

should allow using a keySelector, elementSelector, and durationSelector that throws

-

should allow using a keySelector and a durationSelector, outer throws

-

should allow using a durationSelector, and outer unsubscribed early

-

should allow using a durationSelector, outer and all inners unsubscribed early

-

should allow using a durationSelector, but keySelector throws

-

should allow using a durationSelector, but elementSelector throws

-

should allow using a durationSelector which eventually throws

-
spec-js/operators/groupBy-spec.js -

should allow inners to be unsubscribed early at different times, with durationSelector

-

should return inners that when subscribed late exhibit hot behavior

-

should return inner group that when subscribed late emits complete()

-

should return inner group that when subscribed late emits error()

-

should return inner that does not throw when faulty outer is unsubscribed early

-

should not break lift() composability

-

should allow unsubscribing early and explicitly

-

should allow unsubscribing early and explicitly

-

should propagate errors from the source

-

should support Observable.empty

-

should support Observable.never

-

should support Observable.throw

-

should return false if source emits element

-

should raise error if source raise error

-

should not completes if source never emits

-

should return true if source is Observable.empty()

-

should allow unsubscribing explicitly and early

-

should not break unsubscription chains when result is unsubscribed explicitly

-

should error on nothing sent but completed

-

should error on empty

-

should go on forever on never

-

should return last element matches with predicate

-

should allow unsubscribing explicitly and early

-

should not break unsubscription chains when result is unsubscribed explicitly

-

should return a default value if no element found

-

should not return default value if an element is found

-

should support a result selector argument

-

should raise error when predicate throws

-

should raise error when result selector throws

-

should support type guards without breaking previous behavior

-

should be able to compose with let

-

should map one value

-

should throw an error if not passed a function

-

should map multiple values

-

should propagate errors from map function

-

should propagate errors from observable that emits only errors

-

should propagate errors from observable that emit values

-

should propagate errors from subscribe

-

should not map an empty observable

-

should allow unsubscribing explicitly and early

-

should map with index

-

should map with index until completed

-

should map with index until an error occurs

-

should map using a custom thisArg

-

should map twice

-

should do multiple maps using a custom thisArg

-

should not break unsubscription chain when unsubscribed explicitly

-

should map one value

-

should allow unsubscribing explicitly and early

-

should propagate errors from observable that emits only errors

-

should propagate errors from observable that emit values

-

should propagate errors from subscribe

-

should not map an empty observable

-

should map twice

-

should not break unsubscription chain when unsubscribed explicitly

-

should materialize a happy stream

-

should materialize a sad stream

-

should allow unsubscribing explicitly and early

-

should not break unsubscription chains when result is unsubscribed explicitly

-

should materialize stream does not completes

-

should materialize stream never completes

-

should materialize stream does not emit

-

should materialize empty stream

-

should materialize stream throws

-

should be never when source is never

-

should be zero when source is empty

-

should be never when source doesn't complete

-

should be completes when source doesn't have values

-

should max the unique value of an observable

-

should max the values of an ongoing hot observable

-

should allow unsubscribing explicitly and early

-

should not break unsubscription chains when result is unsubscribed explicitly

-

should max a range() source observable

-

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

-

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

-

should work with error

-

should work with throw

-

should handle a constant predicate on an empty hot observable

-

should handle a constant predicate on an never hot observable

-

should handle a constant predicate on a simple hot observable

-

should handle a reverse predicate on observable with many values

-

should handle a predicate for string on observable with many values

-

should handle a constant predicate on observable that throws

-

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

-

should merge a source with a second

-

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

-

should merge cold and cold

-

should merge hot and hot

-

should merge hot and cold

-

should merge parallel emissions

-

should allow unsubscribing explicitly and early

-

should not break unsubscription chains when result is unsubscribed explicitly

-

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 two observables

-

should merge two immediately-scheduled observables

-

should merge all observables in an observable

-

should throw if any child observable throws

-

should handle merging a hot observable of observables

-

should merge one cold Observable at a time with parameter concurrency=1

-

should merge two cold Observables at a time with parameter concurrency=2

-

should merge one hot Observable at a time with parameter concurrency=1

-

should merge two hot Observables at a time with parameter concurrency=2

-

should handle merging a hot observable of observables, outer unsubscribed early

-

should not break unsubscription chains when result is unsubscribed explicitly

-

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 never and throw

-

should merge empty and eventual error

-

should merge never and eventual error

-

should take an empty source and return empty too

-

should take a never source and return never too

-

should take a throw source and return throw too

-

should handle 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 merge all promises in an observable

-

should raise error when promise rejects

-

should mergeMap many regular interval inners

-

should map values to constant resolved promises and merge

-

should map values to constant rejected promises and merge

-

should map values to resolved promises and merge

-

should map values to rejected promises and merge

-

should mergeMap values to resolved promises with resultSelector

-

should mergeMap values to rejected promises with resultSelector

-

should mergeMap many outer values to many inner values

-

should mergeMap many outer to many inner, complete late

-

should mergeMap many outer to many inner, outer never completes

-

should not break unsubscription chains when result is unsubscribed explicitly

-

should mergeMap many outer to many inner, inner never completes

-

should mergeMap many outer to many inner, and inner throws

-

should mergeMap many outer to many inner, and outer throws

-

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

-

should mergeMap to many cold Observable, with parameter concurrency=1

-

should mergeMap to many cold Observable, with parameter concurrency=2

-

should mergeMap to many hot Observable, with parameter concurrency=1

-

should mergeMap to many hot Observable, with parameter concurrency=2

-

should mergeMap to many cold Observable, with parameter concurrency=1, without resultSelector

-

should mergeMap to many cold Observable, with parameter concurrency=2, without resultSelector

-

should mergeMap to many hot Observable, with parameter concurrency=1, without resultSelector

-

should mergeMap to many hot Observable, with parameter concurrency=2, without resultSelector

-

should mergeMap many complex, where all inners are finite

-

should mergeMap many complex, all inners finite except one

-

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

-

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

-

should mergeMap many complex, all inners complete except one throws

-

should mergeMap many complex, all inners finite, outer is unsubscribed

-

should mergeMap many complex, all inners finite, project throws

-

should mergeMap many outer to an array for each value

-

should mergeMap many outer to inner arrays, using resultSelector

-

should mergeMap many outer to inner arrays, and outer throws

-

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

-

should mergeMap many outer to inner arrays, outer gets unsubscribed

-

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

-

should mergeMap many outer to inner arrays, project throws

-

should mergeMap many outer to inner arrays, resultSelector throws

-

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

-

should map and flatten

-

should map and flatten an Array

-

should support type signatures

-

should mergeMapTo many regular interval inners

-

should map values to constant resolved promises and merge

-

should map values to constant rejected promises and merge

-

should mergeMapTo values to resolved promises with resultSelector

-

should mergeMapTo values to rejected promises with resultSelector

-

should mergeMapTo many outer values to many inner values

-

should mergeMapTo many outer to many inner, complete late

-

should mergeMapTo many outer to many inner, outer never completes

-

should not break unsubscription chains when result is unsubscribed explicitly

-

should mergeMapTo many outer to many inner, inner never completes

-

should mergeMapTo many outer to many inner, and inner throws

-

should mergeMapTo many outer to many inner, and outer throws

-

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

-

should mergeMapTo many cold Observable, with parameter concurrency=1

-

should mergeMap to many cold Observable, with parameter concurrency=2

-

should mergeMapTo many cold Observable, with parameter concurrency=1, without resultSelector

-

should mergeMap to many cold Observable, with parameter concurrency=2, without resultSelector

-

should mergeMapTo many outer to arrays

-

should mergeMapTo many outer to inner arrays, using resultSelector

-

should mergeMapTo many outer to inner arrays, and outer throws

-

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

-

should mergeMapTo many outer to inner arrays, outer gets unsubscribed

-

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

-

should mergeMapTo many outer to inner arrays, resultSelector throws

-

should map and flatten

-

should map and flatten an Array

-

should support type signatures

-

should mergeScan things

-

should handle errors

-

should mergeScan values and be able to asynchronously project them

-

should not stop ongoing async projections when source completes

-

should interrupt ongoing async projections when result is unsubscribed early

-

should not break unsubscription chains when result is unsubscribed explicitly

-

should handle errors in the projection function

-

should propagate errors from the projected Observable

-

should handle an empty projected Observable

-

should handle a never projected Observable

-

handle empty

-

handle never

-

handle throw

-

should mergeScan unsubscription

-

should mergescan projects cold Observable with single concurrency

-

should emit accumulator if inner completes without value

-

should emit accumulator if inner completes without value after source completes

-

should mergescan projects hot Observable with single concurrency

-

should mergescan projects cold Observable with dual concurrency

-

should mergescan projects hot Observable with dual concurrency

-

should be never when source is never

-

should be zero when source is empty

-

should be never when source doesn't complete

-

should be completes when source doesn't have values

-

should min the unique value of an observable

-

should min the values of an ongoing hot observable

-

should min a range() source observable

-

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

-

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

-

should work with error

-

should work with throw

-

should handle a constant predicate on an empty hot observable

-

should handle a constant predicate on an never hot observable

-

should handle a constant predicate on a simple hot observable

-

should allow unsubscribing explicitly and early

-

should not break unsubscription chains when result is unsubscribed explicitly

-

should handle a reverse predicate on observable with many values

-

should handle a predicate for string on observable with many values

-

should handle a constant predicate on observable that throws

-

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

-

should accept Subjects

-

should accept Subject factory functions

-

should accept a multicast selector and connect to a hot source for each subscriber

-

should accept a multicast selector and connect to a cold source for each subscriber

-

should accept a multicast selector and respect the subject's messaging semantics

-

should do nothing if connect is not called, despite subscriptions

-

should multicast the same values to multiple observers

-

should multicast an error from the source to multiple observers

-
spec-js/operators/multicast-spec.js -

should not break unsubscription chains when result is unsubscribed explicitly

-

should multicast an empty source

-

should multicast a never source

-

should multicast a throw source

-

should multicast one observable to multiple observers

-

should remove all subscribers from the subject when disconnected

-

should connect when first subscriber subscribes

-

should disconnect when last subscriber unsubscribes

-

should be retryable when cold source is synchronous

-

should be retryable with ReplaySubject and cold source is synchronous

-

should be repeatable when cold source is synchronous

-

should be repeatable with ReplaySubject and cold source is synchronous

-

should be retryable

-

should be retryable using a ReplaySubject

-

should be repeatable

-

should be repeatable using a ReplaySubject

-

should allow you to reconnect by subscribing again

-
spec-js/operators/multicast-spec.js -
spec-js/operators/multicast-spec.js -

should observe after specified delay

-

should observe when source raises error

-

should observe when source is empty

-

should observe when source does not complete

-

should allow unsubscribing early and explicitly

-

should not break unsubscription chains when the result is unsubscribed explicitly

-

should clean up subscriptions created by async scheduling (prevent memory leaks #2244)

-

should continue with hot observables

-

should continue with array of multiple observables throw error

-

should continue with multiple observables throw error

-

should continue with multiple observables does not throw error

-

should continue after empty observable

-

should not complete with observble does not ends

-

should not continue with observble does not ends

-

should complete observable with next observable throws

-

should work with promise

-

should pairwise things

-

should not emit on single-element streams

-

should handle mid-stream throw

-

should handle empty

-

should handle never

-

should handle throw

-

should partition an observable into two using a predicate

-

should partition an observable into two using a predicate and thisArg

-

should pass errors to both returned observables

-

should pass errors to both returned observables if source throws

-

should pass errors to both returned observables if predicate throws

-

should partition empty observable if source does not emits

-

should partition empty observable if source is empty

-

should partition if source emits single elements

-

should partition if predicate matches all of source elements

-

should partition if predicate does not match all of source elements

-

should partition to infinite observable if source does not completes

-

should partition to infinite observable if source never completes

-

should partition into two observable with early unsubscription

-

should not break unsubscription chains when result is unsubscribed explicitly

-

should throw without predicate

-

should accept thisArg

-

should work for one object

-

should work for multiple objects

-

should work with deep nested properties

-

should work with edge cases of deep nested properties

-

should throw an error if not property is passed

-

should propagate errors from observable that emits only errors

-

should propagate errors from observable that emit values

-

should not pluck an empty observable

-

should allow unsubscribing explicitly and early

-

should pluck twice

-

should not break unsubscription chain when unsubscribed explicitly

-

should return a ConnectableObservable-ish

-

should do nothing if connect is not called, despite subscriptions

-

should multicast the same values to multiple observers

-

should accept selectors

-

should multicast an error from the source to multiple observers

-
spec-js/operators/publish-spec.js -

should not break unsubscription chains when result is unsubscribed explicitly

-

should emit completed when subscribed after completed

-

should multicast an empty source

-

should multicast a never source

-

should multicast a throw source

-

should multicast one observable to multiple observers

-

should connect when first subscriber subscribes

-

should disconnect when last subscriber unsubscribes

-

should NOT be retryable

-

should NOT be repeatable

-

should return a ConnectableObservable-ish

-

should only emit default value if connect is not called, despite subscriptions

-

should multicast the same values to multiple observers

-

should multicast an error from the source to multiple observers

-
spec-js/operators/publishBehavior-spec.js -

should not break unsubscription chains when result is unsubscribed explicitly

-

should emit completed when subscribed after completed

-

should multicast an empty source

-

should multicast a never source

-

should multicast a throw source

-

should multicast one observable to multiple observers

-

should follow the RxJS 4 behavior and emit nothing to observer after completed

-

should connect when first subscriber subscribes

-

should disconnect when last subscriber unsubscribes

-

should NOT be retryable

-

should NOT be repeatable

-

should return a ConnectableObservable-ish

-

should do nothing if connect is not called, despite subscriptions

-

should multicast the same values to multiple observers

-

should multicast an error from the source to multiple observers

-
spec-js/operators/publishLast-spec.js -

should not break unsubscription chains when result is unsubscribed explicitly

-

should multicast an empty source

-

should multicast a never source

-

should multicast a throw source

-

should multicast one observable to multiple observers

-

should connect when first subscriber subscribes

-

should disconnect when last subscriber unsubscribes

-

should NOT be retryable

-

should return a ConnectableObservable-ish

-

should do nothing if connect is not called, despite subscriptions

-

should multicast the same values to multiple observers, bufferSize=1

-

should multicast the same values to multiple observers, bufferSize=2

-

should multicast an error from the source to multiple observers

-
spec-js/operators/publishReplay-spec.js -

should not break unsubscription chains when result is unsubscribed explicitly

-

should multicast one observable to multiple observers

-

should replay as many events as specified by the bufferSize

-
spec-js/operators/publishReplay-spec.js -

should emit replayed values plus completed when subscribed after completed

-

should multicast an empty source

-

should multicast a never source

-

should multicast a throw source

-

should connect when first subscriber subscribes

-

should disconnect when last subscriber unsubscribes

-

should NOT be retryable

-

should NOT be repeatable

-

should race cold and cold

-

should race cold and cold and accept an Array of Observable argument

-

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

-

should allow observable emits immediately

-

should ignore latter observables if a former one emits immediately

-

should unsubscribe former observables if a latter one emits immediately

-

should unsubscribe from immediately emitting observable on unsubscription

-

should reduce with seed

-

should reduce with a seed of undefined

-

should reduce without a seed

-

should reduce with index without seed

-

should reduce with index with seed

-

should reduce with seed if source is empty

-

should raise error if reduce function throws without seed

-

should allow unsubscribing explicitly and early

-

should not break unsubscription chains when result is unsubscribed explicitly

-

should raise error if source emits and raises error with seed

-

should raise error if source raises error with seed

-

should raise error if reduce function throws with seed

-

should not complete with seed if source emits but does not completes

-

should not complete with seed if source never completes

-

should not complete without seed if source emits but does not completes

-

should not complete without seed if source never completes

-

should reduce if source does not emit without seed

-

should raise error if source emits and raises error without seed

-

should raise error if source raises error without seed

-

should accept array typed reducers

-

should accept T typed reducers

-

should accept R typed reducers

-

should count references

-

should unsub from the source when all other subscriptions are unsubbed

-
spec-js/operators/refCount-spec.js -
spec-js/operators/refCount-spec.js -

should resubscribe multiple times

-

should complete without emit when count is zero

-

should emit source once when count is one

-

should repeat until gets unsubscribed

-

should be able to repeat indefinitely until unsubscribed

-

should not break unsubscription chain when unsubscribed explicitly

-

should consider negative count as repeat indefinitely

-

should not complete when source never completes

-

should not complete when source does not completes

-

should complete immediately when source does not complete without emit but count is zero

-

should complete immediately when source does not complete but count is zero

-

should emit source once and does not complete when source emits but does not complete

-

should complete when source is empty

-

should complete when source does not emit

-

should complete immediately when source does not emit but count is zero

-

should raise error when source raises error

-

should raises error if source throws

-

should raises error if source throws when repeating infinitely

-

should terminate repeat and throw if source subscription to _next throws

-

should terminate repeat and throw if source subscription to _complete throws

-

should terminate repeat and throw if source subscription to _next throws when repeating infinitely

-

should terminate repeat and throw if source subscription to _complete throws when repeating infinitely

-

should raise error after first emit succeed

-

should repeat a synchronous source (multicasted and refCounted) multiple times

-

should handle a source with eventual complete using a hot notifier that raises error

-

should retry when notified via returned notifier on complete

-

should retry when notified and complete on returned completion

-

should apply an empty notifier on an empty source

-

should apply a never notifier on an empty source

-

should apply an empty notifier on a never source

-

should apply a never notifier on a never source

-

should return an empty observable given a just-throw source and empty notifier

-

should return a error observable given a just-throw source and never notifier

-

should mirror a basic cold source with complete, given a never notifier

-

should mirror a basic cold source with no termination, given a never notifier

-

should mirror a basic hot source with complete, given a never notifier

-

should tear down resources when result is unsubscribed early

-

should not break unsubscription chains when unsubscribed explicitly

-
spec-js/operators/repeatWhen-spec.js -
spec-js/operators/repeatWhen-spec.js -

should retry a number of times, without error, then complete

-

should retry a number of times, then call error handler

-

should retry until successful completion

-

should handle an empty source

-

should handle a never source

-

should return a never observable given an async just-throw source and no count

-

should handle a basic source that emits next then completes

-

should handle a basic source that emits next but does not complete

-

should handle a basic source that emits next then errors, no count

-
spec-js/operators/retry-spec.js -

should not break unsubscription chain when unsubscribed explicitly

-

should retry a synchronous source (multicasted and refCounted) multiple times

-

should handle a source with eventual error using a hot notifier that raises error

-

should retry when notified via returned notifier on thrown error

-

should retry when notified and complete on returned completion

-

should apply an empty notifier on an empty source

-

should apply a never notifier on an empty source

-

should apply an empty notifier on a never source

-

should apply a never notifier on a never source

-

should return an empty observable given a just-throw source and empty notifier

-

should return a never observable given a just-throw source and never notifier

-

should hide errors using a never notifier on a source with eventual error

-

should propagate error thrown from notifierSelector function

-
spec-js/operators/retryWhen-spec.js -

should mirror a basic cold source with complete, given a never notifier

-

should mirror a basic cold source with no termination, given a never notifier

-

should mirror a basic hot source with complete, given a never notifier

-

should handle a hot source that raises error but eventually completes

-

should tear down resources when result is unsubscribed early

-

should not break unsubscription chains when unsubscribed explicitly

-
spec-js/operators/retryWhen-spec.js -
spec-js/operators/retryWhen-spec.js -

should sample nothing if source has not nexted at all

-

should behave properly when notified by the same observable as the source (issue #2075)

-

should sample nothing if source has nexted after all notifications, but notifier does not complete

-

should sample when the notifier completes

-

should not complete when the notifier completes, nor should it emit

-

should complete only when the source completes, if notifier completes early

-

should allow unsubscribing explicitly and early

-

should not break unsubscription chains when result is unsubscribed explicitly

-

should only sample when a new value arrives, even if it is the same value

-

should raise error if source raises error

-

should completes if source does not emits

-

should raise error if source throws immediately

-

should raise error if notification raises error

-

should not completes if source does not complete

-

should sample only until source completes

-

should complete sampling if sample observable completes

-

should sample nothing if new value has not arrived

-

should sample if new value has arrived, even if it is the same value

-

should sample nothing if source has not nexted by time of sample

-

should raise error if source raises error

-

should allow unsubscribing explicitly and early

-

should not break unsubscription chains when result is unsubscribed explicitly

-

should completes if source does not emits

-

should raise error if source throws immediately

-

should not completes if source does not complete

-

should scan things

-

should scan with a seed of undefined

-

should scan without seed

-

should handle errors

-

should handle errors in the projection function

-

handle empty

-

handle never

-

handle throw

-

should allow unsubscribing explicitly and early

-

should not break unsubscription chains when result is unsubscribed explicitly

-

should pass current index to accumulator

-

should accept array typed reducers

-

should accept T typed reducers

-

should accept R typed reducers

-

should return false for two sync observables that are unequal in length

-

should return true for two sync observables that match

-

should return true for two observables that match when the last one emits and completes in the same frame

-

should return true for two observables that match when the last one emits and completes in the same frame

-

should error with an errored source

-

should error with an errored compareTo

-

should error if the source is a throw

-

should never return if source is a never

-

should never return if compareTo is a never

-

should return false if source is empty and compareTo is not

-

should return false if compareTo is empty and source is not

-

should return never if compareTo is empty and source is never

-

should return never if source is empty and compareTo is never

-

should error if the comparor errors

-

should use the provided comparor

-

should return false for two unequal sequences, compareTo finishing last

-

should return false for two unequal sequences, early wrong value from source

-

should return false when the source emits an extra value after the compareTo completes

-

should return false when the compareTo emits an extra value after the source completes

-

should return true for two empty observables

-

should return false for an empty observable and an observable that emits

-

should return compare hot and cold observables

-

should share a single subscription

-

should not change the output of the observable when error

-

should not change the output of the observable when successful with cold observable

-

should not change the output of the observable when error with cold observable

-

should retry just fine

-

should share the same values to multiple observers

-

should share an error from the source to multiple observers

-
spec-js/operators/share-spec.js -

should share an empty source

-

should share a never source

-

should share a throw source

-

should connect when first subscriber subscribes

-

should disconnect when last subscriber unsubscribes

-

should not break unsubscription chain when last subscriber unsubscribes

-

should be retryable when cold source is synchronous

-

should be repeatable when cold source is synchronous

-

should be retryable

-

should be repeatable

-

should not change the output of the observable when never

-

should not change the output of the observable when empty

-

should raise error from empty predicate if observable does not emit

-

should return only element from empty predicate if observable emits only once

-

should allow unsubscribing explicitly and early

-

should not break unsubscription chains when result is unsubscribed explicitly

-

should raise error from empty predicate if observable emits error

-

should raise error from predicate if observable emits error

-

should raise error if predicate throws error

-

should return element from predicate if observable have single matching element

-

should raise error from predicate if observable have multiple matching element

-

should raise error from predicate if observable does not emit

-

should return undefined from predicate if observable does not contain matching element

-

should call predicate with indices starting at 0

-

should skip all values without error if total is more than actual number of values

-

should skip all values without error if total is same as actual number of values

-

should not skip if count is zero

-

should allow unsubscribing explicitly and early

-

should not break unsubscription chains when result is unsubscribed explicitly

-

should raise error if skip count is more than actual number of emits and source raises error

-

should raise error if skip count is same as emits of source and source raises error

-

should skip values before a total and raises error if source raises error

-

should complete regardless of skip count if source is empty

-

should not complete if source never completes without emit

-

should skip values before total and never completes if source emits and does not complete

-

should skip all values and never completes if total is more than numbers of value and source does not complete

-

should skip all values and never completes if total is same asnumbers of value and source does not complete

-

should raise error if source throws

-

should emit element only after another observable emits

-

should skip value and raises error until another observable raises error

-

should skip all element when another observable does not emit and completes early

-

should allow unsubscribing explicitly and early

-

should not break unsubscription chains when result is unsubscribed explicitly

-

should skip all element when another observable is empty

-

should keep subscription to source, to wait for its eventual complete

-

should not complete if source observable does not complete

-

should not complete if source observable never completes

-

should raise error if source does not completes when another observable raises error

-

should raise error if source never completes when another observable raises error

-

should skip all element and does not complete when another observable never completes

-

should skip all element and does not complete when another observable does not completes

-

should skip all element and does not complete when another observable completes after source

-

should not completes if source does not completes when another observable does not emit

-

should not completes if source and another observable both does not complete

-

should skip all element when another observable unsubscribed early before emit

-

should skip all elements with a true predicate

-

should skip all elements with a truthy predicate

-

should not skip any element with a false predicate

-

should not skip any elements with a falsy predicate

-

should skip elements on hot source

-

should be possible to skip using the element's index

-

should skip using index with source unsubscribes early

-

should not break unsubscription chains when result is unsubscribed explicitly

-

should skip using value with source throws

-

should invoke predicate while its false and never again

-

should handle predicate that throws

-

should handle Observable.empty

-

should handle Observable.never

-

should handle Observable.throw

-

should start an observable with given value

-

should start with given value and does not completes if source does not completes

-

should start with given value and does not completes if source never emits

-

should start with given value and completes if source does not emits

-

should start with given value and complete immediately if source is empty

-

should start with given value and source both if source emits single value

-

should start with given values when given value is more than one

-

should start with given value and raises error if source raises error

-

should start with given value and raises error immediately if source throws error

-

should allow unsubscribing explicitly and early

-

should not break unsubscription chains when result is unsubscribed explicitly

-

should start with empty if given value is not specified

-

should accept scheduler as last argument with single value

-

should accept scheduler as last argument with multiple value

-

should start subscribe after specified delay

-

should subscribe when source raises error

-

should subscribe when source is empty

-

should subscribe when source does not complete

-

should allow unsubscribing early and explicitly

-

should not break unsubscription chains when the result is unsubscribed explicitly

-

should switch to each immediately-scheduled inner Observable

-

should unsub inner observables

-

should switch to each inner Observable

-

should handle a hot observable of observables

-

should handle a hot observable of observables, outer is unsubscribed early

-

should not break unsubscription chains when result is unsubscribed explicitly

-

should handle a hot observable of observables, inner never completes

-

should handle a synchronous switch to the second inner observable

-

should handle a hot observable of observables, one inner throws

-

should handle a hot observable of observables, outer throws

-

should handle an empty hot observable

-

should handle a never hot observable

-

should complete not before the outer completes

-

should handle an observable of promises

-

should handle an observable of promises, where last rejects

-

should handle an observable with Arrays in it

-

should not leak when child completes before each switch (prevent memory leaks #2355)

-

should not leak if we switch before child completes (prevent memory leaks #2355)

-

should switch with a selector function

-

should unsub inner observables

-

should switch inner cold observables

-

should raise error when projection throws

-

should raise error when resultSelector throws

-

should switch inner cold observables, outer is unsubscribed early

-

should not break unsubscription chains when result is unsubscribed explicitly

-

should switch inner cold observables, inner never completes

-

should handle a synchronous switch to the second inner observable

-

should switch inner cold observables, one inner throws

-

should switch inner hot observables

-

should switch inner empty and empty

-

should switch inner empty and never

-

should switch inner never and empty

-

should switch inner never and throw

-

should switch inner empty and throw

-

should handle outer empty

-

should handle outer never

-

should handle outer throw

-

should handle outer error

-

should switch with resultSelector goodness

-

should switch a synchronous many outer to a synchronous many inner

-

should unsub inner observables

-

should switch to an inner cold observable

-

should switch to an inner cold observable, outer eventually throws

-

should switch to an inner cold observable, outer is unsubscribed early

-

should not break unsubscription chains when result is unsubscribed explicitly

-

should switch to an inner cold observable, inner never completes

-

should handle a synchronous switch to the inner observable

-

should switch to an inner cold observable, inner raises an error

-

should switch an inner hot observable

-

should switch to an inner empty

-

should switch to an inner never

-

should switch to an inner that just raises an error

-

should handle an empty outer

-

should handle a never outer

-

should handle an outer that just raises and error

-

should switch with resultSelector goodness

-

should raise error when resultSelector throws

-

should work with empty

-

should go on forever on never

-

should be empty on take(0)

-

should take one value of an observable with one value

-

should take one values of an observable with many values

-

should error on empty

-

should propagate error from the source observable

-

should propagate error from an observable with values

-

should allow unsubscribing explicitly and early

-

should work with throw

-

should throw if total is less than zero

-

should not break unsubscription chain when unsubscribed explicitly

-

should unsubscribe from the source when it reaches the limit

-

should complete when the source is reentrant

-

should take last three values

-

should take all element when try to take larger then source

-

should take all element when try to take exact

-

should not take any values

-

should work with empty

-

should go on forever on never

-

should be empty on takeLast(0)

-

should take one value from an observable with one value

-

should take one value from an observable with many values

-

should error on empty

-

should propagate error from the source observable

-

should propagate error from an observable with values

-

should allow unsubscribing explicitly and early

-

should work with throw

-

should throw if total is less than zero

-

should not break unsubscription chain when unsubscribed explicitly

-

should take values and raises error when notifier raises error

-

should take all values when notifier is empty

-

should take all values when notifier does not complete

-

should allow unsubscribing explicitly and early

-

should complete when notifier emits if source observable does not complete

-

should raise error when notifier raises error if source observable does not complete

-

should not complete when notifier is empty if source observable does not complete

-

should not complete when source and notifier do not complete

-

should complete when notifier emits before source observable emits

-

should raise error if source raises error before notifier emits

-

should raise error immediately if source throws

-

should dispose source observable if notifier emits before source emits

-

should dispose notifier if source observable completes

-

should not break unsubscription chain when unsubscribed explicitly

-

should take all elements with predicate returns true

-

should take all elements with truthy predicate

-

should skip all elements with predicate returns false

-

should skip all elements with falsy predicate

-

should take all elements until predicate return false

-

should take elements with predicate when source does not complete

-

should not complete when source never completes

-

should complete when source does not emit

-

should complete when source is empty

-

should pass element index to predicate

-

should raise error when source raises error

-

should raise error when source throws

-

should invoke predicate until return false

-

should raise error if predicate throws

-

should take elements until unsubscribed

-

should not break unsubscription chain when unsubscribed explicitly

-

should simply mirror the source if values are not emitted often enough

-

should throttle 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 take only the first value emitted 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 throttle 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 throttle by promise resolves

-

should raise error when promise rejects

-

should throttle events by 50 time units

-

should throttle events multiple times

-

should simply mirror 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 throttle and does not complete when source does not completes

-

should not break unsubscription chains when result is unsubscribed explicitly

-

should throttle values until source raises error

-

should record interval if source emit elements

-

should completes without record interval if source does not emits

-

should complete immediately if source is empty

-

should record interval then does not completes if source emits but not completes

-

should allow unsubscribing explicitly and early

-

should not break unsubscription chains when result is unsubscribed explicitly

-

should not completes if source never completes

-

raise error if source raises error

-

should record interval then raise error if source raises error after emit

-

should raise error if source immediately throws

-

should emit and error of an instanceof TimeoutError on timeout

-

should not timeout if source completes within absolute timeout period

-

should not timeout if source emits within timeout period

-

should allow unsubscribing explicitly and early

-

should not break unsubscription chains when result is unsubscribed explicitly

-
spec-js/operators/timeout-spec.js -

should timeout at a specified Date

-

should timeout specified Date with default error while source emits

-

should timeout at a specified date then subscribe to the passed observable

-
spec-js/operators/timeoutWith-spec.js -

should allow unsubscribing explicitly and early

-

should not break unsubscription chain when unsubscribed explicitly

-

should not subscribe to withObservable after explicit unsubscription

-
spec-js/operators/timeoutWith-spec.js -
spec-js/operators/timeoutWith-spec.js -
spec-js/operators/timeoutWith-spec.js -
spec-js/operators/timeoutWith-spec.js -

should not timeout if source completes within timeout period

-

should not timeout if source raises error within timeout period

-

should not timeout if source emits within timeout period

-

should timeout after specified Date then subscribe to the passed observable

-

should not timeout if source completes within specified Date

-

should not timeout if source raises error within specified Date

-
spec-js/operators/timeoutWith-spec.js -

should record stamp if source emit elements

-

should completes without record stamp if source does not emits

-

should complete immediately if source is empty

-

should record stamp then does not completes if source emits but not completes

-

should allow unsubscribing explicitly and early

-

should not break unsubscription chains when result is unsubscribed explicitly

-

should not completes if source never completes

-

raise error if source raises error

-

should record stamp then raise error if source raises error after emit

-

should raise error if source immediately throws

-

should be never when source is never

-

should be never when source is empty

-

should be never when source doesn't complete

-

should reduce observable without values into an array of length zero

-

should reduce the a single value of an observable into an array

-

should allow unsubscribing explicitly and early

-

should not break unsubscription chains when result is unsubscribed explicitly

-

should work with error

-

should work with throw

-

should convert an Observable to a promise of its last value

-

should handle errors properly

-

should allow for global config via Rx.config.Promise

-

should return a single empty window if source is empty and closings are basic

-

should return a single empty window if source is empty and closing is empty

-

should return a single empty window if source is sync empty and closing is sync empty

-

should split a Just source into a single window identical to source, using a Never closing

-

should return a single Never window if source is Never

-

should be able to split a never Observable into timely empty windows

-

should emit an error-only window if outer is a simple throw-Observable

-

should handle basic case with window closings

-

should handle basic case with window closings, but outer throws

-

should stop emitting windows when outer is unsubscribed early

-

should not break unsubscription chains when result is unsubscribed explicitly

-

should make outer emit error when closing throws

-

should complete the resulting Observable when window closings completes

-

should emit windows with count 2 and skip 1

-

should emit windows with count 2, and skip unspecified

-

should return empty if source is empty

-

should return Never if source if Never

-

should propagate error from a just-throw source

-

should raise error if source raises error

-

should dispose of inner windows once outer is unsubscribed early

-

should not break unsubscription chains when result is unsubscribed explicitly

-

should close windows after max count is reached

-
spec-js/operators/windowTime-spec.js -

should emit windows given windowTimeSpan

-

should emit windows given windowTimeSpan and windowCreationInterval

-

should return a single empty window if source is empty

-

should split a Just source into a single window identical to source

-

should be able to split a never Observable into timely empty windows

-

should emit an error-only window if outer is a simple throw-Observable

-

should handle source Observable which eventually emits an error

-
spec-js/operators/windowTime-spec.js -

should not break unsubscription chains when result is unsubscribed explicitly

-
spec-js/operators/windowToggle-spec.js -

should emit windows using constying cold closings

-

should emit windows using constying hot closings

-

should emit windows using constying empty delayed closings

-

should emit windows using constying cold closings, outer unsubscribed early

-

should not break unsubscription chains when result is unsubscribed explicitly

-

should dispose window Subjects if the outer is unsubscribed early

-

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 handle empty closing observable

-

should emit windows using constying cold closings

-

should emit windows using constying hot closings

-

should emit windows using constying empty delayed closings

-

should emit windows using constying cold closings, outer unsubscribed early

-

should not break unsubscription chain when unsubscribed explicitly

-

should propagate error thrown from closingSelector

-

should propagate error emitted from a closing

-

should propagate error emitted late from a closing

-

should propagate errors emitted from the source

-

should handle empty source

-

should handle a never source

-

should handle throw

-

should handle a never closing Observable

-

should handle a throw closing Observable

-

should merge the value with the latest values from the other observables into arrays

-
spec-js/operators/withLatestFrom-spec.js -

should allow unsubscribing early and explicitly

-

should not break unsubscription chains when result is unsubscribed explicitly

-

should handle empty

-

should handle never

-

should handle throw

-

should handle error

-

should handle error with project argument

-

should handle merging with empty

-

should handle merging with never

-

should handle promises

-

should handle arrays

-

should handle lowercase-o observables

-

should combine a source with a second

-

should zip the provided observables

-

should end once one observable completes and its buffer is empty

-
spec-js/operators/zip-spec.js -

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 not break unsubscription chain when unsubscribed explicitly

-

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 combine two observables

-

should take all observables from the source and zip them

-

should end once one observable completes and its buffer is empty

-
spec-js/operators/zipAll-spec.js -

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 zip until one child terminates

-

should handle a hot observable of observables

-

should handle 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 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 combine a source with a second

-

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 two immediately-scheduled observables

-

should combine a source with an immediately-scheduled source

-

should not break unsubscription chain when unsubscribed explicitly

-

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 contain exports from commonjs modules

-

should exist

-

should act like the async scheduler if delay > 0

-

should schedule an action to happen later

-

should execute recursively scheduled actions in separate asynchronous contexts

-

should cancel the animation frame if all scheduled actions unsubscribe before it executes

-

should execute the rest of the scheduled actions if the first action is canceled

-

should exist

-

should act like the async scheduler if delay > 0

-

should schedule an action to happen later

-

should execute recursively scheduled actions in separate asynchronous contexts

-

should cancel the setImmediate if all scheduled actions unsubscribe before it executes

-

should execute the rest of the scheduled actions if the first action is canceled

-

should act like the async scheduler if delay > 0

-

should switch from synchronous to asynchronous at will

-

should unsubscribe the rest of the scheduled actions if an action throws an error

-

should exist

-

should parse a marble string into a series of notifications and types

-

should parse a marble string, allowing spaces too

-

should parse a marble string with a subscription point

-

should parse a marble string with an error

-

should default in the letter for the value if no value hash was passed

-

should handle grouped values

-

should parse a subscription marble string into a subscriptionLog

-

should parse a subscription marble string with an unsubscription

-

should parse a subscription marble string with a synchronous unsubscription

-

should parse a simple time marble string to a number

-

should throw if not given good marble input

-

should create a cold observable

-

should create a cold observable

-

should exist

-

should exist

-

should create a cold observable

-

should exist

-

should create a hot observable

-

should exist

-

should parse a simple time marble string to a number

-

should exist

-

should return an object with a toBe function

-

should append to flushTests array

-

should handle empty

-

should handle never

-

should accept an unsubscription marble diagram

-

should exist

-

should return an object with a toBe function

-

should append to flushTests array

-

should assert subscriptions of a cold observable

-

should be awesome

-

should support testing metastreams

-

should exist

-

should schedule things in order when flushed if each this is scheduled synchrously

-

should schedule things in order when flushed if each this is scheduled at random

-

should schedule things in order when there are negative delays

-

should support recursive scheduling

-

should emit the last value when complete

-

should emit the last value when subscribing after complete

-

should keep emitting the last value to subsequent subscriptions

-

should not emit values after complete

-

should not allow change value after complete

-

should not emit values if unsubscribed before complete

-

should just complete if no value has been nexted into it

-

should keep emitting complete to subsequent subscriptions

-

should only error if an error is passed into it

-

should keep emitting error to subsequent subscriptions

-

should not allow send complete after error

-

should extend Subject

-

should throw if it has received an error and getValue() is called

-
spec-js/subjects/BehaviorSubject-spec.js -

should have a getValue() method to retrieve the current value

-

should not allow you to set value directly

-

should still allow you to retrieve the value from the value property

-

should start with an initialization value

-

should pump values to multiple subscribers

-

should not pass values nexted after a complete

-

should clean out unsubscribed subscribers

-

should replay the previous value when subscribed

-

should emit complete when subscribed after completed

-

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

-

should extend Subject

-

should add the observer before running subscription code

-

should replay values upon subscription

-

should replay values and complete

-

should replay values and error

-

should only replay values within its buffer size

-

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

-

should replay 2 previous values when subscribed

-

should replay 2 last values for when subscribed after completed

-
spec-js/subjects/ReplaySubject-spec.js -

should replay previous values since 40 time units ago when subscribed

-

should replay last values since 40 time units ago when subscribed

-

should exist

-

should return Symbol.iterator

-

should use Symbol to create an return a symbol and polyfill Symbol.iterator

-

should return "$$iterator"

-

should return the key that matches the "entries" key on Map.prototype, but not return "size"

-

should return "@@iterator"

-

should return "@@iterator"

-

should return "@@iterator"

-

should exist in the proper form when Symbol does not exist

-

should exist in the proper form

-

should exist in the proper form

-

should exist

-

should accept string as keys

-

should allow setting keys twice

-

should have a delete method that removes keys

-

should clear all

-

should exist

-

should iterate over keys and values

-

should have setImmediate and clearImmediate methods

-

should use the setImmediate and clearImmediate methods from root

-

should create the proper flavor of setImmediate using process.nextTick

-

should create the proper flavor of setImmediate using postMessage

-

should create the proper flavor of setImmediate that uses message channels

-

should create the proper flavor of setImmediate that uses readystatechange on a DOM element

-

should use the post message impl

-

should use the post message impl

-

should use the readystatechange impl

-

should use the readystatechange impl

-

should use the setTimeout impl

-

should return a function that takes no arguments and will be called with the passed arguments

-

should coerce to a string and convert to a function which will be called by the returned function

-

should use Object.toString to return an identifier string

-

should return false

-

should return true

-

should maintain any existing onmessage handler

-

should return false

-

should return true

-

should return false

-

should return false

-

should return true if MessageChannel exists

-

should return false if MessageChannel does NOT exist

-

should return false if there is no document in global scope

-

should return true if created script elements have an onreadystatechange property

-

should return false if created script elements do NOT have an onreadystatechange property

-

should add to tasksByHandle and increment the nextHandle

-

should delete values from tasksByHandle

-

should delay running the task if it is currently running a task

-

should not error if there is no task currently running and the handle passed is not found

-

should execute the task and clean up after

-

should create a proper setImmediate implementation that uses setTimeout

-

should work

-

should exist

-

should act like a hashtable that accepts objects as keys

-

should allow setting keys twice

-

should have a delete method that removes keys

-

should exist

-

should iterate over keys and values

-

should use Set if Set exists

-

should provide the minimal Set we require

-

should implement add, has, size and clear

-

should create a message that is a clear indication of its internal errors

-

should exist

-

should use Object.assign if available

-

should assign n objects to a target

-

should assign n objects to a target

-

should return assignImpl if Object.assign does not exist on root

-

should return Object.assign if it exists

-

should exist

-

should synchronously complete when subscribe to scalarObservable

-

should subscribe to observables that are an instanceof Rx.Observable

-

should emit error when observable emits error

-

should subscribe to an array and emit synchronously

-

should subscribe to an array-like and emit synchronously

-

should subscribe to a promise

-

should emits error when the promise rejects

-

should subscribe an iterable and emit results synchronously

-

should subscribe to to an object that implements Symbol.observable

-

should emit an error if value returned by Symbol.observable call is not a valid observable

-

should emit an error when trying to subscribe to an unknown type of object

-

should emit an error when trying to subscribe to a non-object

-