         for observer in taskObservers {
             observer.taskOperationDidSuspend(self)
         }
+        
+        return self
+    }
+    
+    // MARK: Overrided methods
+    
+    override open func finished(_ errors: [Error]) {
+        completeOperations.removeAll()
+        internalQueue.isSuspended = true
+        state = .finished
+        for observer in taskObservers {
+            observer.taskOperationDidFinish(self)
+        }
+    }
+    
+    override open func execute() {
+        resume()
+        internalQueue.addOperation(finishingOperation)
     }
 }
 

    
    /// Adds the operation to the internal queue
    open func addOperation(_ operation: Foundation.Operation) {
        internalQueue.addOperation(operation)
    }
    
    /// Adds multiple operations to the queue
    open func addOperations(_ operations: [Foundation.Operation]) {
        internalQueue.addOperations(operations)
    }
    
    /// Adds the new error to the internal errors array

            }
        }
        
        for operation in internalQueue.operations {
            guard operation !== finishingOperation && operation !== startingOperation else { continue }
            
            completeOperation.addDependency(operation)
        }
        
        completeOperations.append(completeOperation)
        finishingOperation.addDependency(completeOperation)
        internalQueue.addOperation(completeOperation)
        return self
    }
    
    /// resume all the operations in the queue
    @discardableResult
    public final func resume() -> TaskOperation {
        assert(state == .suspended)
        
        state = .running
        internalQueue.isSuspended = false
        for observer in taskObservers {
            observer.taskOperationDidResume(self)
        }
        
        return self
    }
    
    /// suspends all the operations in the current queue
    @discardableResult
    public final func suspend() -> TaskOperation {
        assert(state == .running)
        
        state = .suspended
