 
 public func ==(lhs: ResolutionError, rhs: ResolutionError) -> Bool {
     switch (lhs, rhs){
-    case (.optional(let lname), .optional(let rname)):
-        return lname == rname
-    case (.implicitlyUnwrappedOptional(let lname), .implicitlyUnwrappedOptional(let rname)):
-        return lname == rname
     case (.tooManyDependencies(let ldependencyCount), .tooManyDependencies(let rdependencyCount)):
         return ldependencyCount == rdependencyCount
     default:

            
            it("does show warning for service with optional dependency"){
                let w = resolutionErrors(forInitializer: OptionalService.init)
                expect(w.first) == ResolutionError.optional("DependencyB")
            }
            
            it("does show warning for service with implicitly unwrapped dependency"){
                let w = resolutionErrors(forInitializer: UnwrappedService.init)
                expect(w.first) == ResolutionError.implicitlyUnwrappedOptional("DependencyA")
            }
            
            it("does show multiple warnings"){
                let w = resolutionErrors(forInitializer: BadService.init)
                expect(w.count) == 5
            }
            
            // This fails

                expect(w.count) == 0
            }
            
            it("doesnt show warning for optional closure"){
                let w = resolutionErrors(forInitializer: OptionalNestedClosureService.init)
                expect(w.count) == 0
            }
            
        }
