Merge pull request #237 from michalsrutek/develop

Fix couple of typos
Merge pull request #238 from michalsrutek/use-anyobject-keyword
2020-05-29 14:42:25 +01:00 · 2020-05-29 14:42:03 +01:00 · 2020-04-23 10:22:20 +02:00 · 2020-04-23 09:59:03 +02:00 · 2019-12-27 11:14:55 +00:00 · 2019-12-27 11:07:21 +00:00
44 changed files with 932 additions and 620 deletions
@@ -36,3 +36,4 @@ Carthage
 # SPM
 .build/
 Packages
+.swiftpm
@@ -1 +0,0 @@
-4.2
@@ -5,14 +5,25 @@ matrix:
    - script:
        - set -o pipefail && xcodebuild test -workspace Dip.xcworkspace -scheme Dip -sdk iphonesimulator -destination 'platform=iOS Simulator,name=iPhone 6,OS=latest' ONLY_ACTIVE_ARCH=NO | xcpretty -c
        - set -o pipefail && xcodebuild test -workspace Dip.xcworkspace -scheme Dip -sdk macosx -destination 'platform=macOS,arch=x86_64' ONLY_ACTIVE_ARCH=NO | xcpretty -c
-        - pod spec lint --allow-warnings
+        # - pod spec lint --allow-warnings
        - carthage build --no-skip-current
        - swift package clean && swift build && swift test
      os: osx
-      osx_image: xcode10
+      osx_image: xcode10.2
      language: objective-c
      before_install:
-        - gem install cocoapods --version 1.6.0.beta.1 --no-document
+        - gem install cocoapods --version 1.8.4 --no-document
+    - script:
+        - set -o pipefail && xcodebuild test -workspace Dip.xcworkspace -scheme Dip -sdk iphonesimulator -destination 'platform=iOS Simulator,name=iPhone 11,OS=latest' ONLY_ACTIVE_ARCH=NO | xcpretty -c
+        - set -o pipefail && xcodebuild test -workspace Dip.xcworkspace -scheme Dip -sdk macosx -destination 'platform=macOS,arch=x86_64' ONLY_ACTIVE_ARCH=NO | xcpretty -c
+        # - pod spec lint --allow-warnings
+        - carthage build --no-skip-current
+        - swift package clean && swift build && swift test
+      os: osx
+      osx_image: xcode11.2
+      language: objective-c
+      before_install:
+        - gem install cocoapods --version 1.8.4 --no-document
    - script:
        - swift package clean && swift build && swift test
      os: linux
@@ -22,8 +33,22 @@ matrix:
      before_install:
        - wget -q -O - https://swift.org/keys/all-keys.asc | gpg --import -
        - cd ..
-        - export SWIFT_VERSION=swift-4.2-RELEASE
-        - wget https://swift.org/builds/swift-4.2-release/ubuntu1404/$SWIFT_VERSION/$SWIFT_VERSION-ubuntu14.04.tar.gz
+        - export SWIFT_VERSION=swift-5.1-RELEASE
+        - wget https://swift.org/builds/swift-5.1-release/ubuntu1404/$SWIFT_VERSION/$SWIFT_VERSION-ubuntu14.04.tar.gz
+        - tar xzf $SWIFT_VERSION-ubuntu14.04.tar.gz
+        - export PATH="${PWD}/${SWIFT_VERSION}-ubuntu14.04/usr/bin:${PATH}"
+        - cd Dip
+    - script:
+        - swift package clean && swift build && swift test
+      os: linux
+      dist: trusty
+      sudo: required
+      language: generic
+      before_install:
+        - wget -q -O - https://swift.org/keys/all-keys.asc | gpg --import -
+        - cd ..
+        - export SWIFT_VERSION=swift-5.0-RELEASE
+        - wget https://swift.org/builds/swift-5.0-release/ubuntu1404/$SWIFT_VERSION/$SWIFT_VERSION-ubuntu14.04.tar.gz
        - tar xzf $SWIFT_VERSION-ubuntu14.04.tar.gz
        - export PATH="${PWD}/${SWIFT_VERSION}-ubuntu14.04/usr/bin:${PATH}"
        - cd Dip
@@ -1,5 +1,19 @@
 # CHANGELOG

+## Develop
+
+## 7.1.1
+
+* Fixed using `StoryboardInstantiatable` with SPM  ([#233](https://github.com/AliSoftware/Dip/pull/233)).
+
+## 7.1.0
+
+* You can now use a shorthand syntax for resolving a single property using a key path, i.e. `resolvingProperty(\.value)`.
+* Swift 5.0 support ([#224](https://github.com/AliSoftware/Dip/pull/224)).
+* Fixed resolving nested types with the same local names ([#221](https://github.com/AliSoftware/Dip/pull/221)).
+* `@Injected` and `@IntectedWeak` property wrappers ([#225](https://github.com/AliSoftware/Dip/pull/225)).
+* Thread safety can be disabled on container level.
+
 ## 7.0.1

 * Added a workaround for Swift 4.2 regression related to retaining weak properties ([#214](https://github.com/AliSoftware/Dip/issues/214)).
@@ -1,6 +1,6 @@
 Pod::Spec.new do |s|
  s.name             = "Dip"
-  s.version          = "7.0.1"
+  s.version          = "7.1.1"
  s.summary          = "Dependency Injection for Swift made easy."

  s.description      = <<-DESC
@@ -11,7 +11,7 @@ Pod::Spec.new do |s|

  s.homepage         = "https://github.com/AliSoftware/Dip"
  s.license          = 'MIT'
-  s.authors          = { "Olivier Halligon" => "olivier@halligon.net", "Ilya Puchka" => "ilya@puchka.me" }
+  s.authors          = { "Olivier Halligon" => "olivier@halligon.net", "Ilya Puchka" => "ilyapuchka@gmail.com" }
  s.source           = { :git => "https://github.com/AliSoftware/Dip.git", :tag => s.version.to_s }
  s.social_media_url = 'https://twitter.com/aligatr'

@@ -23,4 +23,6 @@ Pod::Spec.new do |s|
  s.requires_arc = true

  s.source_files = 'Sources/**/*.swift'
+
+  s.swift_version = "5.0", "5.1"
 end
@@ -221,25 +221,26 @@
 			isa = PBXProject;
 			attributes = {
 				LastSwiftUpdateCheck = 0730;
-				LastUpgradeCheck = 0930;
+				LastUpgradeCheck = 1020;
 				ORGANIZATIONNAME = AliSoftware;
 				TargetAttributes = {
 					0903B3571C161543002241C1 = {
 						CreatedOnToolsVersion = 7.1.1;
-						LastSwiftMigration = 0800;
+						LastSwiftMigration = 1020;
 					};
 					0903B3601C161543002241C1 = {
 						CreatedOnToolsVersion = 7.1.1;
-						LastSwiftMigration = 0800;
+						LastSwiftMigration = 1020;
 					};
 				};
 			};
 			buildConfigurationList = 0945268B1BEA1CFF0034E72A /* Build configuration list for PBXProject "Dip" */;
 			compatibilityVersion = "Xcode 3.2";
-			developmentRegion = English;
+			developmentRegion = en;
 			hasScannedForEncodings = 0;
 			knownRegions = (
 				en,
+				Base,
 			);
 			mainGroup = 094526871BEA1CFF0034E72A;
 			productRefGroup = 094526921BEA1CFF0034E72A /* Products */;
@@ -360,7 +361,7 @@
 				PRODUCT_BUNDLE_IDENTIFIER = com.alisoftware.Dip;
 				PRODUCT_NAME = Dip;
 				SKIP_INSTALL = YES;
-				SWIFT_VERSION = 4.2;
+				SWIFT_VERSION = 5.0;
 			};
 			name = Debug;
 		};
@@ -380,7 +381,7 @@
 				PRODUCT_BUNDLE_IDENTIFIER = com.alisoftware.Dip;
 				PRODUCT_NAME = Dip;
 				SKIP_INSTALL = YES;
-				SWIFT_VERSION = 4.2;
+				SWIFT_VERSION = 5.0;
 			};
 			name = Release;
 		};
@@ -402,7 +403,7 @@
 				"STORYBOARD_NAME_PREFIX[sdk=iphoneos*]" = UI;
 				"STORYBOARD_NAME_PREFIX[sdk=iphonesimulator*]" = UI;
 				SWIFT_OPTIMIZATION_LEVEL = "-Onone";
-				SWIFT_VERSION = 4.2;
+				SWIFT_VERSION = 5.0;
 			};
 			name = Debug;
 		};
@@ -419,7 +420,7 @@
 				PRODUCT_BUNDLE_IDENTIFIER = com.alisoftware.DipTests;
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				STORYBOARD_NAME_PREFIX = "";
-				SWIFT_VERSION = 4.2;
+				SWIFT_VERSION = 5.0;
 			};
 			name = Release;
 		};
@@ -427,6 +428,7 @@
 			isa = XCBuildConfiguration;
 			buildSettings = {
 				ALWAYS_SEARCH_USER_PATHS = NO;
+				CLANG_ANALYZER_LOCALIZABILITY_NONLOCALIZED = YES;
 				CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x";
 				CLANG_CXX_LIBRARY = "libc++";
 				CLANG_ENABLE_MODULES = YES;
@@ -477,12 +479,12 @@
 				ONLY_ACTIVE_ARCH = YES;
 				SUPPORTED_PLATFORMS = "macosx watchsimulator iphonesimulator appletvsimulator watchos appletvos iphoneos";
 				SWIFT_OPTIMIZATION_LEVEL = "-Onone";
-				SWIFT_VERSION = 4.0;
+				SWIFT_VERSION = 5.0;
 				TARGETED_DEVICE_FAMILY = "1,2,3,4";
 				TVOS_DEPLOYMENT_TARGET = 9.0;
 				VERSIONING_SYSTEM = "apple-generic";
 				VERSION_INFO_PREFIX = "";
-				WATCHOS_DEPLOYMENT_TARGET = 2.0;
+				WATCHOS_DEPLOYMENT_TARGET = 3.0;
 			};
 			name = Debug;
 		};
@@ -490,6 +492,7 @@
 			isa = XCBuildConfiguration;
 			buildSettings = {
 				ALWAYS_SEARCH_USER_PATHS = NO;
+				CLANG_ANALYZER_LOCALIZABILITY_NONLOCALIZED = YES;
 				CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x";
 				CLANG_CXX_LIBRARY = "libc++";
 				CLANG_ENABLE_MODULES = YES;
@@ -533,13 +536,13 @@
 				MTL_ENABLE_DEBUG_INFO = NO;
 				SUPPORTED_PLATFORMS = "macosx watchsimulator iphonesimulator appletvsimulator watchos appletvos iphoneos";
 				SWIFT_OPTIMIZATION_LEVEL = "-Owholemodule";
-				SWIFT_VERSION = 4.0;
+				SWIFT_VERSION = 5.0;
 				TARGETED_DEVICE_FAMILY = "1,2,3,4";
 				TVOS_DEPLOYMENT_TARGET = 9.0;
 				VALIDATE_PRODUCT = YES;
 				VERSIONING_SYSTEM = "apple-generic";
 				VERSION_INFO_PREFIX = "";
-				WATCHOS_DEPLOYMENT_TARGET = 2.0;
+				WATCHOS_DEPLOYMENT_TARGET = 3.0;
 			};
 			name = Release;
 		};
@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <Scheme
-   LastUpgradeVersion = "0930"
+   LastUpgradeVersion = "1020"
   version = "1.3">
   <BuildAction
      parallelizeBuildables = "YES"
@@ -9,7 +9,7 @@
 	<key>CFBundleIdentifier</key>
 	<string>$(PRODUCT_BUNDLE_IDENTIFIER)</string>
 	<key>CFBundleInfoDictionaryVersion</key>
-	<string>7.0.1</string>
+	<string>7.1.1</string>
 	<key>CFBundleName</key>
 	<string>$(PRODUCT_NAME)</string>
 	<key>CFBundlePackageType</key>
@@ -9,7 +9,7 @@
 	<key>CFBundleIdentifier</key>
 	<string>$(PRODUCT_BUNDLE_IDENTIFIER)</string>
 	<key>CFBundleInfoDictionaryVersion</key>
-	<string>7.0.1</string>
+	<string>7.1.1</string>
 	<key>CFBundleName</key>
 	<string>$(PRODUCT_NAME)</string>
 	<key>CFBundlePackageType</key>
@@ -13,7 +13,7 @@ On the previous page you saw how auto-wiring helps us to get rid of boilerplate
 Let's say you have following related components:
 */

