diff --git a/Example/CoreDataDAOTests/CoreDataDAOEntityTests.swift b/Example/CoreDataDAOTests/CoreDataDAOEntityTests.swift
index db07f64..3e9b48b 100644
--- a/Example/CoreDataDAOTests/CoreDataDAOEntityTests.swift
+++ b/Example/CoreDataDAOTests/CoreDataDAOEntityTests.swift
@@ -14,28 +14,34 @@ import CoreData
 
 final class CoreDataDAOEntityTests: XCTestCase {
     
-    let dao = try! CoreDataDAO(
-        CDEntityTranslator(),
-        configuration: CoreDataConfiguration(
-            containerName: "Model",
-            storeType: NSInMemoryStoreType))
+    private var dao: CoreDataDAO<CDEntity, Entity>!
     
+    override func setUp() {
+        super.setUp()
+        
+        let translator = CDEntityTranslator()
+        let configuration = CoreDataConfiguration(
+            containerName: "Model",
+            storeType: NSInMemoryStoreType
+        )
+        
+        dao = try! CoreDataDAO(
+            translator,
+            configuration: configuration
+        )
+    }
+    
+    override func tearDown() {
+        super.tearDown()
+        
+        dao = nil
+    }
     
     func testReadById() {
         let entity = Entity(entityId: "2")
         
-        do {
-            try dao.persist(entity)
-        } catch _ {
-            XCTFail("Read by id is failed")
-        }
-        
-        
-        if let savedEntity = dao.read("2") {
-            XCTAssertEqual(savedEntity.entityId, entity.entityId)
-        } else {
-            XCTFail("Read by id is failed")
-        }
+        XCTAssertNoThrow(try dao.persist(entity), "Read by id is failed")
+        XCTAssertEqual(dao.read("2")?.entityId, entity.entityId, "Read by id is failed")
     }
     
     
@@ -44,42 +50,23 @@ final class CoreDataDAOEntityTests: XCTestCase {
         let exp = expectation(description: "")
         
         DispatchQueue.global().async {
-            do {
-                try self.dao.persist(entity)
-            } catch _ {
-                XCTFail("Async read by id is failed")
-            }
-            
+
+            XCTAssertNotNil(try? self.dao.persist(entity), "Async read by id is failed")
             
             DispatchQueue.global().async {
-                if let savedEntity = self.dao.read("2_back") {
-                    XCTAssertEqual(savedEntity.entityId, entity.entityId)
-                } else {
-                    XCTFail("Async read by id is failed")
-                }
+                XCTAssertEqual(self.dao.read("2_back")?.entityId, entity.entityId, "Async read by id is failed")
                 exp.fulfill()
             }
         }
         
-        waitForExpectations(timeout: 5) { error in
-            if error != nil {
-                XCTFail("Async read by id is failed")
-            }
-            XCTAssert(true)
-        }
+        waitForExpectations(timeout: 5)
     }
     
     
     func testPersist() {
         let entity = Entity(entityId: "1")
-        do {
-            try dao.persist(entity)
-        } catch _ {
-            XCTFail("Persist is failed")
-        }
         
-        
-        XCTAssert(true)
+        XCTAssertNoThrow(try dao.persist(entity), "Persist is failed")
     }
     
     
@@ -87,82 +74,43 @@ final class CoreDataDAOEntityTests: XCTestCase {
         let firstEntity = Entity(entityId: "2")
         let secondEntity = Entity(entityId: "3")
         
-        do {
-            try dao.persist([firstEntity, secondEntity])
-        } catch _ {
-            XCTFail("Persist All is failed")
-        }
-        
-        XCTAssert(true)
+        XCTAssertNoThrow(try dao.persist([firstEntity, secondEntity]), "Persist All is failed")
     }
     
     
     func testAsyncPersist() {
+        let entity = Entity(entityId: "1_back")
         let exp = expectation(description: "")
         
         DispatchQueue.global().async {
-            let entity = Entity(entityId: "1_back")
-            
-            do {
-                try self.dao.persist(entity)
-            } catch _ {
-                XCTFail("Saving entity in background is failed")
-            }
-            
+            XCTAssertNotNil(try? self.dao.persist(entity), "Saving entity in background is failed")
             exp.fulfill()
         }
         
-        waitForExpectations(timeout: 5) { error in
-            if error != nil {
-                XCTFail("Saving entity in background is failed")
-            }
-            XCTAssert(true)
-        }
+        waitForExpectations(timeout: 5)
     }
 
     
     func testEraseById() {
         let entity = Entity(entityId: "3")
         
-        do {
-            try dao.persist(entity)
-            try dao.erase("3")
-        } catch _ {
-            XCTFail("Erase is failed")
-        }
-    
-        XCTAssert(true)
+        XCTAssertNoThrow(try dao.persist(entity), "Erase is failed")
+        XCTAssertNoThrow(try dao.erase("3"), "Erase is failed")
     }
     
     
     func testAsyncEraseById() {
         let entity = Entity(entityId: "2_back")
         
-        do {
-            try dao.persist(entity)
-        } catch _ {
-            XCTFail("Async erase by id is failed")
-        }
-        
+        XCTAssertNoThrow(try dao.persist(entity), "Async erase by id is failed")
         
         let exp = expectation(description: "")
-        
         DispatchQueue.global().async {
-            do {
-                try self.dao.erase("2_back")
-            } catch _ {
-                XCTFail("Async erase by id is failed")
-            }
-            
+            XCTAssertNotNil(try? self.dao.erase("2_back"), "Async erase by id is failed")
             exp.fulfill()
         }
         
-        waitForExpectations(timeout: 5) { error in
-            if error != nil {
-                XCTFail("Async erase by id is failed")
-            }
-            XCTAssert(true)
-        }
+        waitForExpectations(timeout: 5)
     }
     
 }
