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

			describe("multiple element action") {
				sharedExamples("send array elements to elements observable") {
					it("work factory receives inputs") {
						XCTAssertEqual(inputs.events, Recorded.events([
                            .next(10, "a"),
                            .next(20, "b")
                            ])
                        )
                    }
                    
                    it("elements observable receives generated elements") {
                        XCTAssertEqual(elements.events, Recorded.events([
                          .next(10, "a"),
                          .next(10, "b"),
                          .next(10, "c"),
                          .next(20, "b"),
                          .next(20, "c"),
                          .next(20, "d")
                          ])
                        )
                    }
                    
                    it("errors observable receives nothing") {
                        XCTAssertEqual(errors.events, [])
                    }
                    
                    it("disabled until element returns") {
                        XCTAssertEqual(enabled.events, Recorded.events([
                          .next(0, true),
                          .next(10, false),
                          .next(10, true),
                          .next(20, false),
                          .next(20, true)
                          ])
                        )
                    }
                    
                    it("executing until element returns") {
                        XCTAssertEqual(executing.events, Recorded.events([
                          .next(0, false),
                          .next(10, true),
                          .next(10, false),
                          .next(20, true),
                          .next(20, false)
                          ])
                        )
					}

					it("executes twice") {
						expect(executionObservables.events.count) == 2
					}
				}


                }
                
                it("element receives 3 values for each execution") {
                    expect(element.events).to(match(TestEvents.multipleExecutionStreams))
                }
                
                it("executes twice") {
                    expect(executionObservables.events.count).to(match(2))
                }
            }
            
