it('should clear out meesages array after 3 sec', () => {
    const testScheduler = new TestScheduler((actual, expected) => {
      expect(component.messages.length).toBe(0);
    });

    testScheduler.run(({ cold, expectObservable }) => {
      const input = cold('-a--|');
      input.pipe(tap(v => component.message$.next({} as any)));
      const expected = '-- 2999ms a ---|';
      expectObservable(component.remover$).toBe(expected);
    });
  });

  it('should cache value for next subscription and not call callbackFunc again', () => {
    let calls = 0;
    function callback(datum: number, cb: (x: number) => void) {
      calls++;
      cb(datum);
    }
    const boundCallback = bindCallback(callback, rxTestScheduler);
    const results1: Array<number|string> = [];
    const results2: Array<number|string> = [];

    const source = boundCallback(42);

    source.subscribe(x => {
      results1.push(x);
    }, null, () => {
      results1.push('done');
    });

    source.subscribe(x => {
      results2.push(x);
    }, null, () => {
      results2.push('done');
    });

    rxTestScheduler.flush();

    expect(calls).to.equal(1);
    expect(results1).to.deep.equal([42, 'done']);
    expect(results2).to.deep.equal([42, 'done']);
  });

  it('should schedule a value at a specified Date', () => {
    const offset = time('----|');
    const expected =    '----(a|)';

    const dueTime = new Date(rxTestScheduler.now() + offset);
    const source = timer(dueTime, null, rxTestScheduler);
    expectObservable(source).toBe(expected, {a: 0});
  });

 it('should handle never', () => {
   let executed = false;
   let s1 = hot('-');
   let result = s1.pipe(finalize(() => executed = true));
   let expected = '-';
   expectObservable(result).toBe(expected);
   // manually flush so `finalize()` has chance to execute before the test is over.
   rxTestScheduler.flush();
   expect(executed).to.be.false;
 });

 it('should take a scheduler', () => {
   const source = empty(rxTestScheduler);
   let hit = false;
   source.subscribe({
     complete() { hit = true; }
   });
   expect(hit).to.be.false;
   rxTestScheduler.flush();
   expect(hit).to.be.true;
 });

  it('should delay by absolute time period after subscription', () => {
    const e1 =   hot('---^--a--b--|  ');
    const t =   time(      '---|     ');
    const expected =    '------a--b--|';
    const subs =        '^           !';

    const absoluteDelay = new Date(rxTestScheduler.now() + t);
    const result = e1.delay(absoluteDelay, rxTestScheduler);

    expectObservable(result).toBe(expected);
    expectSubscriptions(e1.subscriptions).toBe(subs);
  });

		it('should skip entries with existing values', () => {
			const scheme = {
				src: '^--1--1--2|',
				sub: '^---------!',
				res: '0--1-----2-',
			};
			type Entity = {
				key: string;
				value: string;
			};
			const values = {
				1: {
					key: 'foo',
					value: 'fooValue',
				},
				2: {
					key: 'bar',
					value: 'barValue',
				},
			};
			const expected = {
				0: [],
				1: [[values[1].key, values[1].value]],
				2: [[values[1].key, values[1].value], [values[2].key, values[2].value]],
			};
			scheduler
				.createHotObservable<Entity>(scheme.src, values)
				.pipe(tap(value => map.set(value.key, value.value)))
				.subscribe();
			scheduler.expectObservable(map.entries$).toBe(scheme.res, expected);
		});