diff --git a/Example/CoreDataDAOTests/CoreDataDAOFoldersTests.swift b/Example/CoreDataDAOTests/CoreDataDAOFoldersTests.swift
index 420f355..9b6e267 100644
--- a/Example/CoreDataDAOTests/CoreDataDAOFoldersTests.swift
+++ b/Example/CoreDataDAOTests/CoreDataDAOFoldersTests.swift
@@ -14,30 +14,36 @@ import CoreData
 
 final class CoreDataDAOFoldersTests: XCTestCase {
     
-    let dao = try! CoreDataDAO(
-        CDFolderTranslator(),
-        configuration: CoreDataConfiguration(
-            containerName: "Model",
-            storeType: NSInMemoryStoreType))
+    private var dao: CoreDataDAO<CDFolder, Folder>!
     
+    override func setUp() {
+        super.setUp()
+        
+        let translator = CDFolderTranslator()
+        let configuration = CoreDataConfiguration(
+            containerName: "Model",
+            storeType: NSInMemoryStoreType
+        )
+        
+        dao = try! CoreDataDAO(
+            translator,
+            configuration: configuration
+        )
+    }
+    
+    override func tearDown() {
+        super.tearDown()
+        
+        dao = nil
+    }
     
     func testPersistMessages() {
         let message1 = Message(entityId: "abc", text: "text1")
         let message2 = Message(entityId: "bcc", text: "text2")
-        
         let folder = Folder(entityId: "fld", name: "Home", messages: [message1, message2])
         
-        do {
-            try dao.persist(folder)
-        } catch _ {
-            XCTFail("Persist folder is failed")
-        }
-        
-        if let savedFolder = dao.read(folder.entityId) {
-            XCTAssertEqual(folder.messages.count, savedFolder.messages.count)
-        } else {
-            XCTFail("Persist folder is failed")
-        }
+        XCTAssertNoThrow(try dao.persist(folder), "Persist folder is failed")
+        XCTAssertEqual(dao.read(folder.entityId)?.messages.count, folder.messages.count)
     }
     
 }
