                 it("Callback should not be called for another context object") {
                     let anotherObject = BaseObject()
                     
-                    baseObject.on(self.eventName) { userInfo in
-                        callbackWasCalled = true
-                    }
+                    baseObject.on(eventName, callback: callback)
                     
-                    anotherObject.trigger(self.eventName);
+                    anotherObject.trigger(eventName);
                     
                     expect(callbackWasCalled) == false
                 }
                 
                 it("Callback should not be called when handler is removed") {
-                    let callback: EventCallback = { userInfo in
-                        callbackWasCalled = true
-                    }
-                    
-                    baseObject.on(self.eventName, callback: callback)
-                    baseObject.off(self.eventName, callback: callback)
-                    baseObject.trigger(self.eventName)
+                    baseObject.on(eventName, callback: callback)
+                    baseObject.off(eventName, callback: callback)
+                    baseObject.trigger(eventName)
                     
                     expect(callbackWasCalled) == false
                 }
                 
                 it("Callback should not be called when stop listening is called") {
-                    let callback: EventCallback = { userInfo in
-                        callbackWasCalled = true
-                    }
-                    
-                    baseObject.on(self.eventName, callback: callback)
+                    baseObject.on(eventName, callback: callback)
                     baseObject.on("another-event", callback: callback)
                     baseObject.stopListening()
                     

            
            describe("once") {
                it("Callback should be called on event trigger") {
                    baseObject.once(self.eventName) { userInfo in
                        callbackWasCalled = true
                    }
                    
                    baseObject.trigger(self.eventName)
                    
                    expect(callbackWasCalled) == true
                }
                
                it("Callback should not be called twice") {
                    baseObject.once(self.eventName) { userInfo in
                        callbackWasCalled = true
                    }
                    
                    baseObject.trigger(self.eventName)
                    callbackWasCalled = false
                    baseObject.trigger(self.eventName)
                    
                    expect(callbackWasCalled) == false
                }

            
            describe("on") {
                it("Callback should be called on event trigger") {
                    baseObject.on(eventName, callback: callback)
                    baseObject.trigger(eventName)
                    
                    expect(callbackWasCalled) == true
                }
                
                it("Callback should receive userInfo on trigger with params") {
                    var value = "Not Expected"
                    baseObject.on(eventName) { userInfo in
                        value = userInfo?["new_value"] as! String
                    }
                    
                    baseObject.trigger(eventName, userInfo: ["new_value": "Expected"])
                    
                    expect(value) == "Expected"
                    
                }
                
                it("Callback should be called for every callback registered") {
                    baseObject.on(eventName, callback: callback)
                    
                    var secondCallbackWasCalled = false
                    baseObject.on(eventName) { userInfo in
                        secondCallbackWasCalled = true
                    }
                    
                    baseObject.trigger(eventName)
                    
                    expect(callbackWasCalled) == true
                    expect(secondCallbackWasCalled) == true
                }
                
                it("Callback should not be called for another event trigger") {
                    baseObject.on(eventName, callback: callback)
                    
                    baseObject.trigger("another-event")
                    
