                 context("and player close fullscreen mode") {
 
                     beforeEach {
-                        fullscreenHandler.enterInFullscreen()
+                        core.setFullscreen(true)
                     }
 
                     it("should set property `fullscreen` of mediaControll to `false`") {
-                        fullscreenHandler.exitFullscreen()
                         core.setFullscreen(false)
                         expect(core.mediaControl?.fullscreen).to(beFalse())
                     }
 
                     it("should post notification `exitFullscreen`") {
-                        self.expectation(forNotification: Event.exitFullscreen.rawValue, object: fullscreenHandler) { notification in
-                            return true
-                        }
-                        fullscreenHandler.exitFullscreen()
+                        self.expectation(forNotification: Event.exitFullscreen.rawValue, object: core) { notification in
+                            return true
+                        }
+
+                        core.setFullscreen(false)
                         self.waitForExpectations(timeout: 2, handler: nil)
                     }
 

                        }

                        it("shouldn't post notification `willEnterFullscreen`") {
                            let expect = self.expectation(forNotification: InternalEvent.willEnterFullscreen.rawValue, object: fullscreenHandler) { notification in
                                return true
                            }

                            expect.isInverted = true
                            core.setFullscreen(true)
                            self.waitForExpectations(timeout: 2, handler: nil)
                        }

                        it("shouldn't post notification `didEnterFullscreen`") {
                            let expect = self.expectation(forNotification: InternalEvent.didEnterFullscreen.rawValue, object: fullscreenHandler) { notification in
                                return true
                            }
                            expect.isInverted = true
                            core.setFullscreen(true)
                            self.waitForExpectations(timeout: 2, handler: nil)
                        }

            context("when fullscreen is done by app") {

                var core: Core!

                beforeEach {
                    core = Core(options: [kFullscreenByApp: true] as Options)
                }

                context("and player enter in fullscreen mode") {

                    beforeEach {
                        core.setFullscreen(false)
                    }

                    it("should set property `fullscreen` of mediaControll to `true`") {
                        core.setFullscreen(true)
                        expect(core.mediaControl?.fullscreen).to(beTrue())
                    }

                    it("should post notification `requestFullscreen`") {
                       self.expectation(forNotification: Event.requestFullscreen.rawValue, object: core) { notification in
                            return true
                        }

                        core.setFullscreen(true)
                        self.waitForExpectations(timeout: 2, handler: nil)
                    }

                    it("should listen to requestFullscreen event from player") {
                        let player = Player(options: core.options)
                        var callbackWasCalled = false