diff --git a/Example/CoreDataDAOTests/CoreDataDAOManyDAOTests.swift b/Example/CoreDataDAOTests/CoreDataDAOManyDAOTests.swift
index a37108e..f61acdc 100644
--- a/Example/CoreDataDAOTests/CoreDataDAOManyDAOTests.swift
+++ b/Example/CoreDataDAOTests/CoreDataDAOManyDAOTests.swift
@@ -14,30 +14,43 @@ import CoreData
 
 final class CoreDataDAOManyDAOTests: XCTestCase {
     
-    let messagesDAO = try! CoreDataDAO(
-        CDMessageTranslator(),
-        configuration: CoreDataConfiguration(
-            containerName: "Model",
-            storeType: NSInMemoryStoreType))
+    private var messagesDAO: CoreDataDAO<CDMessage, Message>!
+    private var folderDAO: CoreDataDAO<CDFolder, Folder>!
     
-    let folderDAO = try! CoreDataDAO(
-        CDFolderTranslator(),
-        configuration: CoreDataConfiguration(
+    override func setUp() {
+        super.setUp()
+        
+        let configuration = CoreDataConfiguration(
             containerName: "Model",
-            storeType: NSInMemoryStoreType))
+            storeType: NSInMemoryStoreType
+        )
+        
+        let messageTranslator = CDMessageTranslator()
+        messagesDAO = try! CoreDataDAO(
+            messageTranslator,
+            configuration: configuration
+        )
+        
+        let folderTranslator = CDFolderTranslator()
+        folderDAO = try! CoreDataDAO(
+            folderTranslator,
+            configuration: configuration
+        )
+    }
     
+    override func tearDown() {
+        super.tearDown()
+        
+        messagesDAO = nil
+        folderDAO = nil
+    }
     
     func testPersistMessage() {
         let message = Message(entityId: "abc", text: "text")
         let folder = Folder(entityId: "fld", name: "folder", messages: [])
         
-        do {
-            try messagesDAO.persist(message)
-            try folderDAO.persist(folder)
-        } catch _ {
-            XCTFail("Persist message is failed")
-        }
-        
+        XCTAssertNoThrow(try messagesDAO.persist(message), "Persist message is failed")
+        XCTAssertNoThrow(try folderDAO.persist(folder), "Persist message is failed")
         XCTAssertEqual(message, messagesDAO.read(message.entityId))
         XCTAssertEqual(folder, folderDAO.read(folder.entityId))
     }
diff --git a/Example/CoreDataDAOTests/CoreDataDAOMessagesTests.swift b/Example/CoreDataDAOTests/CoreDataDAOMessagesTests.swift
index bb66476..8caf3d8 100644
--- a/Example/CoreDataDAOTests/CoreDataDAOMessagesTests.swift
+++ b/Example/CoreDataDAOTests/CoreDataDAOMessagesTests.swift
@@ -14,52 +14,49 @@ import CoreData
 
 final class CoreDataDAOMessagesTests: XCTestCase {
     
-    let dao = try! CoreDataDAO(
-        CDMessageTranslator(),
-        configuration: CoreDataConfiguration(
-            containerName: "Model",
-            storeType: NSInMemoryStoreType))
+    private var dao: CoreDataDAO<CDMessage, Message>!
     
+    override func setUp() {
+        super.setUp()
+        
+        let translator = CDMessageTranslator()
+        let configuration = CoreDataConfiguration(
+            containerName: "Model",
+            storeType: NSInMemoryStoreType
+        )
+        
+        dao = try! CoreDataDAO(
+            translator,
+            configuration: configuration
+        )
+    }
+    
+    override func tearDown() {
+        super.tearDown()
+        
+        dao = nil
+    }
     
     func testPersistMessage() {
         let message = Message(entityId: "abc", text: "text")
         
-        do {
-            try dao.persist(message)
-        } catch _ {
-            XCTFail("Persist message is failed")
-        }
-        
+        XCTAssertNoThrow(try dao.persist(message), "Persist message is failed")
         XCTAssertEqual(message, dao.read(message.entityId))
     }
     
-    
     func testReadMessage() {
         let message = Message(entityId: "def", text: "text 2")
         
-        do {
-            try dao.persist(message)
-        } catch _ {
-            XCTFail("Read message is failed")
-        }
-        
+        XCTAssertNoThrow(try dao.persist(message), "Read message is failed")
         XCTAssertEqual(message, dao.read("def"))
     }
     
-    
     func testEraseMessage() {
         let message = Message(entityId: "ghi", text: "text 2")
         
-        do {
-            try dao.persist(message)
-            try dao.erase("ghi")
-        } catch _ {
-            XCTFail("Erase message is failed")
-        }
-        
+        XCTAssertNoThrow(try dao.persist(message), "Erase message is failed")
+        XCTAssertNoThrow(try dao.erase("ghi"), "Erase message is failed")
         XCTAssertNil(dao.read("ghi"))
     }
-
-    
     
 }