                 }
                 
                 it("element receives 3 values for each execution") {
-                    XCTAssertEqual(element.events, Recorded.events([
-                      .next(10, "a"),
-                      .next(10, "a"),
-                      .next(10, "a"),
-                      .completed(10),
-                      .next(20, "b"),
-                      .next(20, "b"),
-                      .next(20, "b"),
-                      .completed(20)
-                      ])
-                    )
+                    expect(element.events).to(match(TestEvents.multipleExecutionStreams))
                 }
                 
                 it("executes twice") {
-                    expect(executionObservables.events.count) == 2
+                    expect(executionObservables.events.count).to(match(2))
                 }
             }
             

                scheduler.scheduleAt(10) { action.inputs.onNext("a") }
                scheduler.scheduleAt(20) { action.inputs.onNext("b") }
            }
            afterEach {
                action = nil
            }
            it("receives generated inputs") {
                scheduler.start()
                XCTAssertEqual(inputs.events, Recorded.events([
                  .next(10, "a"),
                  .next(20, "b")
                  ])
                )
            }
            it("emits nothing on `elements`") {
                let elements = scheduler.createObserver(Never.self)
                action.elements.bind(to: elements).disposed(by: disposeBag)
                scheduler.start()
                XCTAssertEqual(elements.events.count, 0)
            }
            it("emits on `completions` when completed") {
                let completions = scheduler.createObserver(Void.self)
                action.completions.bind(to: completions).disposed(by: disposeBag)
                scheduler.start()
                XCTAssert(completions.events.contains { $0.time == 10})
                XCTAssert(completions.events.contains { $0.time == 20})
            }
        }


            it("execute on .next") {
                scheduler.scheduleAt(10) { action.inputs.onNext("a") }
                scheduler.start()
                let hasStopEvent = executions.events.filter { $0.value.isStopEvent }.isEmpty
                expect(hasStopEvent).to(beTrue())
            }
            it("ignore .error events") {
                scheduler.scheduleAt(10) { action.inputs.onError(TestError) }
                scheduler.start()
                let hasStopEvent = executions.events.filter { $0.value.isStopEvent }.isEmpty
                expect(hasStopEvent).to(beTrue())
            }
            it("ignore .completed events") {
                scheduler.scheduleAt(10) { action.inputs.onCompleted() }
                scheduler.start()
                let hasStopEvent = executions.events.filter { $0.value.isStopEvent }.isEmpty
                expect(hasStopEvent).to(beTrue())
                expect(inputs.events.isEmpty).to(beTrue())
            }
            it("accept multiple .next events") {
                scheduler.scheduleAt(10) { action.inputs.onNext("a") }
                scheduler.scheduleAt(20) { action.inputs.onNext("b") }
                scheduler.start()
                expect(inputs.events).to(match(TestEvents.inputs))
                let executionsCount = executions.events.filter { !$0.value.isStopEvent }.count
                expect(executionsCount).to(match(2))
            }
            it("not terminate after .error event") {
                scheduler.scheduleAt(10) { action.inputs.onError(TestError) }
                scheduler.scheduleAt(20) { action.inputs.onNext("b") }
                scheduler.start()
                expect(inputs.events).to(match(Recorded.events([.next(20, "b")])))
                let executionsCount = executions.events.filter { !$0.value.isStopEvent }.count
                expect(executionsCount).to(match(1))
            }
            it("not terminate after .completed event") {
                scheduler.scheduleAt(10) { action.inputs.onCompleted() }
                scheduler.scheduleAt(20) { action.inputs.onNext("b") }
                scheduler.start()
                expect(inputs.events).to(match(Recorded.events([.next(20, "b")])))
                let executionsCount = executions.events.filter { !$0.value.isStopEvent }.count
                expect(executionsCount).to(match(1))
            }
        }
        
		describe("action properties") {
            var inputs: TestableObserver<String>!
            var elements: TestableObserver<String>!