-protocol Service: class {
+protocol Service: AnyObject {
    var logger: Logger? { get }
    var tracker: Tracker? { get }
 }
@@ -101,11 +101,11 @@ serverWithNoClient.optionalClient.value
 Another example of using auto-injection is circular dependencies. Let's say you have a `Server` and a `ServerClient` both referencing each other.
 */

-protocol Server: class {
+protocol Server: AnyObject {
    weak var client: ServerClient? { get }
 }

-protocol ServerClient: class {
+protocol ServerClient: AnyObject {
    var server: Server? { get }
 }

@@ -13,11 +13,11 @@ Very often we encounter situations when we have circular dependencies between co
 Let's say you have some network client and it's delegate defined like this:
 */

-protocol NetworkClientDelegate: class {
+protocol NetworkClientDelegate: AnyObject {
    var networkClient: NetworkClient { get }
 }

-protocol NetworkClient: class {
+protocol NetworkClient: AnyObject {
    weak var delegate: NetworkClientDelegate? { get set }
 }

@@ -1,6 +1,6 @@
 import Foundation

-public protocol Service: class {}
+public protocol Service: AnyObject {}

 public class ServiceImp1: Service {
  public init() {}
@@ -22,7 +22,7 @@ public class ServiceImp4: Service {
  
 }

-public protocol Client: class {
+public protocol Client: AnyObject {
  var service: Service {get}
  init(service: Service)
 }
@@ -74,9 +74,9 @@ public class DataProviderImp: DataProvider {
    public init() {}
 }

-public protocol ListInteractorOutput: class {}
-public protocol ListModuleInterface: class {}
-public protocol ListInteractorInput: class {}
+public protocol ListInteractorOutput: AnyObject {}
+public protocol ListModuleInterface: AnyObject {}
+public protocol ListInteractorInput: AnyObject {}
 public class ListPresenter: NSObject {
    public var listInteractor : ListInteractorInput?
    public var listWireframe : ListWireframe?
@@ -96,8 +96,8 @@ public class ListWireframe : NSObject {
    }
 }

-public protocol AddModuleDelegate: class {}
-public protocol AddModuleInterface: class {}
+public protocol AddModuleDelegate: AnyObject {}
+public protocol AddModuleInterface: AnyObject {}
 public class AddWireframe: NSObject {
    let addPresenter : AddPresenter
    public init(addPresenter: AddPresenter) {
@@ -0,0 +1,3 @@
+source "https://rubygems.org"
+
+gem "cocoapods", '=1.4.0'
@@ -0,0 +1,76 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    CFPropertyList (3.0.0)
+    activesupport (4.2.11)
+      i18n (~> 0.7)
+      minitest (~> 5.1)
+      thread_safe (~> 0.3, >= 0.3.4)
+      tzinfo (~> 1.1)
+    atomos (0.1.3)
+    claide (1.0.2)
+    cocoapods (1.4.0)
+      activesupport (>= 4.0.2, < 5)
+      claide (>= 1.0.2, < 2.0)
+      cocoapods-core (= 1.4.0)
+      cocoapods-deintegrate (>= 1.0.2, < 2.0)
+      cocoapods-downloader (>= 1.1.3, < 2.0)
+      cocoapods-plugins (>= 1.0.0, < 2.0)
+      cocoapods-search (>= 1.0.0, < 2.0)
+      cocoapods-stats (>= 1.0.0, < 2.0)
+      cocoapods-trunk (>= 1.3.0, < 2.0)
+      cocoapods-try (>= 1.1.0, < 2.0)
+      colored2 (~> 3.1)
+      escape (~> 0.0.4)
+      fourflusher (~> 2.0.1)
+      gh_inspector (~> 1.0)
+      molinillo (~> 0.6.4)
+      nap (~> 1.0)
+      ruby-macho (~> 1.1)
+      xcodeproj (>= 1.5.4, < 2.0)
+    cocoapods-core (1.4.0)
+      activesupport (>= 4.0.2, < 6)
+      fuzzy_match (~> 2.0.4)
+      nap (~> 1.0)
+    cocoapods-deintegrate (1.0.2)
+    cocoapods-downloader (1.2.2)
+    cocoapods-plugins (1.0.0)
+      nap
+    cocoapods-search (1.0.0)
+    cocoapods-stats (1.0.0)
+    cocoapods-trunk (1.3.1)
+      nap (>= 0.8, < 2.0)
+      netrc (~> 0.11)
+    cocoapods-try (1.1.0)
+    colored2 (3.1.2)
+    concurrent-ruby (1.1.4)
+    escape (0.0.4)
+    fourflusher (2.0.1)
+    fuzzy_match (2.0.4)
+    gh_inspector (1.1.3)
+    i18n (0.9.5)
+      concurrent-ruby (~> 1.0)
+    minitest (5.11.3)
+    molinillo (0.6.6)
+    nanaimo (0.2.6)
+    nap (1.1.0)
+    netrc (0.11.0)
+    ruby-macho (1.3.1)
+    thread_safe (0.3.6)
+    tzinfo (1.2.5)
+      thread_safe (~> 0.1)
+    xcodeproj (1.7.0)
+      CFPropertyList (>= 2.3.3, < 4.0)
+      atomos (~> 0.1.3)
+      claide (>= 1.0.2, < 2.0)
+      colored2 (~> 3.1)
+      nanaimo (~> 0.2.6)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  cocoapods (= 1.4.0)
+
+BUNDLED WITH
+   1.16.5
@@ -0,0 +1,8 @@
+import XCTest
+
+import DipTests
+
+var tests = [XCTestCaseEntry]()
+tests += DipTests.__allTests()
+
+XCTMain(tests)
@@ -1,30 +1,15 @@
-//
-// Dip
-//
-// Copyright (c) 2015 Olivier Halligon <olivier@halligon.net>
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-//
+// swift-tools-version:5.0

 import PackageDescription

 let package = Package(
-    name: "Dip"
+    name: "Dip",
+    products: [
+        .library(name: "Dip", targets: ["Dip"]),
+    ],
+    targets: [
+        .target(name: "Dip", dependencies: [], path: "Sources"),
+        .testTarget(name: "DipTests", dependencies: ["Dip"], path: "Tests"),
+    ]
 )

@@ -279,7 +279,7 @@
 			isa = PBXProject;
 			attributes = {
 				LastSwiftUpdateCheck = 0700;
-				LastUpgradeCheck = 0930;
+				LastUpgradeCheck = 1020;
 				ORGANIZATIONNAME = AliSoftware;
 				TargetAttributes = {
 					0990225E1BC123C000E76F43 = {
@@ -292,7 +292,7 @@
 			};
 			buildConfigurationList = 607FACCB1AFB9204008FA782 /* Build configuration list for PBXProject "DipSampleApp" */;
 			compatibilityVersion = "Xcode 3.2";
-			developmentRegion = English;
+			developmentRegion = en;
 			hasScannedForEncodings = 0;
 			knownRegions = (
 				en,
@@ -423,6 +423,7 @@
 			isa = XCBuildConfiguration;
 			buildSettings = {
 				ALWAYS_SEARCH_USER_PATHS = NO;
+				CLANG_ANALYZER_LOCALIZABILITY_NONLOCALIZED = YES;
 				CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x";
 				CLANG_CXX_LIBRARY = "libc++";
 				CLANG_ENABLE_MODULES = YES;
@@ -479,6 +480,7 @@
 			isa = XCBuildConfiguration;
 			buildSettings = {
 				ALWAYS_SEARCH_USER_PATHS = NO;
+				CLANG_ANALYZER_LOCALIZABILITY_NONLOCALIZED = YES;
 				CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x";
 				CLANG_CXX_LIBRARY = "libc++";
 				CLANG_ENABLE_MODULES = YES;
@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <Scheme
-   LastUpgradeVersion = "0930"
+   LastUpgradeVersion = "1020"
   version = "1.3">
   <BuildAction
      parallelizeBuildables = "YES"
@@ -9,7 +9,7 @@
 	<key>CFBundleIdentifier</key>
 	<string>$(PRODUCT_BUNDLE_IDENTIFIER)</string>
 	<key>CFBundleInfoDictionaryVersion</key>
-	<string>7.0.1</string>
+	<string>7.1.1</string>
 	<key>CFBundleName</key>
 	<string>$(PRODUCT_NAME)</string>
 	<key>CFBundlePackageType</key>
@@ -8,7 +8,7 @@

 import Foundation

-///Provides Person entitis fetching them with web service
+///Provides Person entities fetching them with web service
 struct SWAPIPersonProvider : PersonProviderAPI {
    let ws: NetworkLayer
    
@@ -8,7 +8,7 @@

 import UIKit

-protocol FetchableTrait: class {
+protocol FetchableTrait: AnyObject {
    associatedtype ObjectType
    var objects: [ObjectType]? { get set }
    var batchRequestID: Int { get set }
@@ -9,7 +9,7 @@
 	<key>CFBundleIdentifier</key>
 	<string>$(PRODUCT_BUNDLE_IDENTIFIER)</string>
 	<key>CFBundleInfoDictionaryVersion</key>
-	<string>7.0.1</string>
+	<string>7.1.1</string>
 	<key>CFBundleName</key>
 	<string>$(PRODUCT_NAME)</string>
 	<key>CFBundlePackageType</key>
@@ -78,7 +78,7 @@ extension DependencyContainer {
 ```

 */
-public protocol AutoInjectedPropertyBox: class {
+public protocol AutoInjectedPropertyBox {
  ///The type of wrapped property.
  static var wrappedType: Any.Type { get }
  
@@ -93,40 +93,108 @@ public protocol AutoInjectedPropertyBox: class {
  func resolve(_ container: DependencyContainer) throws
 }

+#if swift(>=5.1)
 /**
 Use this wrapper to identify _strong_ properties of the instance that should be
 auto-injected by `DependencyContainer`. Type T can be any type.
-
- - warning: Do not define this property as optional or container will not be able to inject it.
-            Instead define it with initial value of `Injected<T>()`.
-
+ 
 **Example**:
+ 
+ ```swift
+ class ClientImp: Client {
+   @Injected var service: Service?
+ }
+ ```
+ 
+ - seealso: `InjectedWeak`
+ 
+ */
+@propertyWrapper
+public struct Injected<T>: _InjectedPropertyBox, AutoInjectedPropertyBox {
+  let valueBox: NullableBox<T> = NullableBox(nil)
+  
+  ///Wrapped value.
+  public var wrappedValue: T? {
+    get {
+      return valueBox.unboxed
+    }
+    set {
+      guard (required && newValue != nil) || !required else {
+        fatalError("Can not set required property to nil.")
+      }
+      valueBox.unboxed = newValue
+    }
+  }
+  

+  let required: Bool
+  let didInject: (T) -> ()
+  let tag: DependencyContainer.Tag?
+  let overrideTag: Bool
+
+  public init(wrappedValue initialValue: T?) {
+    self.init()
+  }
+}
+#else
+/**
+ Use this wrapper to identify _strong_ properties of the instance that should be
+ auto-injected by `DependencyContainer`. Type T can be any type.
+ 
+ - warning: Do not define this property as optional or container will not be able to inject it.
+ Instead define it with initial value of `Injected<T>()`.
+ 
+ **Example**:
+ 
 ```swift
 class ClientImp: Client {
   var service = Injected<Service>()
 }
 ```
+ 
 - seealso: `InjectedWeak`
-
-*/
-public final class Injected<T>: _InjectedPropertyBox<T>, AutoInjectedPropertyBox {
+ 
+ */
+public struct Injected<T>: _InjectedPropertyBox, AutoInjectedPropertyBox {
+  let valueBox: NullableBox<T> = NullableBox(nil)
  
+  ///Wrapped value.
+  public var value: T? {
+    return valueBox.unboxed
+  }
+
+  let required: Bool
+  let didInject: (T) -> ()
+  let tag: DependencyContainer.Tag?
+  let overrideTag: Bool
+  
+  /// Returns a new wrapper with provided value.
+  func setValue(_ value: T?) -> Injected {
+    guard (required && value != nil) || !required else {
+      fatalError("Can not set required property to nil.")
+    }
+    
+    return Injected(value: value, required: required, tag: tag, overrideTag: overrideTag, didInject: didInject)
+  }
+}
+#endif
+
+public extension Injected {
  ///The type of wrapped property.
-  public static var wrappedType: Any.Type {
+  static var wrappedType: Any.Type {
    return T.self
  }
-
-  ///Wrapped value.
-  public internal(set) var value: T? {
-    didSet {
-      if let value = value { didInject(value) }
-    }
-  }
-
+  
  init(value: T?, required: Bool = true, tag: DependencyTagConvertible?, overrideTag: Bool, didInject: @escaping (T) -> ()) {
-    self.value = value
-    super.init(required: required, tag: tag, overrideTag: overrideTag, didInject: didInject)
+    self.init(required: required, tag: tag, overrideTag: overrideTag, didInject: didInject)
+    self.valueBox.unboxed = value
+  }
+  
+  init(required: Bool = true, tag: DependencyTagConvertible?, overrideTag: Bool, didInject: @escaping (T) -> () = { _ in }) {
+    self.required = required
+    self.tag = tag?.dependencyTag
+    self.overrideTag = overrideTag
+    self.didInject = didInject
  }

  /**
@@ -140,30 +208,24 @@ public final class Injected<T>: _InjectedPropertyBox<T>, AutoInjectedPropertyBox
      - didInject: Block that will be called when concrete instance is injected in this property.
                   Similar to `didSet` property observer. Default value does nothing.
   */
-  public convenience init(required: Bool = true, didInject: @escaping (T) -> () = { _ in }) {
+  init(required: Bool = true, didInject: @escaping (T) -> () = { _ in }) {
    self.init(value: nil, required: required, tag: nil, overrideTag: false, didInject: didInject)
  }
  
-  public convenience init(required: Bool = true, tag: DependencyTagConvertible?, didInject: @escaping (T) -> () = { _ in }) {
+  init(required: Bool = true, tag: DependencyTagConvertible?, didInject: @escaping (T) -> () = { _ in }) {
    self.init(value: nil, required: required, tag: tag, overrideTag: true, didInject: didInject)
  }

-  public func resolve(_ container: DependencyContainer) throws {
-    let resolved: T? = try super.resolve(with: container)
-    value = resolved
-  }
-
-  /// Returns a new wrapper with provided value.
-  public func setValue(_ value: T?) -> Injected {
-    guard (required && value != nil) || !required else {
-      fatalError("Can not set required property to nil.")
+  func resolve(_ container: DependencyContainer) throws {
+    let resolved: T? = try self.resolve(with: container, tag: tag, overrideTag: overrideTag, required: required)
+    valueBox.unboxed = resolved
+    if let resolved = resolved  {
+      didInject(resolved)
    }
-    
-    return Injected(value: value, required: required, tag: tag, overrideTag: overrideTag, didInject: didInject)
  }
-
 }

+#if swift(>=5.1)
 /**
 Use this wrapper to identify _weak_ properties of the instance that should be
 auto-injected by `DependencyContainer`. Type T should be a **class** type.
@@ -175,7 +237,7 @@ public final class Injected<T>: _InjectedPropertyBox<T>, AutoInjectedPropertyBox
         For that reason if you resolve instance that has a _weak_ auto-injected property this property
         will be released when `resolve` will complete.
 
- Use `InjectedWeak<T>` to define one of two circular dependecies if another dependency is defined as `Injected<U>`.
+ Use `InjectedWeak<T>` to define one of two circular dependencies if another dependency is defined as `Injected<U>`.
 This will prevent a retain cycle between resolved instances.

 - warning: Do not define this property as optional or container will not be able to inject it.
@@ -185,42 +247,124 @@ public final class Injected<T>: _InjectedPropertyBox<T>, AutoInjectedPropertyBox
 
 ```swift
 class ServiceImp: Service {
-   var client = InjectedWeak<Client>()
+   @InjectedWeak var client: Client?
 }
-
 ```
 
 - seealso: `Injected`
 
 */
-public final class InjectedWeak<T>: _InjectedPropertyBox<T>, AutoInjectedPropertyBox {
+@propertyWrapper
+public struct InjectedWeak<T>: _InjectedPropertyBox, AutoInjectedPropertyBox {

  //Only classes (means AnyObject) can be used as `weak` properties
  //but we can not make <T: AnyObject> because that will prevent using protocol as generic type
  //so we just rely on user reading documentation and passing AnyObject in runtime
  //also we will throw fatal error if type can not be casted to AnyObject during resolution.
-
-  ///The type of wrapped property.
-  public static var wrappedType: Any.Type {
-    return T.self
-  }
-
-  var valueBox: WeakBox<T>? = nil {
-    didSet {
-      if let value = value { didInject(value) }
+  
+  let valueBox: WeakBox<T> = WeakBox(nil)
+  
+  ///Wrapped value.
+  public var wrappedValue: T? {
+    get {
+      return valueBox.value
+    }
+    set {
+      guard (required && newValue != nil) || !required else {
+        fatalError("Can not set required property to nil.")
+      }
+      
+      valueBox.unboxed = newValue as AnyObject
    }
  }
  
+  let required: Bool
+  let didInject: (T) -> ()
+  let tag: DependencyContainer.Tag?
+  let overrideTag: Bool
+  
+  public init(wrappedValue initialValue: T?) {
+    self.init()
+  }
+}
+#else
+/**
+ Use this wrapper to identify _weak_ properties of the instance that should be
+ auto-injected by `DependencyContainer`. Type T should be a **class** type.
+ Otherwise it will cause runtime exception when container will try to resolve the property.
+ Use this wrapper to define one of two circular dependencies to avoid retain cycle.
+ 
+ - note: The only difference between `InjectedWeak` and `Injected` is that `InjectedWeak` uses
+ _weak_ reference to store underlying value, when `Injected` uses _strong_ reference.
+ For that reason if you resolve instance that has a _weak_ auto-injected property this property
+ will be released when `resolve` will complete.
+ 
+ Use `InjectedWeak<T>` to define one of two circular dependencies if another dependency is defined as `Injected<U>`.
+ This will prevent a retain cycle between resolved instances.
+ 
+ - warning: Do not define this property as optional or container will not be able to inject it.
+ Instead define it with initial value of `InjectedWeak<T>()`.
+ 
+ **Example**:
+ 
+ ```swift
+ class ServiceImp: Service {
+   var client = InjectedWeak<Client>()
+ }
+ ```
+ 
+ - seealso: `Injected`
+ 
+ */
+public struct InjectedWeak<T>: _InjectedPropertyBox, AutoInjectedPropertyBox {
+  
+  //Only classes (means AnyObject) can be used as `weak` properties
+  //but we can not make <T: AnyObject> because that will prevent using protocol as generic type
+  //so we just rely on user reading documentation and passing AnyObject in runtime
+  //also we will throw fatal error if type can not be casted to AnyObject during resolution.
+  
+  let valueBox: WeakBox<T> = WeakBox(nil)
+  
  ///Wrapped value.
  public var value: T? {
-    return valueBox?.value
+    return valueBox.value
  }

-  init(value: T?, required: Bool = true, tag: DependencyTagConvertible?, overrideTag: Bool, didInject: @escaping (T) -> ()) {
-    self.valueBox = value.map(WeakBox.init)
-    super.init(required: required, tag: tag, overrideTag: overrideTag, didInject: didInject)
+  let required: Bool
+  let didInject: (T) -> ()
+  let tag: DependencyContainer.Tag?
+  let overrideTag: Bool
+  
+  
+  /// Returns a new wrapper with provided value.
+  func setValue(_ value: T?) -> InjectedWeak {
+    guard (required && value != nil) || !required else {
+      fatalError("Can not set required property to nil.")
+    }
+    
+    return InjectedWeak(value: value, required: required, tag: tag, overrideTag: overrideTag, didInject: didInject)
+  }
+}
+#endif
+
+public extension InjectedWeak {
+  ///The type of wrapped property.
+  static var wrappedType: Any.Type {
+    return T.self
  }
  
+  init(value: T?, required: Bool = true, tag: DependencyTagConvertible?, overrideTag: Bool, didInject: @escaping (T) -> ()) {
+    self.init(required: required, tag: tag, overrideTag: overrideTag, didInject: didInject)
+    self.valueBox.unboxed = value as AnyObject
+  }
+  
+  init(required: Bool = true, tag: DependencyTagConvertible?, overrideTag: Bool, didInject: @escaping (T) -> () = { _ in }) {
+    self.required = required
+    self.tag = tag?.dependencyTag
+    self.overrideTag = overrideTag
+    self.didInject = didInject
+  }
+
  /**
   Creates a new wrapper for weak auto-injected property.
   
@@ -232,46 +376,28 @@ public final class InjectedWeak<T>: _InjectedPropertyBox<T>, AutoInjectedPropert
      - didInject: Block that will be called when concrete instance is injected in this property.
                   Similar to `didSet` property observer. Default value does nothing.
   */
-  public convenience init(required: Bool = true, didInject: @escaping (T) -> () = { _ in }) {
+  init(required: Bool = true, didInject: @escaping (T) -> () = { _ in }) {
    self.init(value: nil, required: required, tag: nil, overrideTag: false, didInject: didInject)
  }
  
-  public convenience init(required: Bool = true, tag: DependencyTagConvertible?, didInject: @escaping (T) -> () = { _ in }) {
+  init(required: Bool = true, tag: DependencyTagConvertible?, didInject: @escaping (T) -> () = { _ in }) {
    self.init(value: nil, required: required, tag: tag, overrideTag: true, didInject: didInject)
  }
  
-  public func resolve(_ container: DependencyContainer) throws {
-    let resolved: T? = try super.resolve(with: container)
-    valueBox = resolved.map(WeakBox.init)
-  }
-
-  /// Returns a new wrapper with provided value.
-  public func setValue(_ value: T?) -> InjectedWeak {
-    guard (required && value != nil) || !required else {
-      fatalError("Can not set required property to nil.")
+  func resolve(_ container: DependencyContainer) throws {
+    let resolved: T? = try self.resolve(with: container, tag: tag, overrideTag: overrideTag, required: required)
+    valueBox.unboxed = resolved as AnyObject
+    if let resolved = resolved  {
+      didInject(resolved)
    }
-    
-    return InjectedWeak(value: value, required: required, tag: tag, overrideTag: overrideTag, didInject: didInject)
  }
-
 }

-public class _InjectedPropertyBox<T> {
+protocol _InjectedPropertyBox {}

-  let required: Bool
-  let didInject: (T) -> ()
-  let tag: DependencyContainer.Tag?
-  let overrideTag: Bool
-
-  init(required: Bool = true, tag: DependencyTagConvertible?, overrideTag: Bool, didInject: @escaping (T) -> () = { _ in }) {
-    self.required = required
-    self.tag = tag?.dependencyTag
-    self.overrideTag = overrideTag
-    self.didInject = didInject
-  }
-
-  func resolve(with container: DependencyContainer) throws -> T? {
-    let tag = overrideTag ? self.tag : container.context.tag
+extension _InjectedPropertyBox {
+  func resolve<T>(with container: DependencyContainer, tag: DependencyContainer.Tag?, overrideTag: Bool, required: Bool) throws -> T? {
+    let tag = overrideTag ? tag : container.context.tag
    do {
      container.context.key = container.context.key.tagged(with: tag)
      let key = DefinitionKey(type: T.self, typeOfArguments: Void.self, tag: tag?.dependencyTag)
@@ -289,12 +415,10 @@ public class _InjectedPropertyBox<T> {
    }
  }
  
-  private func resolve<U>(with container: DependencyContainer, key: DefinitionKey, builder: ((U) throws -> Any) throws -> Any) throws -> Any {
+  func resolve<U>(with container: DependencyContainer, key: DefinitionKey, builder: ((U) throws -> Any) throws -> Any) throws -> Any {
    return try container._resolve(key: key, builder: { definition throws -> Any in
      try builder(definition.weakFactory)
    })
  }
  
 }
-
-
@@ -1,17 +1,5 @@
-#if _runtime(_ObjC)
-  extension String {
-    func has(prefix aPrefix: String) -> Bool {
-      return hasPrefix(aPrefix)
-    }
+extension String {
+  func has(prefix aPrefix: String) -> Bool {
+    return hasPrefix(aPrefix)
  }
-  
-#else
-  
-  extension String {
-    func has(prefix aPrefix: String) -> Bool {
-      return aPrefix ==
-        String(self.characters.prefix(aPrefix.characters.count))
-    }
-
-  }
-#endif
+}
@@ -34,12 +34,14 @@ public struct DefinitionKey: Hashable, CustomStringConvertible {
    self.tag = tag
  }
  
-  public var hashValue: Int {
-    return "\(type)-\(typeOfArguments)-\(tag.desc)".hashValue
+  public func hash(into hasher: inout Hasher) {
+    hasher.combine(ObjectIdentifier(type))
+    hasher.combine(ObjectIdentifier(typeOfArguments))
+    hasher.combine(tag.desc)
  }
  
  public var description: String {
-    return "type: \(type), arguments: \(typeOfArguments), tag: \(tag.desc)"
+    return "type: \(String(reflecting: type)), arguments: \(typeOfArguments), tag: \(tag.desc)"
  }
  
  func tagged(with tag: DependencyContainer.Tag?) -> DefinitionKey {
@@ -53,13 +55,13 @@ public struct DefinitionKey: Hashable, CustomStringConvertible {
    return
      lhs.type == rhs.type &&
      lhs.typeOfArguments == rhs.typeOfArguments &&
-      lhs.tag == rhs.tag
+      lhs.tag.desc == rhs.tag.desc
  }
  
 }

 ///Dummy protocol to store definitions for different types in collection
-public protocol DefinitionType: class { }
+public protocol DefinitionType: AnyObject { }

 /**
 `Definition<T, U>` describes how instances of type `T` should be created when this type is resolved by the `DependencyContainer`.
@@ -126,6 +128,22 @@ public final class Definition<T, U>: DefinitionType {
    return self
  }

+  @discardableResult public func resolvingProperty<Root, V>(_ keyPath: ReferenceWritableKeyPath<Root, V>, as type: Any.Type = V.self, tag: DependencyTagConvertible? = nil) -> Definition {
+    return resolvingProperties { (container, instance) in
+      precondition(instance is Root, "Type of resolved instance \(Swift.type(of: instance)) does not match expected type \(Root.self)")
+      let resolved = try container.resolve(type, tag: tag)
+      precondition(resolved is V, "Type of resolved property \(Swift.type(of: resolved)) does not match expected type \(type)")
+      (instance as! Root)[keyPath: keyPath] = resolved as! V
+    }
+  }
+
+  @discardableResult public func resolvingProperty<Root, V>(_ keyPath: ReferenceWritableKeyPath<Root, V>, factory: @escaping (DependencyContainer) throws -> V = { try $0.resolve() }) -> Definition {
+    return resolvingProperties { (container, instance) in
+      precondition(instance is Root, "Type of resolved instance \(Swift.type(of: instance)) does not match expected type \(Root.self)")
+      (instance as! Root)[keyPath: keyPath] = try factory(container)
+    }
+  }
+
  /**
   Whether container should perform properties auto-injection when resolving using this definition.
   If called will override container configuration. Can be called together with `resolvingProperties`
@@ -188,7 +206,7 @@ public final class Definition<T, U>: DefinitionType {
        
        //definitions for types that can be resolved by `forwardsTo` definition
        //can also be used to resolve self type and it's implementing types
-        //this way container properly reuses previosly resolved instances
+        //this way container properly reuses previously resolved instances
        //when there are several forwarded definitions
        //see testThatItReusesInstanceResolvedByTypeForwarding)
        for definition in forwardsTo.forwardsFrom {
@@ -274,7 +292,7 @@ class DefinitionBuilder<T, U> {

 typealias KeyDefinitionPair = (key: DefinitionKey, definition: _Definition)

-/// Definitions are matched if they are registered for the same tag and thier factories accept the same number of runtime arguments.
+/// Definitions are matched if they are registered for the same tag and their factories accept the same number of runtime arguments.
 private func ~=(lhs: KeyDefinitionPair, rhs: KeyDefinitionPair) -> Bool {
  guard lhs.key.type == rhs.key.type else { return false }
  guard lhs.key.tag == rhs.key.tag else { return false }
@@ -282,9 +300,9 @@ private func ~=(lhs: KeyDefinitionPair, rhs: KeyDefinitionPair) -> Bool {
  return true
 }

-/// Returns key-defintion pairs with definitions able to resolve that type (directly or via type forwarding)
+/// Returns key-definition pairs with definitions able to resolve that type (directly or via type forwarding)
 /// and which tag matches provided key's tag or is nil if strictByTag is false.
-/// In the end filters defintions by type of runtime arguments.
+/// In the end filters definitions by type of runtime arguments.
 func filter(definitions _definitions: [KeyDefinitionPair], byKey key: DefinitionKey, strictByTag: Bool = false, byTypeOfArguments: Bool = false) -> [KeyDefinitionPair] {
  let definitions = _definitions
    .filter({ $0.key.type == key.type || $0.definition.doesImplements(type: key.type) })
@@ -40,6 +40,7 @@ public final class DependencyContainer {
  }

  var autoInjectProperties: Bool
+  var threadSafe: Bool
  internal(set) public var context: Context!
  var definitions = [DefinitionKey: _Definition]()
  var resolvedInstances = ResolvedInstances()
@@ -63,6 +64,7 @@ public final class DependencyContainer {

   - Parameters:
     - autoInjectProperties: Whether container should perform properties auto-injection. Default is `true`.
+     - threadSafe: Whether container should be thread-safe. Default is `true`. You may want to disable it for better performance.
     - configBlock: A configuration block in which you typically put all you `register` calls.
   
   - note: The `configBlock` is simply called at the end of the `init` to let you configure everything. 
@@ -82,8 +84,9 @@ public final class DependencyContainer {
   
   - returns: A new DependencyContainer.
   */
-  public init(autoInjectProperties: Bool = true, configBlock: (DependencyContainer)->() = { _ in }) {
+  public init(autoInjectProperties: Bool = true, threadSafe: Bool = true, configBlock: (DependencyContainer)->() = { _ in }) {
    self.autoInjectProperties = autoInjectProperties
+    self.threadSafe = threadSafe
    configBlock(self)
  }
  
@@ -91,7 +94,7 @@ public final class DependencyContainer {
   Call this method to complete container setup. After container is bootstrapped
   you can not add or remove definitions. Trying to do so will cause runtime exception.
   You can completely reset container, after reset you can bootstrap it again. 
-   During bootsrap container will instantiate components registered with `EagerSingleton` scope.
+   During bootstrap container will instantiate components registered with `EagerSingleton` scope.
   
   - throws: `DipError` if failed to instantiate any component
  */
@@ -104,6 +107,10 @@ public final class DependencyContainer {
  }

  func threadSafe<T>(_ closure: () throws -> T) rethrows -> T {
+    guard threadSafe else {
+      return try closure()
+    }
+
    lock.lock()
    defer { lock.unlock() }
    return try closure()
@@ -291,7 +298,7 @@ extension DependencyContainer {
    for collaborator in _collaborators {
      //if container is already in a context resolving this type
      //it means that it has been already called to resolve this type,
-      //so there is probably a cercular reference between containers.
+      //so there is probably a circular reference between containers.
      //To break it skip this container
      if let context = collaborator.context, context.resolvingType == key.type && context.tag == key.tag { continue }
      
@@ -446,7 +453,7 @@ extension DependencyContainer: CustomStringConvertible {
 //MARK: - DependencyTagConvertible

 /// Implement this protocol on your type if you want to use its instances as `DependencyContainer`'s tags.
-/// `DependencyContainer.Tag`, `String`, `Int` and any `RawRepresentable` with `RawType` of `String` or `Int` by default confrom to this protocol.
+/// `DependencyContainer.Tag`, `String`, `Int` and any `RawRepresentable` with `RawType` of `String` or `Int` by default conform to this protocol.
 public protocol DependencyTagConvertible {
  var dependencyTag: DependencyContainer.Tag { get }
 }
@@ -66,7 +66,7 @@ public enum DipError: Error, CustomStringConvertible {
  case ambiguousDefinitions(type: Any.Type, definitions: [DefinitionType])
  
  /**
-   Thrown by `resolve(tag:)` if resolved instance does not implemenet resolved type (i.e. when type-forwarding).
+   Thrown by `resolve(tag:)` if resolved instance does not implement resolved type (i.e. when type-forwarding).
   
   - parameters:
      - resolved: Resolved instance
@@ -77,18 +77,16 @@ public enum DipError: Error, CustomStringConvertible {
  public var description: String {
    switch self {
    case let .definitionNotFound(key):
-      return "No definition registered for \(key).\nCheck the tag, type you try to resolve, number, order and types of runtime arguments passed to `resolve()` and match them with registered factories for type \(key.type)."
+      return "No definition registered for \(key).\nCheck the tag, type you try to resolve, number, order and types of runtime arguments passed to `resolve()` and match them with registered factories for type \(String(reflecting: key.type))."
    case let .autoInjectionFailed(label, type, error):
-      return "Failed to auto-inject property \"\(label.desc)\" of type \(type). \(error)"
+      return "Failed to auto-inject property \"\(label.desc)\" of type \(String(reflecting: type)). \(error)"
    case let .autoWiringFailed(type, error):
-      return "Failed to auto-wire type \"\(type)\". \(error)"
+      return "Failed to auto-wire type \"\(String(reflecting: type))\". \(error)"
    case let .ambiguousDefinitions(type, definitions):
-      return "Ambiguous definitions for \(type):\n" +
+      return "Ambiguous definitions for \(String(reflecting: type)):\n" +
        definitions.map({ "\($0)" }).joined(separator: ";\n")
    case let .invalidType(resolved, key):
-      return "Resolved instance \(resolved ?? "nil") does not implement expected type \(key.type)."
+      return "Resolved instance \(resolved ?? "nil") does not implement expected type \(String(reflecting: key.type))."
    }
  }
-  
 }
-
@@ -81,7 +81,7 @@ extension DependencyContainer {
   
   - parameters:
      - tag: The arbitrary tag to use to lookup definition.
-      - builder: Generic closure that accepts generic factory and returns inctance created by that factory.
+      - builder: Generic closure that accepts generic factory and returns instance created by that factory.
   
   - throws: `DipError.DefinitionNotFound`, `DipError.AutoInjectionFailed`, `DipError.AmbiguousDefinitions`, `DipError.InvalidType`
   
@@ -183,7 +183,7 @@ extension DependencyContainer {
      return previouslyResolved
    }
    
-    log(level: .Verbose, context)
+    if let context = context { log(level: .Verbose, context) }
    var resolvedInstance = try builder(definition)
    
    /*
@@ -98,7 +98,7 @@ extension DependencyContainer {
   }
   ```
   
-   Though before you do so you should probably review your design and try to reduce number of depnedencies.
+   Though before you do so you should probably review your design and try to reduce number of dependencies.
   */
  public func register<T, U>(scope: ComponentScope, type: T.Type, tag: DependencyTagConvertible?, factory: @escaping (U) throws -> T, numberOfArguments: Int, autoWiringFactory: @escaping (DependencyContainer, Tag?) throws -> T) -> Definition<T, U> {
    let definition = DefinitionBuilder<T, U> {
@@ -141,7 +141,7 @@ extension DependencyContainer {
           which factories accept any number of runtime arguments and are tagged with the same tag,
           passed to `resolve` method, or with no tag. Container will try to use these definitions
           to resolve a component one by one until one of them succeeds, starting with tagged definitions
-           in order of decreasing their's factories number of arguments. If none of them succeds it will
+           in order of decreasing their's factories number of arguments. If none of them succeeds it will
           throw an error. If it finds two definitions with the same number of arguments - it will throw
           an error.
   
@@ -22,7 +22,7 @@
 // THE SOFTWARE.
 //

-#if (canImport(UIKit) || canImport(AppKit) || canImport(WatchKit)) && !SWIFT_PACKAGE
+#if (canImport(UIKit) || canImport(AppKit) || canImport(WatchKit))

 extension DependencyContainer {
  ///Containers that will be used to resolve dependencies of instances, created by stroyboards.
@@ -56,6 +56,13 @@ class Box<T> {
  }
 }

+class NullableBox<T> {
+    var unboxed: T?
+    init(_ value: T?) {
+        self.unboxed = value
+    }
+}
+
 protocol WeakBoxType {
  var unboxed: AnyObject? { get }
 }
@@ -66,15 +73,8 @@ class WeakBox<T>: WeakBoxType {
    return unboxed as? T
  }

-  init(_ value: T) {
-    #if _runtime(_ObjC)
-      weak var value: AnyObject? = value as AnyObject
-    #else
-      weak var value: AnyObject? = value as? AnyObject
-    #endif
-    guard value != nil else {
-      fatalError("Can not store weak reference to not a class instance (\(T.self))")
-    }
+  init(_ value: T?) {
+    weak var value: AnyObject? = value as AnyObject
    self.unboxed = value
  }
 }
@@ -25,16 +25,44 @@
 import XCTest
@testable import Dip

-private protocol Server: class {
+private protocol Server: AnyObject {
  var client: Client! {get}
  var anotherClient: Client! {get set}
 }

-private protocol Client: class {
+private protocol Client: AnyObject {
  var server: Server? {get}
  var anotherServer: Server! {get set}
 }

+#if swift(>=5.1)
+private class ServerImp: Server {
+  
+  @InjectedWeak(didInject: { _ in
+    AutoInjectionTests.clientDidInjectCalled = true
+  }) var client: Client!
+  
+  @InjectedWeak(required: false) var _optionalProperty: AnyObject?
+  
+  weak var anotherClient: Client!
+}
+
+private class ClientImp: Client {
+  
+  @Injected(didInject: { _ in
+    AutoInjectionTests.serverDidInjectCalled = true
+  }) var server: Server
+  
+  @Injected(required: false) var _optionalProperty: AnyObject?
+  
+  @Injected(tag: "tagged") var taggedServer: Server
+  @Injected(tag: nil) var nilTaggedServer: Server
+  
+  var anotherServer: Server!
+}
+
+#else
+
 private class ServerImp: Server {
  
  var _client = InjectedWeak<Client>() { _ in
@@ -67,7 +95,18 @@ private class ClientImp: Client {
  var taggedServer = Injected<Server>(tag: "tagged")
  var nilTaggedServer = Injected<Server>(tag: nil)
 }
+#endif

+#if swift(>=5.1)
+private class Obj1 {
+  @InjectedWeak var obj2: Obj2?
+  @Injected var obj3: Obj3?
+}
+
+private class Obj2 {
+  @Injected var obj1: Obj1?
+}
+#else
 private class Obj1 {
  let obj2 = InjectedWeak<Obj2>()
  let obj3 = Injected<Obj3>()
@@ -76,6 +115,7 @@ private class Obj1 {
 private class Obj2 {
  let obj1 = Injected<Obj1>()
 }
+#endif

 private class Obj3 {
  
@@ -92,29 +132,6 @@ class AutoInjectionTests: XCTestCase {
  static var clientDidInjectCalled: Bool = false

  let container = DependencyContainer()
-  
-  static var allTests = {
-    return [
-      ("testThatItResolvesAutoInjectedDependencies", testThatItResolvesAutoInjectedDependencies),
-      ("testThatItResolvesInheritedDependencies", testThatItResolvesInheritedDependencies),
-      ("testThatItCanSetInjectedProperty", testThatItCanSetInjectedProperty),
-      ("testThatItThrowsErrorIfFailsToAutoInjectDependency", testThatItThrowsErrorIfFailsToAutoInjectDependency),
-      ("testThatItResolvesAutoInjectedSingletons", testThatItResolvesAutoInjectedSingletons),
-      ("testThatItCallsResolveDependencyBlockWhenAutoInjecting", testThatItCallsResolveDependencyBlockWhenAutoInjecting),
-      ("testThatItReusesResolvedAutoInjectedInstances", testThatItReusesResolvedAutoInjectedInstances),
-      ("testThatItReusesAutoInjectedInstancesOnNextResolveOrAutoInjection", testThatItReusesAutoInjectedInstancesOnNextResolveOrAutoInjection),
-      ("testThatThereIsNoRetainCycleBetweenAutoInjectedCircularDependencies", testThatThereIsNoRetainCycleBetweenAutoInjectedCircularDependencies),
-      ("testThatItCallsDidInjectOnAutoInjectedProperty", testThatItCallsDidInjectOnAutoInjectedProperty),
-      ("testThatNoErrorThrownWhenOptionalPropertiesAreNotAutoInjected", testThatNoErrorThrownWhenOptionalPropertiesAreNotAutoInjected),
-      ("testThatItResolvesTaggedAutoInjectedProperties", testThatItResolvesTaggedAutoInjectedProperties),
-      ("testThatItPassesTagToAutoInjectedProperty", testThatItPassesTagToAutoInjectedProperty),
-      ("testThatItDoesNotPassTagToAutoInjectedPropertyWithExplicitTag", testThatItDoesNotPassTagToAutoInjectedPropertyWithExplicitTag),
-      ("testThatItAutoInjectsPropertyWithCollaboratingContainer", testThatItAutoInjectsPropertyWithCollaboratingContainer),
-      ("testThatItDoesNotAutoInjectIfDisabled", testThatItDoesNotAutoInjectIfDisabledInDefinition),
-      ("testThatItDoesNotAutoInjectIfDisabledInContainer", testThatItDoesNotAutoInjectIfDisabledInContainer),
-      ("testThatItAutoInjectsWhenOverridenInDefinition", testThatItAutoInjectsWhenOverridenInDefinition),
-    ]
-  }()

  override func setUp() {
    container.reset()
@@ -131,10 +148,18 @@ class AutoInjectionTests: XCTestCase {
  
  func testThatItResolvesInheritedDependencies() {
    class ServerImp2: ServerImp {
+      #if swift(>=5.1)
+      @InjectedWeak(didInject: { _ in
+        XCTAssertTrue(AutoInjectionTests.serverDidInjectCalled, "Inherited properties should be resolved first")
+      }) var client2: Client?
+      #else
      var _client2 = InjectedWeak<Client>() { _ in
        XCTAssertTrue(AutoInjectionTests.serverDidInjectCalled, "Inherited properties should be resolved first")
      }
-      var client2: Client? { return _client2.value }
+      var client2: Client? {
+        return _client2.value
+      }
+      #endif
    }

    container.register { ServerImp2() as Server }
@@ -156,17 +181,23 @@ class AutoInjectionTests: XCTestCase {
    
    let newServer = ServerImp()
    let newClient = ClientImp()
+    #if swift(>=5.1)
+    client.server = newServer
+    server.client = newClient
+    #else
    client._server = client._server.setValue(newServer)
    server._client = server._client.setValue(newClient)
+    #endif
    
    XCTAssertTrue(client.server === newServer)
    XCTAssertTrue(server.client === newClient)
  }
-  
+    
+
  func testThatItThrowsErrorIfFailsToAutoInjectDependency() {
    container.register { ClientImp() as Client }
    
-    AssertThrows(expression: try container.resolve() as Client)
+    XCTAssertThrowsError(try self.container.resolve() as Client)
  }

  func testThatItResolvesAutoInjectedSingletons() {
@@ -248,11 +279,19 @@ class AutoInjectionTests: XCTestCase {
    let obj2 = try! container.resolve() as Obj2
    
    //then
-    XCTAssertTrue(obj2 === obj2.obj1.value!.obj2.value!,
+    #if swift(>=5.1)
+    XCTAssertTrue(obj2 === obj2.obj1!.obj2!,
      "Auto-injected instance should be reused on next auto-injection")
    
-    XCTAssertTrue(obj2.obj1.value! === obj2.obj1.value!.obj3.value!.obj1,
+    XCTAssertTrue(obj2.obj1! === obj2.obj1!.obj3!.obj1,
      "Auto-injected instance should be reused on next resolve")
+    #else
+    XCTAssertTrue(obj2 === obj2.obj1.value!.obj2.value!,
+                  "Auto-injected instance should be reused on next auto-injection")
+    
+    XCTAssertTrue(obj2.obj1.value! === obj2.obj1.value!.obj3.value!.obj1,
+                  "Auto-injected instance should be reused on next resolve")
+    #endif
  }
  
  func testThatThereIsNoRetainCycleBetweenAutoInjectedCircularDependencies() {
@@ -297,7 +336,10 @@ class AutoInjectionTests: XCTestCase {
    container.register { ServerImp() as Server }
    container.register { ClientImp() as Client }

-    AssertNoThrow(expression: try container.resolve() as Client, "Container should not throw error if failed to resolve optional auto-injected properties.")
+    XCTAssertNoThrow(
+      try container.resolve() as Client,
+      "Container should not throw error if failed to resolve optional auto-injected properties."
+    )
  }
  
  func testThatItResolvesTaggedAutoInjectedProperties() {
@@ -310,7 +352,11 @@ class AutoInjectionTests: XCTestCase {
    let client = try! container.resolve() as Client
    
    //then
+    #if swift(>=5.1)
+    let taggedServer = (client as! ClientImp).taggedServer!
+    #else
    let taggedServer = (client as! ClientImp).taggedServer.value!
+    #endif
    let server = client.server!
    
    //server and tagged server should be resolved as different instances
@@ -329,7 +375,11 @@ class AutoInjectionTests: XCTestCase {
    let client = try! container.resolve(tag: "tagged") as Client
    
    //then
+    #if swift(>=5.1)
+    let taggedServer = (client as! ClientImp).taggedServer!
+    #else
    let taggedServer = (client as! ClientImp).taggedServer.value!
+    #endif
    let server = client.server!
    
    //server and tagged server should be resolved as the same instance
@@ -350,8 +400,13 @@ class AutoInjectionTests: XCTestCase {
    let client = try! container.resolve(tag: "otherTag") as Client
    
    //then
+    #if swift(>=5.1)
+    let taggedServer = (client as! ClientImp).taggedServer!
+    let nilTaggedServer = (client as! ClientImp).nilTaggedServer!
+    #else
    let taggedServer = (client as! ClientImp).taggedServer.value!
    let nilTaggedServer = (client as! ClientImp).nilTaggedServer.value!
+    #endif
    let server = client.server!
    
    //server and tagged server should be resolved as different instances
@@ -362,15 +417,50 @@ class AutoInjectionTests: XCTestCase {
    XCTAssertNotNil(taggedServer)
    XCTAssertNotNil(nilTaggedServer)
  }
-  
+
+
+  struct Foo
+  {
+    struct Bar
+    {
+
+    }
+  }
+
+  struct Baz
+  {
+    struct Bar
+    {
+
+    }
+  }
+
+
+  func testScopedTypes() {
+    let key1 = DefinitionKey(type: Baz.Bar.self, typeOfArguments: Void.self)
+    let key2 = DefinitionKey(type: Foo.Bar.self, typeOfArguments: Void.self)
+
+    XCTAssertNotEqual(key1, key2)
+    XCTAssertNotEqual(key1.hashValue, key2.hashValue)
+
+    container.register { Baz.Bar() }
+
+    XCTAssertNotNil(try? container.resolve() as Baz.Bar)
+    XCTAssertThrowsError(try container.resolve() as Foo.Bar)
+
+    container.register { Foo.Bar() }
+
+    XCTAssertNotNil(try? container.resolve() as Foo.Bar)
+  }
+
  func testThatItAutoInjectsPropertyWithCollaboratingContainer() {
    let collaborator = DependencyContainer()
    collaborator.register { ServerImp() as Server }
    container.register { ClientImp() as Client }
-    
+
    container.collaborate(with: collaborator)
    collaborator.collaborate(with: container)
-    
+
    let client = try! container.resolve() as Client
    let server = client.server
    XCTAssertTrue(client === server?.client)
@@ -398,7 +488,7 @@ class AutoInjectionTests: XCTestCase {
    XCTAssertNil(server)
  }

-  func testThatItAutoInjectsWhenOverridenInDefinition() {
+  func testThatItAutoInjectsWhenOverriddenInDefinition() {
    let container = DependencyContainer(autoInjectProperties: false)
    container.register { ServerImp() as Server }
    container.register { ClientImp() as Client }
@@ -25,12 +25,12 @@
 import XCTest
@testable import Dip

-private protocol Service: class { }
+private protocol Service: AnyObject { }
 private class ServiceImp1: Service { }
 private class ServiceImp2: Service { }
 private class ServiceImp3 {}

-private protocol AutoWiredClient: class {
+private protocol AutoWiredClient: AnyObject {
  var service1: Service! { get set }
  var service2: Service! { get set }
 }
@@ -50,30 +50,6 @@ class AutoWiringTests: XCTestCase {
  
  let container = DependencyContainer()

-  static var allTests = {
-    return [
-      ("testThatItCanResolveWithAutoWiring", testThatItCanResolveWithAutoWiring),
-      ("testThatItUsesAutoWireFactoryWithMostNumberOfArguments", testThatItUsesAutoWireFactoryWithMostNumberOfArguments),
-      ("testThatItThrowsAmbiguityErrorWhenUsingAutoWire", testThatItThrowsAmbiguityErrorWhenUsingAutoWire),
-      ("testThatItUsesAutoWireFactoryWithMostNumberOfArguments", testThatItUsesAutoWireFactoryWithMostNumberOfArguments),
-      ("testThatItPrefersTaggedFactoryWithDifferentNumberOfArgumentsWhenUsingAutoWire", testThatItPrefersTaggedFactoryWithDifferentNumberOfArgumentsWhenUsingAutoWire),
-      ("testThatItPrefersTaggedFactoryWithDifferentTypesOfArgumentsWhenUsingAutoWire", testThatItPrefersTaggedFactoryWithDifferentTypesOfArgumentsWhenUsingAutoWire),
-      ("testThatItFallbackToNotTaggedFactoryWhenUsingAutoWire", testThatItFallbackToNotTaggedFactoryWhenUsingAutoWire),
-      ("testThatItDoesNotTryToUseAutoWiringWhenCallingResolveWithArguments", testThatItDoesNotTryToUseAutoWiringWhenCallingResolveWithArguments),
-      ("testThatItDoesNotUseAutoWiringWhenFailedToResolveLowLevelDependency", testThatItDoesNotUseAutoWiringWhenFailedToResolveLowLevelDependency),
-      ("testThatItReusesInstancesResolvedWithAutoWiringWhenUsingAutoWiringAgain", testThatItReusesInstancesResolvedWithAutoWiringWhenUsingAutoWiringAgain),
-      ("testThatItReusesInstancesResolvedWithAutoWiringWhenUsingAutoWiringAgainWithTheSameTag", testThatItReusesInstancesResolvedWithAutoWiringWhenUsingAutoWiringAgainWithTheSameTag),
-      ("testThatItDoesNotReuseInstancesResolvedWithAutoWiringWhenUsingAutoWiringAgainWithAnotherTag", testThatItDoesNotReuseInstancesResolvedWithAutoWiringWhenUsingAutoWiringAgainWithAnotherTag),
-      ("testThatItUsesTagToResolveDependenciesWithAutoWiringWith1Argument", testThatItUsesTagToResolveDependenciesWithAutoWiringWith1Argument),
-      ("testThatItUsesTagToResolveDependenciesWithAutoWiringWith2Arguments", testThatItUsesTagToResolveDependenciesWithAutoWiringWith2Arguments),
-      ("testThatItUsesTagToResolveDependenciesWithAutoWiringWith3Arguments", testThatItUsesTagToResolveDependenciesWithAutoWiringWith3Arguments),
-      ("testThatItUsesTagToResolveDependenciesWithAutoWiringWith4Arguments", testThatItUsesTagToResolveDependenciesWithAutoWiringWith4Arguments),
-      ("testThatItUsesTagToResolveDependenciesWithAutoWiringWith5Arguments", testThatItUsesTagToResolveDependenciesWithAutoWiringWith5Arguments),
-      ("testThatItUsesTagToResolveDependenciesWithAutoWiringWith6Arguments", testThatItUsesTagToResolveDependenciesWithAutoWiringWith6Arguments),
-      ("testThatItCanAutoWireOptional", testThatItCanAutoWireOptional)
-    ]
-  }()
-
  override func setUp() {
    container.reset()
  }
@@ -138,12 +114,10 @@ class AutoWiringTests: XCTestCase {
    container.register { ServiceImp2() }
    
    //when
-    AssertThrows(expression: try container.resolve() as AutoWiredClient) { error -> Bool in
-      switch error {
-      case let DipError.autoWiringFailed(_, error):
-        if case DipError.ambiguousDefinitions = error { return true }
-        else { return false }
-      default: return false
+    XCTAssertThrowsError(try self.container.resolve() as AutoWiredClient) { (error) in
+      guard case DipError.autoWiringFailed(_, DipError.ambiguousDefinitions) = error else {
+        XCTFail("Thrown unexpected error: \(error)")
+        return
      }
    }
  }
@@ -233,8 +207,12 @@ class AutoWiringTests: XCTestCase {
    
    //when
    let service = try! container.resolve() as Service
-    AssertThrows(expression: try container.resolve(arguments: service) as AutoWiredClient,
-      "Container should not use auto-wiring when resolving with runtime arguments")
+    
+    // then
+    XCTAssertThrowsError(
+      try self.container.resolve(arguments: service) as AutoWiredClient,
+      "Container should not use auto-wiring when resolving with runtime arguments"
+    )
  }
  
  func testThatItDoesNotUseAutoWiringWhenFailedToResolveLowLevelDependency() {
@@ -259,12 +237,13 @@ class AutoWiringTests: XCTestCase {
    container.register { ServiceImp2() }
    
    //then
-    AssertThrows(expression: try container.resolve() as AutoWiredClient,
-      "Container should not use auto-wiring when definition for resolved type is registered.")
+    XCTAssertThrowsError(
+      try self.container.resolve() as AutoWiredClient,
+      "Container should not use auto-wiring when definition for resolved type is registered."
+    )
  }
  
  func testThatItReusesInstancesResolvedWithAutoWiringWhenUsingAutoWiringAgain() {
-    
    //given
    container.register { ServiceImp1() as Service }
    container.register { ServiceImp2() }
@@ -282,8 +261,10 @@ class AutoWiringTests: XCTestCase {
    let resolved = try! container.resolve() as AutoWiredClient
    
    //then
-    //when doing another auto-wiring during resolve we should reuse instance
-    XCTAssertTrue((resolved as! AutoWiredClientImp) === (anotherInstance as! AutoWiredClientImp))
+    XCTAssertTrue(
+      (resolved as! AutoWiredClientImp) === (anotherInstance as! AutoWiredClientImp),
+      "when doing another auto-wiring during resolve we should reuse instance"
+    )
  }
  
  func testThatItReusesInstancesResolvedWithoutAutoWiringWhenUsingAutoWiringAgain() {
@@ -307,8 +288,10 @@ class AutoWiringTests: XCTestCase {
    let resolved = try! container.resolve(arguments: service1, service2) as AutoWiredClient
    
    //then
-    //when doing another auto-wiring during resolve we should reuse instance
-    XCTAssertTrue((resolved as! AutoWiredClientImp) === (anotherInstance as! AutoWiredClientImp))
+    XCTAssertTrue(
+      (resolved as! AutoWiredClientImp) === (anotherInstance as! AutoWiredClientImp),
+      "when doing another auto-wiring during resolve we should reuse instance"
+    )
  }

  func testThatItReusesInstancesResolvedWithAutoWiringWhenUsingAutoWiringAgainWithTheSameTag() {
@@ -330,8 +313,10 @@ class AutoWiringTests: XCTestCase {
    let resolved = try! container.resolve(tag: "tag") as AutoWiredClient
    
    //then
-    //when doing another auto-wiring during resolve we should reuse instance
-    XCTAssertTrue((resolved as! AutoWiredClientImp) === (anotherInstance as! AutoWiredClientImp))
+    XCTAssertTrue(
+      (resolved as! AutoWiredClientImp) === (anotherInstance as! AutoWiredClientImp),
+      "when doing another auto-wiring during resolve we should reuse instance"
+    )
  }
  
  func testThatItDoesNotReuseInstancesResolvedWithAutoWiringWhenUsingAutoWiringAgainWithAnotherTag() {
@@ -353,8 +338,10 @@ class AutoWiringTests: XCTestCase {
    let resolved = try! container.resolve(tag: "tag") as AutoWiredClient
    
    //then
-    //when doing another auto-wiring during resolve we should reuse instance
-    XCTAssertTrue((resolved as! AutoWiredClientImp) !== (anotherInstance as! AutoWiredClientImp))
+    XCTAssertTrue(
+      (resolved as! AutoWiredClientImp) !== (anotherInstance as! AutoWiredClientImp),
+      "when doing another auto-wiring during resolve we should reuse instance"
+    )
  }
  
  func testThatItUsesTagToResolveDependenciesWithAutoWiringWith1Argument() {
@@ -464,11 +451,11 @@ class AutoWiringTests: XCTestCase {
    
    var resolved: AutoWiredClient?
    //when
-    AssertNoThrow(expression: resolved = try container.resolve() as AutoWiredClient?)
+    XCTAssertNoThrow(resolved = try self.container.resolve() as AutoWiredClient?)
    XCTAssertNotNil(resolved)
    
    //when
-    AssertNoThrow(expression: resolved = try container.resolve(tag: "tag") as AutoWiredClient?)
+    XCTAssertNoThrow(resolved = try self.container.resolve(tag: "tag") as AutoWiredClient?)
    XCTAssertNotNil(resolved)
  }
  
@@ -25,7 +25,7 @@
 import XCTest
@testable import Dip

-private protocol Service: class {}
+private protocol Service: AnyObject {}
 private class ServiceImp1: Service {}
 private class ServiceImp2: Service {}

@@ -47,27 +47,6 @@ class ComponentScopeTests: XCTestCase {
  
  let container = DependencyContainer()
  
-  static var allTests = {
-    return [
-      ("testThatSharedIsDefaultScope", testThatSharedIsDefaultScope),
-      ("testThatScopeCanBeChanged", testThatScopeCanBeChanged),
-      ("testThatItResolvesTypeAsNewInstanceForUniqueScope", testThatItResolvesTypeAsNewInstanceForUniqueScope),
-      ("testThatItReusesInstanceForSingletonScope", testThatItReusesInstanceForSingletonScope),
-      ("testThatSingletonIsNotReusedAcrossContainers", testThatSingletonIsNotReusedAcrossContainers),
-      ("testThatSingletonIsReleasedWhenDefinitionIsRemoved", testThatSingletonIsReleasedWhenDefinitionIsRemoved),
-      ("testThatSingletonIsReleasedWhenDefinitionIsOverridden", testThatSingletonIsReleasedWhenDefinitionIsOverridden),
-      ("testThatSingletonIsReleasedWhenContainerIsReset", testThatSingletonIsReleasedWhenContainerIsReset),
-      ("testThatItReusesInstanceInSharedScopeDuringResolve", testThatItReusesInstanceInSharedScopeDuringResolve),
-      ("testThatItDoesNotReuseInstanceInSharedScopeInNextResolve", testThatItDoesNotReuseInstanceInSharedScopeInNextResolve),
-      ("testThatItDoesNotReuseInstanceInSharedScopeResolvedForNilTag", testThatItDoesNotReuseInstanceInSharedScopeResolvedForNilTagWhenResolvingForAnotherTag),
-      ("testThatItReusesInstanceInSharedScopeResolvedForNilTag", testThatItReusesInstanceInSharedScopeResolvedForNilTag),
-      ("testThatItReusesResolvedInstanceWhenResolvingOptional", testThatItReusesResolvedInstanceWhenResolvingOptional),
-      ("testThatItHoldsWeakReferenceToWeakSingletonInstance", testThatItHoldsWeakReferenceToWeakSingletonInstance),
-      ("testThatItResolvesWeakSingletonAgainAfterItWasReleased", testThatItResolvesWeakSingletonAgainAfterItWasReleased),
-      ("testThatCollaboratingContainersReuseSingletonsResolvedByAnotherContainer", testThatCollaboratingContainersReuseSingletonsResolvedByAnotherContainer)
-    ]
-  }()
-  
  override func setUp() {
    container.reset()
  }
@@ -337,11 +316,14 @@ class ComponentScopeTests: XCTestCase {
    container.register(service, type: Service.self)
    
    //when
-    //resolve and realease reight away
+    //resolve and release right away
    _ = try? container.resolve() as ServiceImp1
    
    //then
-    AssertNoThrow(expression: try container.resolve() as Service, "Weak singleton should be resolved again.")
+    XCTAssertNoThrow(
+      try container.resolve() as Service,
+      "Weak singleton should be resolved again."
+    )
  }
  
  func testThatCollaboratingContainersReuseSingletonsResolvedByAnotherContainer() {
@@ -39,20 +39,6 @@ class ContextTests: XCTestCase {

  let container = DependencyContainer()
  
-  static var allTests = {
-    return [
-      ("testThatContextStoresCurrentlyResolvedType", testThatContextStoresCurrentlyResolvedType),
-      ("testThatContextStoresInjectedInType", testThatContextStoresInjectedInType),
-      ("testThatContextStoresTheTagPassedToResolve", testThatContextStoresTheTagPassedToResolve),
-      ("testThatContextStoresTheTagPassedToResolveWhenAutoInjecting", testThatContextStoresTheTagPassedToResolveWhenAutoInjecting),
-      ("testThatContextStoresTheTagPassedToResolveWhenAutoWiring", testThatContextStoresTheTagPassedToResolveWhenAutoWiring),
-      ("testThatContextDoesNotOverrideNilTagPassedToResolve", testThatContextDoesNotOverrideNilTagPassedToResolve),
-      ("testThatContextStoresNameOfAutoInjectedProperty", testThatContextStoresNameOfAutoInjectedProperty),
-      ("testThatItDoesNotSetInjectedInTypeWhenResolvingWithCollaboration", testThatItDoesNotSetInjectedInTypeWhenResolvingWithCollaboration),
-      ("testThatContextIsPreservedWhenResolvingWithCollaboration", testThatContextIsPreservedWhenResolvingWithCollaboration)
-    ]
-  }()
-  
  override func setUp() {
    container.reset()
    container.register { ServiceImp2() }
@@ -36,18 +36,6 @@ class DefinitionTests: XCTestCase {
  let tag1 = DependencyContainer.Tag.String("tag1")
  let tag2 = DependencyContainer.Tag.String("tag2")
  
-  static var allTests = {
-    return [
-      ("testThatDefinitionKeyIsEqualBy_Type_Factory_Tag", testThatDefinitionKeyIsEqualBy_Type_Factory_Tag),
-      ("testThatDefinitionKeysWithDifferentTypesAreNotEqual", testThatDefinitionKeysWithDifferentTypesAreNotEqual),
-      ("testThatDefinitionKeysWithDifferentFactoriesAreNotEqual", testThatDefinitionKeysWithDifferentFactoriesAreNotEqual),
-      ("testThatDefinitionKeysWithDifferentTagsAreNotEqual", testThatDefinitionKeysWithDifferentTagsAreNotEqual),
-      ("testThatResolveDependenciesCallsResolveDependenciesBlock", testThatResolveDependenciesCallsResolveDependenciesBlock),
-      ("testThatResolveDependenciesBlockIsNotCalledWhenPassedWrongInstance", testThatResolveDependenciesBlockIsNotCalledWhenPassedWrongInstance),
-      ("testThatItRegisteresOptionalTypesAsForwardedTypes", testThatItRegisteresOptionalTypesAsForwardedTypes)
-    ]
-  }()
-
  func testThatDefinitionKeyIsEqualBy_Type_Factory_Tag() {
    let equalKey1 = DefinitionKey(type: Service.self, typeOfArguments: F1.self, tag: tag1)
    let equalKey2 = DefinitionKey(type: Service.self, typeOfArguments: F1.self, tag: tag1)
@@ -112,7 +100,7 @@ class DefinitionTests: XCTestCase {
    XCTAssertFalse(blockCalled)
  }
  
-  func testThatItRegisteresOptionalTypesAsForwardedTypes() {
+  func testThatItRegistersOptionalTypesAsForwardedTypes() {
    let def = Definition<Service, ()>(scope: .unique) { ServiceImp() as Service }
    
    XCTAssertTrue(def.implementingTypes.contains(where: { $0 == Service?.self }))
@@ -25,14 +25,14 @@
 import XCTest
@testable import Dip

-private protocol Service: class { }
+private protocol Service: AnyObject { }
 private class ServiceImp1: Service { }
 private class ServiceImp2: Service { }

-private protocol Server: class {
+private protocol Server: AnyObject {
  var client: Client! { get }
 }
-private protocol Client: class {
+private protocol Client: AnyObject {
  var server: Server! { get }
 }

@@ -49,31 +49,6 @@ class DipTests: XCTestCase {

  let container = DependencyContainer()

-  static var allTests = {
-    return [
-      ("testThatCreatingContainerWithConfigBlockDoesNotCreateRetainCycle", testThatCreatingContainerWithConfigBlockDoesNotCreateRetainCycle),
-      ("testThatItResolvesInstanceRegisteredWithoutTag", testThatItResolvesInstanceRegisteredWithoutTag),
-      ("testThatItResolvesInstanceRegisteredWithTag", testThatItResolvesInstanceRegisteredWithTag),
-      ("testThatItResolvesDifferentInstancesRegisteredForDifferentTags", testThatItResolvesDifferentInstancesRegisteredForDifferentTags),
-      ("testThatNewRegistrationOverridesPreviousRegistration", testThatNewRegistrationOverridesPreviousRegistration),
-      ("testThatItCallsResolveDependenciesOnDefinition", testThatItCallsResolveDependenciesOnDefinition),
-      ("testThatItThrowsErrorIfCanNotFindDefinitionForType", testThatItThrowsErrorIfCanNotFindDefinitionForType),
-      ("testThatItThrowsErrorIfCanNotFindDefinitionForTag", testThatItThrowsErrorIfCanNotFindDefinitionForTag),
-      ("testThatItThrowsErrorIfCanNotFindDefinitionForFactoryWithArguments", testThatItThrowsErrorIfCanNotFindDefinitionForFactoryWithArguments),
-      ("testThatItThrowsErrorIfConstructorThrows", testThatItThrowsErrorIfConstructorThrows),
-      ("testThatItThrowsErrorIfFailsToResolveDependency", testThatItThrowsErrorIfFailsToResolveDependency),
-      ("testThatItCallsDidResolveDependenciesOnResolvableIntance", testThatItCallsDidResolveDependenciesOnResolvableIntance),
-      ("testThatItCallsDidResolveDependenciesInReverseOrder", testThatItCallsDidResolveDependenciesInReverseOrder),
-      ("testItCallsResolveDependenciesOnResolableInstance", testItCallsResolveDependenciesOnResolableInstance),
-      ("testThatItResolvesCircularDependencies", testThatItResolvesCircularDependencies),
-      ("testThatItCanResolveUsingContainersCollaboration", testThatItCanResolveUsingContainersCollaboration),
-      ("testThatCollaboratingWithSelfIsIgnored", testThatCollaboratingWithSelfIsIgnored),
-      ("testThatCollaboratingContainersAreWeakReferences", testThatCollaboratingContainersAreWeakReferences),
-      ("testThatCollaboratingContainersReuseInstancesResolvedByAnotherContainer", testThatCollaboratingContainersReuseInstancesResolvedByAnotherContainer),
-      ("testThatItCanHandleSeparateContainersAndTheirCollaboration", testThatItCanHandleSeparateContainersAndTheirCollaboration)
-    ]
-  }()
-
  override func setUp() {
    container.reset()
  }
@@ -229,25 +204,27 @@ class DipTests: XCTestCase {
    container.register { ServiceImp1() as ServiceImp1 }
    
    //when
-    AssertThrows(expression: try container.resolve() as Service) { error in
-      guard case let DipError.definitionNotFound(key) = error else { return false }
+    XCTAssertThrowsError(try self.container.resolve() as Service) { error in
+      guard case let DipError.definitionNotFound(key) = error else {
+        XCTFail("Thrown unexpected error: \(error)")
+        return
+      }
      
      //then
      let expectedKey = DefinitionKey(type: Service.self, typeOfArguments: Void.self, tag: nil)
      XCTAssertEqual(key, expectedKey)
-
-      return true
    }

    //and when
-    AssertThrows(expression: try container.resolve(Service.self)) { error in
-      guard case let DipError.definitionNotFound(key) = error else { return false }
+    XCTAssertThrowsError(try self.container.resolve(Service.self)) { error in
+      guard case let DipError.definitionNotFound(key) = error else {
+        XCTFail("Thrown unexpected error: \(error)")
+        return
+      }
      
      //then
      let expectedKey = DefinitionKey(type: Service.self, typeOfArguments: Void.self, tag: nil)
      XCTAssertEqual(key, expectedKey)
-      
-      return true
    }
  }
  
@@ -256,25 +233,27 @@ class DipTests: XCTestCase {
    container.register(tag: "some tag") { ServiceImp1() as Service }
    
    //when
-    AssertThrows(expression: try container.resolve(tag: "other tag") as Service) { error in
-      guard case let DipError.definitionNotFound(key) = error else { return false }
+    XCTAssertThrowsError(try self.container.resolve(tag: "other tag") as Service) { error in
+      guard case let DipError.definitionNotFound(key) = error  else {
+        XCTFail("Thrown unexpected error: \(error)")
+        return
+      }
      
      //then
      let expectedKey = DefinitionKey(type: Service.self, typeOfArguments: Void.self, tag: "other tag")
      XCTAssertEqual(key, expectedKey)
-      
-      return true
    }

    //and when
-    AssertThrows(expression: try container.resolve(Service.self, tag: "other tag")) { error in
-      guard case let DipError.definitionNotFound(key) = error else { return false }
+    XCTAssertThrowsError(try self.container.resolve(Service.self, tag: "other tag")) { error in
+      guard case let DipError.definitionNotFound(key) = error else {
+        XCTFail("Thrown unexpected error: \(error)")
+        return
+      }
      
      //then
      let expectedKey = DefinitionKey(type: Service.self, typeOfArguments: Void.self, tag: "other tag")
      XCTAssertEqual(key, expectedKey)
-      
-      return true
    }
  }
  
@@ -283,25 +262,27 @@ class DipTests: XCTestCase {
    container.register { ServiceImp1() as Service }
    
    //when
-    AssertThrows(expression: try container.resolve(arguments: "some string") as Service) { error in
-      guard case let DipError.definitionNotFound(key) = error else { return false }
+    XCTAssertThrowsError(try self.container.resolve(arguments: "some string") as Service) { error in
+      guard case let DipError.definitionNotFound(key) = error else {
+        XCTFail("Thrown unexpected error: \(error)")
+        return
+      }
      
      //then
      let expectedKey = DefinitionKey(type: Service.self, typeOfArguments: String.self, tag: nil)
      XCTAssertEqual(key, expectedKey)
-
-      return true
    }

    //and when
-    AssertThrows(expression: try container.resolve(Service.self, arguments: "some string")) { error in
-      guard case let DipError.definitionNotFound(key) = error else { return false }
+    XCTAssertThrowsError(try self.container.resolve(Service.self, arguments: "some string")) { error in
+      guard case let DipError.definitionNotFound(key) = error else {
+        XCTFail("Thrown unexpected error: \(error)")
+        return
+      }
      
      //then
      let expectedKey = DefinitionKey(type: Service.self, typeOfArguments: String.self, tag: nil)
      XCTAssertEqual(key, expectedKey)
-      
-      return true
    }
  }
  
@@ -312,18 +293,18 @@ class DipTests: XCTestCase {
    container.register { () throws -> Service in throw expectedError }
    
    //when
-    AssertThrows(expression: try container.resolve() as Service) { error in
-      switch error {
-      case let DipError.definitionNotFound(key) where key == failedKey: return true
-      default: return false
+    XCTAssertThrowsError(try self.container.resolve() as Service) { error in
+      guard case let DipError.definitionNotFound(key) = error, key == failedKey else {
+        XCTFail("Thrown unexpected error: \(error)")
+        return
      }
    }
    
    //and when
-    AssertThrows(expression: try container.resolve(Service.self)) { error in
-      switch error {
-      case let DipError.definitionNotFound(key) where key == failedKey: return true
-      default: return false
+    XCTAssertThrowsError(try self.container.resolve(Service.self)) { error in
+      guard case let DipError.definitionNotFound(key) = error, key == failedKey else {
+        XCTFail("Thrown unexpected error: \(error)")
+        return
      }
    }
  }
@@ -339,18 +320,18 @@ class DipTests: XCTestCase {
    }
    
    //when
-    AssertThrows(expression: try container.resolve() as Service) { error in
-      switch error {
-      case let DipError.definitionNotFound(key) where key == failedKey: return true
-      default: return false
+    XCTAssertThrowsError(try self.container.resolve() as Service) { error in
+      guard case let DipError.definitionNotFound(key) = error, key == failedKey else {
+        XCTFail("Thrown unexpected error: \(error)")
+        return
      }
    }
    
    //and when
-    AssertThrows(expression: try container.resolve(Service.self)) { error in
-      switch error {
-      case let DipError.definitionNotFound(key) where key == failedKey: return true
-      default: return false
+    XCTAssertThrowsError(try self.container.resolve(Service.self)) { error in
+      guard case let DipError.definitionNotFound(key) = error, key == failedKey else {
+        XCTFail("Thrown unexpected error: \(error)")
+        return
      }
    }
  }
@@ -495,22 +476,15 @@ class DipTests: XCTestCase {
        XCTAssertNotNil(self.server?.client)
        XCTAssertNotNil(self.secondServer?.client)
      }
-      
    }

    //given
    container.register { try ResolvableServer(client: self.container.resolve()) as Server }
-      .resolvingProperties { (container: DependencyContainer, server: Server) in
-        let server = server as! ResolvableServer
-        server.secondClient = try container.resolve() as Client
-    }
+      .resolvingProperty(\ResolvableServer.secondClient, as: Client.self)
    
    container.register { ResolvableClient() as Client }
-      .resolvingProperties { (container: DependencyContainer, client: Client) in
-        let client = client as! ResolvableClient
-        client.server = try container.resolve() as Server
-        client.secondServer = try container.resolve() as Server
-    }
+      .resolvingProperty(\ResolvableClient.server, factory: { try $0.resolve() })
+      .resolvingProperty(\ResolvableClient.secondServer)

    //when
    let client = (try! container.resolve() as Client) as! ResolvableClient
@@ -558,7 +532,7 @@ class DipTests: XCTestCase {
    }
    
    //then
-    AssertNoThrow(expression: try container.validate("arg"))
+    XCTAssertNoThrow(try self.container.validate("arg"))
    XCTAssertTrue(createdService1)
    XCTAssertTrue(createdService2)
    XCTAssertTrue(createdService3)
@@ -581,8 +555,8 @@ class DipTests: XCTestCase {
    }
    
    //then
-    AssertNoThrow(expression:
-      try container.validate(
+    XCTAssertNoThrow(
+      try self.container.validate(
        "1",
        expectedIntArgument,
        "x",
@@ -597,8 +571,18 @@ class DipTests: XCTestCase {
    container.register { (a: Int) -> Service in ServiceImp1() as Service }
    
    //then
-    AssertThrows(expression: try container.validate()) { error in error is DipError }
-    AssertThrows(expression: try container.validate("1")) { error in error is DipError }
+    XCTAssertThrowsError(try self.container.validate()) { error in
+      guard error is DipError else {
+        XCTFail("Thrown unexpected error: \(error)")
+        return
+      }
+    }
+    XCTAssertThrowsError(try self.container.validate("1")) { error in
+      guard error is DipError else {
+        XCTFail("Thrown unexpected error: \(error)")
+        return
+      }
+    }
  }
  
  func testThatItFailsValidationOnlyForDipErrors() {
@@ -610,7 +594,7 @@ class DipTests: XCTestCase {
    }
    
    //then
-    AssertNoThrow(expression: try container.validate())
+    XCTAssertNoThrow(try self.container.validate())
    
    //given
    let key = DefinitionKey(type: Service.self, typeOfArguments: Void.self, tag: nil)
@@ -619,9 +603,11 @@ class DipTests: XCTestCase {
    }
    
    //then
-    AssertThrows(expression: try container.validate()) { error in
-      if case let DipError.definitionNotFound(_key) = error, _key == key { return true }
-      else { return false }
+    XCTAssertThrowsError(try self.container.validate()) { error in
+      guard case let DipError.definitionNotFound(_key) = error, _key == key else {
+        XCTFail("Thrown unexpected error: \(error)")
+        return
+      }
    }
  }
  
@@ -639,10 +625,10 @@ extension DipTests {
    container.collaborate(with: collaborator)
    
    //then
-    AssertNoThrow(expression: try container.resolve() as Service)
-    AssertNoThrow(expression: try container.resolve(Service.self))
-    AssertNoThrow(expression: try collaborator.resolve() as String)
-    AssertNoThrow(expression: try collaborator.resolve(String.self))
+    XCTAssertNoThrow(try self.container.resolve() as Service)
+    XCTAssertNoThrow(try self.container.resolve(Service.self))
+    XCTAssertNoThrow(try collaborator.resolve() as String)
+    XCTAssertNoThrow(try collaborator.resolve(String.self))
  }
  
  func testThatCollaboratingWithSelfIsIgnored() {
@@ -164,10 +164,10 @@ class DipUITests: XCTestCase {
  }
 }

-protocol SomeService: class {
+protocol SomeService: AnyObject {
  var delegate: SomeServiceDelegate? { get set }
 }
-protocol SomeServiceDelegate: class { }
+protocol SomeServiceDelegate: AnyObject { }
 class SomeServiceImp: SomeService {
  weak var delegate: SomeServiceDelegate?
  init(delegate: SomeServiceDelegate) {
@@ -176,10 +176,10 @@ class SomeServiceImp: SomeService {
  init(){}
 }

-protocol OtherService: class {
+protocol OtherService: AnyObject {
  var delegate: OtherServiceDelegate? { get set }
 }
-protocol OtherServiceDelegate: class {}
+protocol OtherServiceDelegate: AnyObject {}
 class OtherServiceImp: OtherService {
  weak var delegate: OtherServiceDelegate?
  init(delegate: OtherServiceDelegate){
@@ -189,7 +189,7 @@ class OtherServiceImp: OtherService {
 }


-protocol SomeScreen: class {
+protocol SomeScreen: AnyObject {
  var someService: SomeService? { get set }
  var otherService: OtherService? { get set }
 }
@@ -51,22 +51,6 @@ class RuntimeArgumentsTests: XCTestCase {
  
  let container = DependencyContainer()
 
-  static var allTests = {
-    return [
-      ("testThatItResolvesInstanceWithOneArgument", testThatItResolvesInstanceWithOneArgument),
-      ("testThatItResolvesInstanceWithTwoArguments", testThatItResolvesInstanceWithTwoArguments),
-      ("testThatItResolvesInstanceWithThreeArguments", testThatItResolvesInstanceWithThreeArguments),
-      ("testThatItResolvesInstanceWithFourArguments", testThatItResolvesInstanceWithFourArguments),
-      ("testThatItResolvesInstanceWithFiveArguments", testThatItResolvesInstanceWithFiveArguments),
-      ("testThatItResolvesInstanceWithSixArguments", testThatItResolvesInstanceWithSixArguments),
-      ("testThatItRegistersDifferentFactoriesForDifferentNumberOfArguments", testThatItRegistersDifferentFactoriesForDifferentNumberOfArguments),
-      ("testThatItRegistersDifferentFactoriesForDifferentTypesOfArguments", testThatItRegistersDifferentFactoriesForDifferentTypesOfArguments),
-      ("testThatItRegistersDifferentFactoriesForDifferentOrderOfArguments", testThatItRegistersDifferentFactoriesForDifferentOrderOfArguments),
-      ("testThatNewRegistrationWithSameArgumentsOverridesPreviousRegistration", testThatNewRegistrationWithSameArgumentsOverridesPreviousRegistration),
-      ("testThatDifferentFactoriesRegisteredIfArgumentIsOptional", testThatDifferentFactoriesRegisteredIfArgumentIsOptional)
-    ]
-  }()
-
  override func setUp() {
    container.reset()
  }
@@ -284,7 +268,7 @@ class RuntimeArgumentsTests: XCTestCase {
    
    //Due to incomplete implementation of SE-0054 (bug: https://bugs.swift.org/browse/SR-2143)
    //registering definition with T? and T! arguments types will produce two different definitions
-    //but when argement of T! will be passed to `resolve` method it will be transformed to T?
+    //but when argument of T! will be passed to `resolve` method it will be transformed to T?
    //and wrong definition will be used
    //When fixed using T? and T! should not register two different definitions

@@ -22,14 +22,15 @@
 // THE SOFTWARE.
 //

+#if canImport(ObjectiveC)
 import XCTest
@testable import Dip

-private protocol Server: class {
+private protocol Server: AnyObject {
  var client: Client! { get set }
 }

-private protocol Client: class {
+private protocol Client: AnyObject {
  var server: Server { get }
 }

@@ -48,8 +49,8 @@ private class ServerImp: Server, Hashable {
  weak var client: Client!
  init() {}
  
-  var hashValue: Int {
-    return Unmanaged.passUnretained(self).toOpaque().hashValue
+  func hash(into hasher: inout Hasher) {
+    hasher.combine(ObjectIdentifier(self))
  }
 }

@@ -62,22 +63,6 @@ private var resolvedClients = Array<ClientImp>()

 private var container: DependencyContainer!

-#if os(Linux)
-import Glibc
-  
-private var runningThreads: Int = 0
-private var lock: pthread_spinlock_t = 0
-
-private let resolveClientSync: () -> Client? = {
-  let pointer = dispatch_sync { _ in
-    let resolved = try! container.resolve() as Client
-    return UnsafeMutableRawPointer(Unmanaged.passRetained(resolved as! ClientImp).toOpaque())
-  }
-  guard let clientPointer = pointer else { return nil }
-  return Unmanaged<ClientImp>.fromOpaque(clientPointer).takeRetainedValue()
-}
-  
-#else
 let queue = OperationQueue()
 let lock = RecursiveLock()
  
@@ -88,18 +73,11 @@ private let resolveClientSync: () -> Client? = {
  }
  return client
 }
-  
-#endif

 let resolveServerAsync = {
  let server = try! container.resolve() as Server
  lock.lock()
  resolvedServers.insert(server as! ServerImp)
-
-  #if os(Linux)
-    runningThreads -= 1
-  #endif
-
  lock.unlock()
 }

@@ -107,31 +85,11 @@ let resolveClientAsync = {
  let client = try! container.resolve() as Client
  lock.lock()
  resolvedClients.append(client as! ClientImp)
-
-  #if os(Linux)
-    runningThreads -= 1
-  #endif
-
  lock.unlock()
 }

 class ThreadSafetyTests: XCTestCase {
  
-  #if os(Linux)
-  required init(name: String, testClosure: @escaping (XCTestCase) throws -> Void) {
-    pthread_spin_init(&lock, 0)
-    super.init(name: name, testClosure: testClosure)
-  }
-  #endif
-  
-  static var allTests = {
-    return [
-      ("testSingletonThreadSafety", testSingletonThreadSafety),
-      ("testFactoryThreadSafety", testFactoryThreadSafety),
-      ("testCircularReferenceThreadSafety", testCircularReferenceThreadSafety)
-    ]
-  }()
-  
  override func setUp() {
    Dip.logLevel = .Verbose
    container = DependencyContainer()
@@ -146,25 +104,10 @@ class ThreadSafetyTests: XCTestCase {
    container.register(.singleton) { ServerImp() as Server }
    
    for _ in 0..<100 {
-      #if os(Linux)
-      lock.lock()
-      runningThreads += 1
-      lock.unlock()
-        
-      dispatch_async { _ in
-        resolveServerAsync()
-        return nil
-      }
-      #else
      queue.addOperation(resolveServerAsync)
-      #endif
    }
    
-    #if os(Linux)
-    while runningThreads > 0 { sleep(1) }
-    #else
    queue.waitUntilAllOperationsAreFinished()
-    #endif
    
    XCTAssertEqual(resolvedServers.count, 1, "Should create only one instance")
  }
@@ -174,25 +117,10 @@ class ThreadSafetyTests: XCTestCase {
    container.register { ServerImp() as Server }
    
    for _ in 0..<100 {
-      #if os(Linux)
-      lock.lock()
-      runningThreads += 1
-      lock.unlock()
-
-      dispatch_async { _ in
-        resolveServerAsync()
-        return nil
-      }
-      #else
      queue.addOperation(resolveServerAsync)
-      #endif
    }
    
-    #if os(Linux)
-    while runningThreads > 0 { sleep(1) }
-    #else
    queue.waitUntilAllOperationsAreFinished()
-    #endif

    XCTAssertEqual(resolvedServers.count, 100, "All instances should be different")
  }
@@ -209,25 +137,10 @@ class ThreadSafetyTests: XCTestCase {
    }
    
    for _ in 0..<100 {
-      #if os(Linux)
-      lock.lock()
-      runningThreads += 1
-      lock.unlock()
-
-      dispatch_async { _ in
-        resolveClientAsync()
-        return nil
-      }
-      #else
      queue.addOperation(resolveClientAsync)
-      #endif
    }
    
-    #if os(Linux)
-    while runningThreads > 0 { sleep(1) }
-    #else
    queue.waitUntilAllOperationsAreFinished()
-    #endif
    
    XCTAssertEqual(resolvedClients.count, 100, "Instances should be not reused in different object graphs")
    for client in resolvedClients {
@@ -238,5 +151,4 @@ class ThreadSafetyTests: XCTestCase {
  }
  
 }
-
-
+#endif
@@ -25,10 +25,15 @@
 import XCTest
@testable import Dip

-private protocol Service: class { }
-private protocol ForwardedType: class { }
+private protocol Service: AnyObject { }
+private protocol ForwardedType: AnyObject { }
+#if os(Linux)
+private class ServiceImp1: Service, ForwardedType { }
+private class ServiceImp2: Service, ForwardedType { }
+#else
 private class ServiceImp1: NSObject, Service, ForwardedType { }
 private class ServiceImp2: NSObject, Service, ForwardedType { }
+#endif

 private protocol Dependency {}
 private struct DependencyImpl: Dependency {}
@@ -52,24 +57,6 @@ private struct OptionalDependencyClient {
 class TypeForwardingTests: XCTestCase {
  
  let container = DependencyContainer()
-
-  static var allTests = {
-    return [
-      ("testThatItResolvesInstanceByTypeForwarding", testThatItResolvesInstanceByTypeForwarding),
-      ("testThatItReusesInstanceResolvedByTypeForwarding", testThatItReusesInstanceResolvedByTypeForwarding),
-      ("testThatItDoesNotResolveByTypeForwardingIfRegisteredForAnotherTag", testThatItDoesNotResolveByTypeForwardingIfRegisteredForAnotherTag),
-      ("testThatItDoesNotReuseInstanceResolvedByTypeForwardingRegisteredForAnotherTag",  testThatItDoesNotReuseInstanceResolvedByTypeForwardingRegisteredForAnotherTag),
-      ("testThatItCallsResolvedDependenciesBlockWhenResolvingByTypeForwarding", testThatItCallsResolvedDependenciesBlockWhenResolvingByTypeForwarding),
-      ("testThatItCallsResolvedDependenciesBlockProvidedAfterRegistrationWhenResolvingByTypeForwarding",testThatItCallsResolvedDependenciesBlockProvidedAfterRegistrationWhenResolvingByTypeForwarding),
-      ("testThatItFallbackToDefinitionWithNoTagWhenResolvingInstanceByTypeForwarding", testThatItFallbackToDefinitionWithNoTagWhenResolvingInstanceByTypeForwarding),
-      ("testThatItCanResolveOptional", testThatItCanResolveOptional),
-      ("testThatItReusesInstancesResolvedForOptionalType", testThatItReusesInstancesResolvedForOptionalType),
-      ("testThatItFirstUsesTaggedDefinitionWhenResolvingOptional", testThatItFirstUsesTaggedDefinitionWhenResolvingOptional),
-      ("testThatItThrowsErrorWhenResolvingNotImplementedTypeWithTypeForwarding", testThatItThrowsErrorWhenResolvingNotImplementedTypeWithTypeForwarding),
-      ("testThatItOverridesIfSeveralDefinitionsWithTheSameTagForwardTheSameType", testThatItOverridesIfSeveralDefinitionsWithTheSameTagForwardTheSameType),
-      ("testThatItDoesNotOverrideIfDefinitionForwardsTheSameTypeWithDifferentTag", testThatItDoesNotOverrideIfDefinitionForwardsTheSameTypeWithDifferentTag)
-    ]
-  }()
  
  override func setUp() {
    container.reset()
@@ -129,15 +116,15 @@ class TypeForwardingTests: XCTestCase {
    def.implements(ForwardedType.self, tag: "otherTag")
    
    //then
-    AssertThrows(expression: try container.resolve(tag: "tag") as ForwardedType)
-    AssertThrows(expression: try container.resolve(ForwardedType.self, tag: "tag"))
+    XCTAssertThrowsError(try self.container.resolve(tag: "tag") as ForwardedType)
+    XCTAssertThrowsError(try self.container.resolve(ForwardedType.self, tag: "tag"))
    
    //and given
    def.implements(ForwardedType.self, tag: "tag")
    
    //then
-    AssertNoThrow(expression: try container.resolve(tag: "tag") as ForwardedType)
-    AssertNoThrow(expression: try container.resolve(ForwardedType.self, tag: "tag"))
+    XCTAssertNoThrow(try self.container.resolve(tag: "tag") as ForwardedType)
+    XCTAssertNoThrow(try self.container.resolve(ForwardedType.self, tag: "tag"))
  }
  
  func testThatItDoesNotReuseInstanceResolvedByTypeForwardingRegisteredForAnotherTag() {
@@ -149,7 +136,7 @@ class TypeForwardingTests: XCTestCase {
        resolveDependenciesCalled = true

        //when
-        //resolving via type-forawrding for tag different then tag for original definition
+        //resolving via type-forwarding for tag different then tag for original definition
        let forwardType = try container.resolve(tag: "tag") as ForwardedType
        let anyForwardType = try container.resolve(ForwardedType.self, tag: "tag") as! ForwardedType

@@ -325,19 +312,23 @@ class TypeForwardingTests: XCTestCase {
      .implements(ServiceImp2.self)
    
    //then
-    AssertThrows(expression: try container.resolve() as ServiceImp2) { error in
-      guard case let DipError.invalidType(_, key) = error else { return false }
+    XCTAssertThrowsError(try self.container.resolve() as ServiceImp2) { error in
+      guard case let DipError.invalidType(_, key) = error else {
+        XCTFail("Thrown unexpected error: \(error)")
+        return
+      }
      
      let expectedKey = DefinitionKey(type: ServiceImp2.self, typeOfArguments: Void.self, tag: nil)
      XCTAssertEqual(key, expectedKey)
-      return true
    }
-    AssertThrows(expression: try container.resolve(ServiceImp2.self)) { error in
-      guard case let DipError.invalidType(_, key) = error else { return false }
+    XCTAssertThrowsError(try self.container.resolve(ServiceImp2.self)) { error in
+      guard case let DipError.invalidType(_, key) = error else {
+        XCTFail("Thrown unexpected error: \(error)")
+        return
+      }
      
      let expectedKey = DefinitionKey(type: ServiceImp2.self, typeOfArguments: Void.self, tag: nil)
      XCTAssertEqual(key, expectedKey)
-      return true
    }
  }
  
@@ -28,41 +28,6 @@ import XCTest
  typealias NSObject = AnyObject
 #endif

-func AssertThrows<T>(_ file: StaticString = #file, line: UInt = #line, expression: @autoclosure () throws -> T) {
-  AssertThrows(file, line: line, expression: expression, "")
-}
-
-func AssertThrows<T>(_ file: StaticString = #file, line: UInt = #line, expression: @autoclosure () throws -> T, _ message: String) {
-  AssertThrows(expression: expression, checkError: { _ in true }, message)
-}
-
-func AssertThrows<T>(_ file: StaticString = #file, line: UInt = #line, expression: @autoclosure () throws -> T, checkError: (Error) -> Bool) {
-  AssertThrows(file, line: line, expression: expression, checkError: checkError, "")
-}
-
-func AssertThrows<T>(_ file: StaticString = #file, line: UInt = #line, expression: @autoclosure () throws -> T, checkError: (Error) -> Bool, _ message: String) {
-  do {
-    let _ = try expression()
-    XCTFail(message, file: file, line: line)
-  }
-  catch {
-    XCTAssertTrue(checkError(error), "Thrown unexpected error: \(error)", file: file, line: line)
-  }
-}
-
-func AssertNoThrow<T>(_ file: StaticString = #file, line: UInt = #line, expression: @autoclosure () throws -> T) {
-  AssertNoThrow(file, line: line, expression: expression, "")
-}
-
-func AssertNoThrow<T>(_ file: StaticString = #file, line: UInt = #line, expression: @autoclosure () throws -> T, _ message: String) {
-  do {
-    let _ = try expression()
-  }
-  catch {
-    XCTFail(message, file: file, line: line)
-  }
-}
-
 #if os(Linux)
 import Glibc
 typealias TMain = @convention(c) (UnsafeMutableRawPointer?) -> UnsafeMutableRawPointer?
@@ -78,7 +43,7 @@ func dispatch_async(block: @escaping TMain) -> pthread_t {
 }

 func dispatch_sync(block: @escaping TMain) -> UnsafeMutableRawPointer? {
-  var result: UnsafeMutableRawPointer? = UnsafeMutableRawPointer.allocate(bytes: 1, alignedTo: 0)
+  var result: UnsafeMutableRawPointer? = UnsafeMutableRawPointer.allocate(byteCount: 1, alignment: 0)
  let pid = startThread(block)
  pthread_join(pid, &result)
  return result
@@ -1,14 +0,0 @@
-import XCTest
-@testable import DipTests
-
-XCTMain([
-  testCase(DipTests.allTests),
-  testCase(DefinitionTests.allTests),
-  testCase(RuntimeArgumentsTests.allTests),
-  testCase(ComponentScopeTests.allTests),
-  testCase(AutoInjectionTests.allTests),
-//  testCase(ThreadSafetyTests.allTests),
-  testCase(AutoWiringTests.allTests),
-  testCase(ContextTests.allTests),
-  testCase(TypeForwardingTests.allTests)
-])
@@ -0,0 +1,202 @@
+#if !canImport(ObjectiveC)
+import XCTest
+
+extension AutoInjectionTests {
+    // DO NOT MODIFY: This is autogenerated, use:
+    //   `swift test --generate-linuxmain`
+    // to regenerate.
+    static let __allTests__AutoInjectionTests = [
+        ("testThatItAutoInjectsPropertyWithCollaboratingContainer", testThatItAutoInjectsPropertyWithCollaboratingContainer),
+        ("testThatItAutoInjectsWhenOverridenInDefinition", testThatItAutoInjectsWhenOverridenInDefinition),
+        ("testThatItCallsDidInjectOnAutoInjectedProperty", testThatItCallsDidInjectOnAutoInjectedProperty),
+        ("testThatItCallsResolveDependencyBlockWhenAutoInjecting", testThatItCallsResolveDependencyBlockWhenAutoInjecting),
+        ("testThatItDoesNotAutoInjectIfDisabledInContainer", testThatItDoesNotAutoInjectIfDisabledInContainer),
+        ("testThatItDoesNotAutoInjectIfDisabledInDefinition", testThatItDoesNotAutoInjectIfDisabledInDefinition),
+        ("testThatItDoesNotPassTagToAutoInjectedPropertyWithExplicitTag", testThatItDoesNotPassTagToAutoInjectedPropertyWithExplicitTag),
+        ("testThatItPassesTagToAutoInjectedProperty", testThatItPassesTagToAutoInjectedProperty),
+        ("testThatItResolvesAutoInjectedDependencies", testThatItResolvesAutoInjectedDependencies),
+        ("testThatItResolvesAutoInjectedSingletons", testThatItResolvesAutoInjectedSingletons),
+        ("testThatItResolvesInheritedDependencies", testThatItResolvesInheritedDependencies),
+        ("testThatItResolvesTaggedAutoInjectedProperties", testThatItResolvesTaggedAutoInjectedProperties),
+        ("testThatItReusesAutoInjectedInstancesOnNextResolveOrAutoInjection", testThatItReusesAutoInjectedInstancesOnNextResolveOrAutoInjection),
+        ("testThatItReusesResolvedAutoInjectedInstances", testThatItReusesResolvedAutoInjectedInstances),
+        ("testThatItThrowsErrorIfFailsToAutoInjectDependency", testThatItThrowsErrorIfFailsToAutoInjectDependency),
+        ("testThatNoErrorThrownWhenOptionalPropertiesAreNotAutoInjected", testThatNoErrorThrownWhenOptionalPropertiesAreNotAutoInjected),
+        ("testThatThereIsNoRetainCycleBetweenAutoInjectedCircularDependencies", testThatThereIsNoRetainCycleBetweenAutoInjectedCircularDependencies),
+    ]
+}
+
+extension AutoWiringTests {
+    // DO NOT MODIFY: This is autogenerated, use:
+    //   `swift test --generate-linuxmain`
+    // to regenerate.
+    static let __allTests__AutoWiringTests = [
+        ("testThatItCanAutoWireOptional", testThatItCanAutoWireOptional),
+        ("testThatItCanResolveWithAutoWiring", testThatItCanResolveWithAutoWiring),
+        ("testThatItDoesNotReuseInstancesResolvedWithAutoWiringWhenUsingAutoWiringAgainWithAnotherTag", testThatItDoesNotReuseInstancesResolvedWithAutoWiringWhenUsingAutoWiringAgainWithAnotherTag),
+        ("testThatItDoesNotTryToUseAutoWiringWhenCallingResolveWithArguments", testThatItDoesNotTryToUseAutoWiringWhenCallingResolveWithArguments),
+        ("testThatItDoesNotUseAutoWiringWhenFailedToResolveLowLevelDependency", testThatItDoesNotUseAutoWiringWhenFailedToResolveLowLevelDependency),
+        ("testThatItFallbackToNotTaggedFactoryWhenUsingAutoWire", testThatItFallbackToNotTaggedFactoryWhenUsingAutoWire),
+        ("testThatItPrefersTaggedFactoryWithDifferentNumberOfArgumentsWhenUsingAutoWire", testThatItPrefersTaggedFactoryWithDifferentNumberOfArgumentsWhenUsingAutoWire),
+        ("testThatItPrefersTaggedFactoryWithDifferentTypesOfArgumentsWhenUsingAutoWire", testThatItPrefersTaggedFactoryWithDifferentTypesOfArgumentsWhenUsingAutoWire),
+        ("testThatItReusesInstancesResolvedWithAutoWiringWhenUsingAutoWiringAgain", testThatItReusesInstancesResolvedWithAutoWiringWhenUsingAutoWiringAgain),
+        ("testThatItReusesInstancesResolvedWithAutoWiringWhenUsingAutoWiringAgainWithTheSameTag", testThatItReusesInstancesResolvedWithAutoWiringWhenUsingAutoWiringAgainWithTheSameTag),
+        ("testThatItReusesInstancesResolvedWithoutAutoWiringWhenUsingAutoWiringAgain", testThatItReusesInstancesResolvedWithoutAutoWiringWhenUsingAutoWiringAgain),
+        ("testThatItThrowsAmbiguityErrorWhenUsingAutoWire", testThatItThrowsAmbiguityErrorWhenUsingAutoWire),
+        ("testThatItUsesAutoWireFactoryWithMostNumberOfArguments", testThatItUsesAutoWireFactoryWithMostNumberOfArguments),
+        ("testThatItUsesTagToResolveDependenciesWithAutoWiringWith1Argument", testThatItUsesTagToResolveDependenciesWithAutoWiringWith1Argument),
+        ("testThatItUsesTagToResolveDependenciesWithAutoWiringWith2Arguments", testThatItUsesTagToResolveDependenciesWithAutoWiringWith2Arguments),
+        ("testThatItUsesTagToResolveDependenciesWithAutoWiringWith3Arguments", testThatItUsesTagToResolveDependenciesWithAutoWiringWith3Arguments),
+        ("testThatItUsesTagToResolveDependenciesWithAutoWiringWith4Arguments", testThatItUsesTagToResolveDependenciesWithAutoWiringWith4Arguments),
+        ("testThatItUsesTagToResolveDependenciesWithAutoWiringWith5Arguments", testThatItUsesTagToResolveDependenciesWithAutoWiringWith5Arguments),
+        ("testThatItUsesTagToResolveDependenciesWithAutoWiringWith6Arguments", testThatItUsesTagToResolveDependenciesWithAutoWiringWith6Arguments),
+    ]
+}
+
+extension ComponentScopeTests {
+    // DO NOT MODIFY: This is autogenerated, use:
+    //   `swift test --generate-linuxmain`
+    // to regenerate.
+    static let __allTests__ComponentScopeTests = [
+        ("testThatCollaboratingContainersReuseSingletonsResolvedByAnotherContainer", testThatCollaboratingContainersReuseSingletonsResolvedByAnotherContainer),
+        ("testThatContainerCanBeBootstrappedAgainAfterReset", testThatContainerCanBeBootstrappedAgainAfterReset),
+        ("testThatItDoesNotReuseInstanceInSharedScopeInNextResolve", testThatItDoesNotReuseInstanceInSharedScopeInNextResolve),
+        ("testThatItDoesNotReuseInstanceInSharedScopeResolvedForNilTagWhenResolvingForAnotherTag", testThatItDoesNotReuseInstanceInSharedScopeResolvedForNilTagWhenResolvingForAnotherTag),
+        ("testThatItHoldsWeakReferenceToWeakSingletonInstance", testThatItHoldsWeakReferenceToWeakSingletonInstance),
+        ("testThatItResolvesTypeAsNewInstanceForUniqueScope", testThatItResolvesTypeAsNewInstanceForUniqueScope),
+        ("testThatItResolvesWeakSingletonAgainAfterItWasReleased", testThatItResolvesWeakSingletonAgainAfterItWasReleased),
+        ("testThatItReusesInstanceForSingletonScope", testThatItReusesInstanceForSingletonScope),
+        ("testThatItReusesInstanceInSharedScopeDuringResolve", testThatItReusesInstanceInSharedScopeDuringResolve),
+        ("testThatItReusesInstanceInSharedScopeResolvedForNilTag", testThatItReusesInstanceInSharedScopeResolvedForNilTag),
+        ("testThatItReusesResolvedInstanceWhenResolvingOptional", testThatItReusesResolvedInstanceWhenResolvingOptional),
+        ("testThatOnlyEagerSingletonIsCreatedWhenContainerIsBootsrapped", testThatOnlyEagerSingletonIsCreatedWhenContainerIsBootsrapped),
+        ("testThatScopeCanBeChanged", testThatScopeCanBeChanged),
+        ("testThatSharedIsDefaultScope", testThatSharedIsDefaultScope),
+        ("testThatSingletonIsNotReusedAcrossContainers", testThatSingletonIsNotReusedAcrossContainers),
+        ("testThatSingletonIsReleasedWhenContainerIsReset", testThatSingletonIsReleasedWhenContainerIsReset),
+        ("testThatSingletonIsReleasedWhenDefinitionIsOverridden", testThatSingletonIsReleasedWhenDefinitionIsOverridden),
+        ("testThatSingletonIsReleasedWhenDefinitionIsRemoved", testThatSingletonIsReleasedWhenDefinitionIsRemoved),
+    ]
+}
+
+extension ContextTests {
+    // DO NOT MODIFY: This is autogenerated, use:
+    //   `swift test --generate-linuxmain`
+    // to regenerate.
+    static let __allTests__ContextTests = [
+        ("testThatContextDoesNotOverrideNilTagPassedToResolve", testThatContextDoesNotOverrideNilTagPassedToResolve),
+        ("testThatContextIsPreservedWhenResolvingWithCollaboration", testThatContextIsPreservedWhenResolvingWithCollaboration),
+        ("testThatContextStoresCurrentlyResolvedType", testThatContextStoresCurrentlyResolvedType),
+        ("testThatContextStoresInjectedInType", testThatContextStoresInjectedInType),
+        ("testThatContextStoresNameOfAutoInjectedProperty", testThatContextStoresNameOfAutoInjectedProperty),
+        ("testThatContextStoresTheTagPassedToResolve", testThatContextStoresTheTagPassedToResolve),
+        ("testThatContextStoresTheTagPassedToResolveWhenAutoInjecting", testThatContextStoresTheTagPassedToResolveWhenAutoInjecting),
+        ("testThatContextStoresTheTagPassedToResolveWhenAutoWiring", testThatContextStoresTheTagPassedToResolveWhenAutoWiring),
+        ("testThatItDoesNotSetInjectedInTypeWhenResolvingWithCollaboration", testThatItDoesNotSetInjectedInTypeWhenResolvingWithCollaboration),
+    ]
+}
+
+extension DefinitionTests {
+    // DO NOT MODIFY: This is autogenerated, use:
+    //   `swift test --generate-linuxmain`
+    // to regenerate.
+    static let __allTests__DefinitionTests = [
+        ("testThatDefinitionKeyIsEqualBy_Type_Factory_Tag", testThatDefinitionKeyIsEqualBy_Type_Factory_Tag),
+        ("testThatDefinitionKeysWithDifferentFactoriesAreNotEqual", testThatDefinitionKeysWithDifferentFactoriesAreNotEqual),
+        ("testThatDefinitionKeysWithDifferentTagsAreNotEqual", testThatDefinitionKeysWithDifferentTagsAreNotEqual),
+        ("testThatDefinitionKeysWithDifferentTypesAreNotEqual", testThatDefinitionKeysWithDifferentTypesAreNotEqual),
+        ("testThatItRegisteresOptionalTypesAsForwardedTypes", testThatItRegisteresOptionalTypesAsForwardedTypes),
+        ("testThatResolveDependenciesBlockIsNotCalledWhenPassedWrongInstance", testThatResolveDependenciesBlockIsNotCalledWhenPassedWrongInstance),
+        ("testThatResolveDependenciesCallsResolveDependenciesBlock", testThatResolveDependenciesCallsResolveDependenciesBlock),
+    ]
+}
+
+extension DipTests {
+    // DO NOT MODIFY: This is autogenerated, use:
+    //   `swift test --generate-linuxmain`
+    // to regenerate.
+    static let __allTests__DipTests = [
+        ("test_weak_mirror_regression", test_weak_mirror_regression),
+        ("testItCallsResolveDependenciesOnResolableInstance", testItCallsResolveDependenciesOnResolableInstance),
+        ("testThatCollaboratingContainersAreWeakReferences", testThatCollaboratingContainersAreWeakReferences),
+        ("testThatCollaboratingContainersReuseInstancesResolvedByAnotherContainer", testThatCollaboratingContainersReuseInstancesResolvedByAnotherContainer),
+        ("testThatCollaboratingWithSelfIsIgnored", testThatCollaboratingWithSelfIsIgnored),
+        ("testThatCollaborationReferencesAreRecursivelyUpdate", testThatCollaborationReferencesAreRecursivelyUpdate),
+        ("testThatContainerAutowireBeforeCollaboration", testThatContainerAutowireBeforeCollaboration),
+        ("testThatContainersShareTheirSingletonsOnlyWithCollaborators", testThatContainersShareTheirSingletonsOnlyWithCollaborators),
+        ("testThatCreatingContainerWithConfigBlockDoesNotCreateRetainCycle", testThatCreatingContainerWithConfigBlockDoesNotCreateRetainCycle),
+        ("testThatItCallsDidResolveDependenciesInReverseOrder", testThatItCallsDidResolveDependenciesInReverseOrder),
+        ("testThatItCallsDidResolveDependenciesOnResolvableIntance", testThatItCallsDidResolveDependenciesOnResolvableIntance),
+        ("testThatItCallsResolveDependenciesOnDefinition", testThatItCallsResolveDependenciesOnDefinition),
+        ("testThatItCanHandleSeparateContainersAndTheirCollaboration", testThatItCanHandleSeparateContainersAndTheirCollaboration),
+        ("testThatItCanResolveUsingContainersCollaboration", testThatItCanResolveUsingContainersCollaboration),
+        ("testThatItFailsValidationIfNoMatchingArgumentsFound", testThatItFailsValidationIfNoMatchingArgumentsFound),
+        ("testThatItFailsValidationOnlyForDipErrors", testThatItFailsValidationOnlyForDipErrors),
+        ("testThatItPicksRuntimeArgumentsWhenValidatingConfiguration", testThatItPicksRuntimeArgumentsWhenValidatingConfiguration),
+        ("testThatItResolvesCircularDependencies", testThatItResolvesCircularDependencies),
+        ("testThatItResolvesDifferentInstancesRegisteredForDifferentTags", testThatItResolvesDifferentInstancesRegisteredForDifferentTags),
+        ("testThatItResolvesInstanceRegisteredWithoutTag", testThatItResolvesInstanceRegisteredWithoutTag),
+        ("testThatItResolvesInstanceRegisteredWithTag", testThatItResolvesInstanceRegisteredWithTag),
+        ("testThatItThrowsErrorIfCanNotFindDefinitionForFactoryWithArguments", testThatItThrowsErrorIfCanNotFindDefinitionForFactoryWithArguments),
+        ("testThatItThrowsErrorIfCanNotFindDefinitionForTag", testThatItThrowsErrorIfCanNotFindDefinitionForTag),
+        ("testThatItThrowsErrorIfCanNotFindDefinitionForType", testThatItThrowsErrorIfCanNotFindDefinitionForType),
+        ("testThatItThrowsErrorIfConstructorThrows", testThatItThrowsErrorIfConstructorThrows),
+        ("testThatItThrowsErrorIfFailsToResolveDependency", testThatItThrowsErrorIfFailsToResolveDependency),
+        ("testThatItValidatesConfiguration", testThatItValidatesConfiguration),
+        ("testThatNewRegistrationOverridesPreviousRegistration", testThatNewRegistrationOverridesPreviousRegistration),
+    ]
+}
+
+extension RuntimeArgumentsTests {
+    // DO NOT MODIFY: This is autogenerated, use:
+    //   `swift test --generate-linuxmain`
+    // to regenerate.
+    static let __allTests__RuntimeArgumentsTests = [
+        ("testThatDifferentFactoriesRegisteredIfArgumentIsOptional", testThatDifferentFactoriesRegisteredIfArgumentIsOptional),
+        ("testThatItRegistersDifferentFactoriesForDifferentNumberOfArguments", testThatItRegistersDifferentFactoriesForDifferentNumberOfArguments),
+        ("testThatItRegistersDifferentFactoriesForDifferentOrderOfArguments", testThatItRegistersDifferentFactoriesForDifferentOrderOfArguments),
+        ("testThatItRegistersDifferentFactoriesForDifferentTypesOfArguments", testThatItRegistersDifferentFactoriesForDifferentTypesOfArguments),
+        ("testThatItResolvesInstanceWithFiveArguments", testThatItResolvesInstanceWithFiveArguments),
+        ("testThatItResolvesInstanceWithFourArguments", testThatItResolvesInstanceWithFourArguments),
+        ("testThatItResolvesInstanceWithOneArgument", testThatItResolvesInstanceWithOneArgument),
+        ("testThatItResolvesInstanceWithSixArguments", testThatItResolvesInstanceWithSixArguments),
+        ("testThatItResolvesInstanceWithThreeArguments", testThatItResolvesInstanceWithThreeArguments),
+        ("testThatItResolvesInstanceWithTwoArguments", testThatItResolvesInstanceWithTwoArguments),
+        ("testThatNewRegistrationWithSameArgumentsOverridesPreviousRegistration", testThatNewRegistrationWithSameArgumentsOverridesPreviousRegistration),
+    ]
+}
+
+extension TypeForwardingTests {
+    // DO NOT MODIFY: This is autogenerated, use:
+    //   `swift test --generate-linuxmain`
+    // to regenerate.
+    static let __allTests__TypeForwardingTests = [
+        ("testThatItCallsResolvedDependenciesBlockProvidedAfterRegistrationWhenResolvingByTypeForwarding", testThatItCallsResolvedDependenciesBlockProvidedAfterRegistrationWhenResolvingByTypeForwarding),
+        ("testThatItCallsResolvedDependenciesBlockWhenResolvingByTypeForwarding", testThatItCallsResolvedDependenciesBlockWhenResolvingByTypeForwarding),
+        ("testThatItCanResolveOptional", testThatItCanResolveOptional),
+        ("testThatItDoesNotOverrideIfDefinitionForwardsTheSameTypeWithDifferentTag", testThatItDoesNotOverrideIfDefinitionForwardsTheSameTypeWithDifferentTag),
+        ("testThatItDoesNotResolveByTypeForwardingIfRegisteredForAnotherTag", testThatItDoesNotResolveByTypeForwardingIfRegisteredForAnotherTag),
+        ("testThatItDoesNotReuseInstanceResolvedByTypeForwardingRegisteredForAnotherTag", testThatItDoesNotReuseInstanceResolvedByTypeForwardingRegisteredForAnotherTag),
+        ("testThatItFallbackToDefinitionWithNoTagWhenResolvingInstanceByTypeForwarding", testThatItFallbackToDefinitionWithNoTagWhenResolvingInstanceByTypeForwarding),
+        ("testThatItFirstUsesTaggedDefinitionWhenResolvingOptional", testThatItFirstUsesTaggedDefinitionWhenResolvingOptional),
+        ("testThatItOverridesIfSeveralDefinitionsWithTheSameTagForwardTheSameType", testThatItOverridesIfSeveralDefinitionsWithTheSameTagForwardTheSameType),
+        ("testThatItResolvesInstanceByTypeForwarding", testThatItResolvesInstanceByTypeForwarding),
+        ("testThatItReusesInstanceResolvedByTypeForwarding", testThatItReusesInstanceResolvedByTypeForwarding),
+        ("testThatItReusesInstancesResolvedForOptionalType", testThatItReusesInstancesResolvedForOptionalType),
+        ("testThatItThrowsErrorWhenResolvingNotImplementedTypeWithTypeForwarding", testThatItThrowsErrorWhenResolvingNotImplementedTypeWithTypeForwarding),
+    ]
+}
+
+public func __allTests() -> [XCTestCaseEntry] {
+    return [
+        testCase(AutoInjectionTests.__allTests__AutoInjectionTests),
+        testCase(AutoWiringTests.__allTests__AutoWiringTests),
+        testCase(ComponentScopeTests.__allTests__ComponentScopeTests),
+        testCase(ContextTests.__allTests__ContextTests),
+        testCase(DefinitionTests.__allTests__DefinitionTests),
+        testCase(DipTests.__allTests__DipTests),
+        testCase(RuntimeArgumentsTests.__allTests__RuntimeArgumentsTests),
+        testCase(TypeForwardingTests.__allTests__TypeForwardingTests),
+    ]
+}
+#endif
Author	SHA1	Message	Date
Ilya Puchka	7ec008a5c0	Merge pull request #237 from michalsrutek/develop Fix couple of typos	2020-05-29 14:42:25 +01:00
Ilya Puchka	772bc13daa	Merge pull request #238 from michalsrutek/use-anyobject-keyword Use preferred AnyObject keyword	2020-05-29 14:42:03 +01:00
Michal Srutek	fa4325399a	Use preferred AnyObject keyword	2020-04-23 10:22:20 +02:00
Michal Srutek	f7fbbda748	Fix couple of typos	2020-04-23 09:59:03 +02:00
Ilya Puchka	56b0768d60	bump version to 7.1.1	2019-12-27 11:14:55 +00:00
Ilya Puchka	8cf87efb95	Update podspec author	2019-12-27 11:07:21 +00:00
Ilya Puchka	3aa9b334f1	Merge pull request #233 from AliSoftware/spm-fix Enabled StoryboardInstantiatable for SPM builds	2019-11-15 11:53:25 +00:00
Ilya Puchka	b2a0cda242	Update StoryboardInstantiatable.swift	2019-11-13 13:16:52 +00:00
Ilya Puchka	82e3d02497	Merge branch 'master' into develop	2019-11-11 14:22:24 +00:00
Ilya Puchka	3b2f5a272f	bumpe version to 7.1.0	2019-11-10 16:11:17 +00:00
Ilya Puchka	eab2d424e7	allow to disable thread safety on container level	2019-11-10 16:01:20 +00:00
Ilya Puchka	0f2cda0a52	update changelog	2019-11-10 15:53:45 +00:00
Ilya Puchka	05c02c9645	Merge pull request #225 from AliSoftware/property-delegates Property wrappers	2019-11-10 15:52:49 +00:00
Ilya Puchka	fa086dad8f	add xcode 11 and swift 5.1 to travis build	2019-11-10 15:35:53 +00:00
Ilya Puchka	cdc09f5a03	removed unneeded initial nil values	2019-11-10 15:22:38 +00:00
Ilya Puchka	b94ed3bea2	fix warning	2019-11-10 15:22:16 +00:00
Ilya Puchka	0fd70e65dd	Merge branch 'develop' into property-delegates	2019-11-10 15:13:55 +00:00
Ilya Puchka	97e7f4782f	Merge branch 'pr/221' into develop	2019-11-10 15:12:41 +00:00
Ilya Puchka	f1fdbbc988	code review	2019-11-10 15:02:03 +00:00
Ilya Puchka	e368bb3051	Merge branch 'develop' into nested_types	2019-11-10 14:50:07 +00:00
Ilya Puchka	4ce4832960	Merge pull request #229 from dchohfi/develop Bump watchos deployment target to 3.0	2019-10-28 08:46:22 +00:00
Diego Chohfi	d3bd0c27e3	Bump watchos deployment target to 3.0	2019-10-21 10:40:46 -07:00
Ilya Puchka	be0c39ab6b	update for beta 3	2019-07-07 23:54:58 +01:00
Ilya Puchka	0de45e7d53	fixed checking for new injected value	2019-07-07 23:53:45 +01:00
Ilya Puchka	3b421d0cff	refactor property wrappers to struct	2019-07-07 16:16:50 +01:00
Ilya Puchka	f1234bf2b9	introduce swift 5.1 property delegates	2019-06-30 19:12:42 +01:00
Ilya Puchka	b0d7153bfe	ignore swiftpm files	2019-06-30 18:27:59 +01:00
Ilya Puchka	0193aa6bf6	Merge pull request #224 from AliSoftware/swift5 Swift 5	2019-06-30 17:17:49 +01:00
Ilya Puchka	de7ad3ac48	removed linux thread safety tests, regenerate test manifest	2019-06-30 16:59:10 +01:00
Ilya Puchka	40ad490c48	removed unneeded code	2019-06-30 15:53:23 +01:00
Ilya Puchka	95cc5df26f	fixed Linux tests	2019-06-30 15:40:40 +01:00
Ilya Puchka	09a7115aff	fix tests	2019-06-30 14:29:22 +01:00
Ilya Puchka	15c0002ea3	remove compatibility file	2019-06-12 01:18:14 +01:00
Ilya Puchka	0644d85a9c	update swift version in all targets	2019-06-12 01:18:05 +01:00
Ilya Puchka	e1522a0bf3	Merge branch 'develop' into swift5	2019-06-12 01:15:06 +01:00
Ilya Puchka	a659415496	generate LinuxMain	2019-06-11 23:23:39 +01:00
Ilya Puchka	efe25d575b	update package description	2019-06-11 23:10:22 +01:00
Ilya Puchka	22c67fa30c	disable spec validation	2019-06-11 21:30:55 +01:00
Ilya Puchka	7a091da44d	migrate to swift 5	2019-06-11 21:16:03 +01:00
s	9580976dd8	Print nested types in errors, hash keys using full typenames	2019-04-01 17:13:06 +02:00
Ilya Puchka	a4f0256313	fixed typos	2018-12-20 01:32:21 +00:00
Ilya Puchka	815e9ccd66	shorthand method for resolving properties via keypaths	2018-12-20 01:30:35 +00:00
Ilya Puchka	b9bf9c4d75	Merge pull request #216 from AliSoftware/develop Release 7.0.1	2018-12-19 22:54:14 +00:00
Ilya Puchka	530a20999a	use Cocoapods 1.4.0 as latest versions fail validation	2018-12-19 15:56:32 +00:00