                         fullscreenHandler.enterInFullscreen()
                         self.waitForExpectations(timeout: 2, handler: nil)
                     }
+
+                    it("should listen event from player") {
+                        let player = Player(options: core.options)
+                        var callbackWasCalled = false
+
+                        player.on(.requestFullscreen) { _ in
+                            callbackWasCalled = true
+                        }
+
+                        player.attachTo(UIView(), controller: UIViewController())
+                        player.setFullscreen(true)
+
+                        expect(callbackWasCalled).toEventually(beTrue())
+                    }
                 }
 
                 context("and player close fullscreen mode") {

                        }
                        fullscreenHandler.exitFullscreen()
                        self.waitForExpectations(timeout: 2, handler: nil)
                    }
                }
            }

                        core.parentView = UIView()
                        fullscreenHandler.exitFullscreen()
                        expect(core.parentView?.subviews.contains(core)).to(beTrue())
                    }

                    it("should trigger event on core") {
                        var callbackWasCalled = false

                        core.on(InternalEvent.didExitFullscreen.rawValue) { _ in
                            callbackWasCalled = true
                        }

                        fullscreenHandler.exitFullscreen()
                        expect(callbackWasCalled).toEventually(beTrue())
                    }

                    context("and call setFullscreen twice") {
                        beforeEach {
                            core.setFullscreen(false)
                        }

                        it("should keep property `fullscreen` of mediaControll to `false`") {
                            core.setFullscreen(false)
                            expect(core.mediaControl?.fullscreen).to(beFalse())
                        }

                        it("shouldn't post notification `willExitFullscreen`") {
                            self.expectation(forNotification: InternalEvent.willExitFullscreen.rawValue, object: fullscreenHandler) { notification in
                                return false
                            }
                            core.setFullscreen(false)
                            self.waitForExpectations(timeout: 2, handler: nil)
                        }

                        it("shouldn't post notification `didExitFullscreen`") {
                            self.expectation(forNotification: InternalEvent.didExitFullscreen.rawValue, object: fullscreenHandler) { notification in
                                return false
                            }
                            core.setFullscreen(false)
                            self.waitForExpectations(timeout: 2, handler: nil)
                        }

                    }
                }
            }
