             expect.fulfill()
         }
         
-        // pause at time between _interruptableTask's 1st & 2nd delay (t=0.3)
+        // pause at t=0.3 (between _interruptableTask's 1st & 2nd delay before pause-check)
         Async.main(after: 0.3) {
             
-            // NOTE: parentTask should also be paused (if not, `task` will never be fulfilled/rejected)
+            // NOTE: task2 will be paused,
             task2.pause()
-            
-            XCTAssertNil(innerTask, "`innerTask` has not been created yet.")
             
             XCTAssertEqual(task2.state, TaskState.Paused)
             XCTAssertNil(task2.progress, "`task2.progress` should be nil because `innerTask.progress()` has not been invoked yet.")
             
-            XCTAssertEqual(task.state, TaskState.Paused, "Parent task should also be paused.")
-            XCTAssertTrue(task.progress? == 2)
-            
-            // resume after 0.3sec (t=0.6)
+            XCTAssertNil(innerTask, "`innerTask` should NOT be created yet.")
+            
+            XCTAssertEqual(task.state, TaskState.Running, "`task` should NOT be paused.")
+            XCTAssertTrue(task.progress? == 2, "`task` should be halfway progressed.")
+            XCTAssertNil(task.value, "`task` should NOT be fulfilled yet.")
+            
+            // resume at t=0.6
             Async.main(after: 0.3) {
                 
                 XCTAssertEqual(task2.state, TaskState.Paused)
                 XCTAssertNil(task2.progress, "`task2.progress` should still be nil.")
                 
-                XCTAssertEqual(task.state, TaskState.Paused, "Parent task should also be paused.")
-                XCTAssertTrue(task.progress? == 2)
+                XCTAssertNotNil(innerTask, "`innerTask` should be created at this point.")
+                XCTAssertEqual(innerTask!.state, task2.state, "`innerTask!.state` should be same as `task2.state`.")
+                
+                XCTAssertEqual(task.state, TaskState.Fulfilled, "`task` should NOT be paused, and it should be fulfilled at this point.")
+                XCTAssertEqual(task.value!, "OK", "`task` should be fulfilled.")
                 
                 task2.resume()
-                XCTAssertEqual(task2.state, TaskState.Running)
-                XCTAssertEqual(task.state, TaskState.Running, "Parent task should also be resumed.")
-                
-            }
-        }
-        
-        self.wait()
-    }
-    
-    func testPauseResume_async_success()
-    {
-        // NOTE: this is async test
-        if !self.isAsync { return }
-        
-        var expect = self.expectationWithDescription(__FUNCTION__)
-        
-        let task = _interruptableTask(progressCount: 5)
-        weak var innerTask: _InterruptableTask?
-        
-        // chain async-task with success
-        let task2 = task.success { [weak self] _ -> _InterruptableTask in
-            innerTask = _interruptableTask(progressCount: 5)
-            return innerTask!
-        }
-        
-        task2.success { value -> Void in
-            XCTAssertEqual(value, "OK")
-            expect.fulfill()
-        }
-        
-        // pause at time between _interruptableTask's 1st & 2nd delay (t=0.3)
-        Async.main(after: 0.3) {
-            
-            // NOTE: parentTask should also be paused (if not, `task` will never be fulfilled/rejected)
-            task2.pause()
-            
-            XCTAssertEqual(task2.state, TaskState.Paused)
-            XCTAssertNil(task2.progress, "`task2.progress` should be nil because `innerTask.progress()` has not been invoked yet.")
-            
-            XCTAssertEqual(task.state, TaskState.Paused, "Parent task should also be paused.")
-            XCTAssertTrue(task.progress? == 2)
-            
-            // resume after 0.3sec (t=0.6)
-            Async.main(after: 0.3) {
-                
-                XCTAssertNil(innerTask, "`innerTask` has not been created yet.")
-                
-                XCTAssertEqual(task2.state, TaskState.Paused)
-                XCTAssertNil(task2.progress, "`task2.progress` should still be nil.")
-                
-                XCTAssertEqual(task.state, TaskState.Paused, "Parent task should also be paused.")
-                XCTAssertTrue(task.progress? == 2)
-                
-                task2.resume()
-                XCTAssertEqual(task2.state, TaskState.Running)
-                XCTAssertEqual(task.state, TaskState.Running, "Parent task should also be resumed.")
-                
-            }
-        }
-        
-        self.wait()
-    }
-
-    func testPauseResume_async_failure()
-    {
-        // NOTE: this is async test
-        if !self.isAsync { return }
-        
-        var expect = self.expectationWithDescription(__FUNCTION__)
-        
-        let task = _interruptableTask(progressCount: 5)
-        weak var innerTask: _InterruptableTask?
-        
-        // chain async-task with failure
-        let task2 = task.failure { [weak self] _ -> _InterruptableTask in
-            innerTask = _interruptableTask(progressCount: 5)
-            return innerTask!
-        }
-            
-        task2.success { value -> Void in
-            XCTAssertEqual(value, "OK")
-            expect.fulfill()
-        }
-        
-        // pause at time between _interruptableTask's 1st & 2nd delay (t=0.3)
-        Async.main(after: 0.3) {
-            
-            // NOTE: parentTask should also be paused (if not, `task` will never be fulfilled/rejected)
-            task2.pause()
-            
-            XCTAssertEqual(task2.state, TaskState.Paused)
-            XCTAssertNil(task2.progress, "`task2.progress` should be nil because `innerTask.progress()` has not been invoked yet.")
-            
-            XCTAssertEqual(task.state, TaskState.Paused, "Parent task should also be paused.")
-            XCTAssertTrue(task.progress? == 2)
-            
-            // resume after 0.3sec (t=0.6)
-            Async.main(after: 0.3) {
-                
-                XCTAssertEqual(task2.state, TaskState.Paused)
-                XCTAssertNil(task2.progress, "`task2.progress` should still be nil.")
-                
-                XCTAssertEqual(task.state, TaskState.Paused, "Parent task should also be paused.")
-                XCTAssertTrue(task.progress? == 2)
-                
-                task2.resume()
-                XCTAssertEqual(task2.state, TaskState.Running)
-                XCTAssertEqual(task.state, TaskState.Running, "Parent task should also be resumed.")
+                
+                XCTAssertEqual(task2.state, TaskState.Running, "`task2` should be resumed.")
+                
+                // check tasks's states at t=0.7
+                Async.main(after: 0.1) {
+                    XCTAssertEqual(task2.state, TaskState.Running)
+                    XCTAssertEqual(innerTask!.state, task2.state, "`innerTask!.state` should be same as `task2.state`.")
+                    XCTAssertEqual(task.state, TaskState.Fulfilled)
+                }
                 
             }
         }

        let task = _interruptableTask(progressCount: 5)
        weak var innerTask: _InterruptableTask?
        
        // chain async-task with then
        let task2 = task.then { [weak self] _ -> _InterruptableTask in
            innerTask = _interruptableTask(progressCount: 5)
            return innerTask!

            
        }
        
        // pause at t=0.3 (between _interruptableTask's 1st & 2nd delay before pause-check)
        Async.main(after: 0.3) {
            
            task.pause()
            
            XCTAssertEqual(task.state, TaskState.Paused)
            XCTAssertTrue(task.progress? == 2, "`task` should be progressed halfway.")
            
            // resume at t=0.6
            Async.main(after: 0.3) {
                
                XCTAssertEqual(task.state, TaskState.Paused)
                XCTAssertTrue(task.progress? == 2, "`task` should pause progressing.")
                
                task.resume()
                
                XCTAssertEqual(task.state, TaskState.Running, "`task` should start running again.")
                
            }
        }
        
        self.wait()
    }
    
    func testPauseResume_innerTask()
    {
        // NOTE: this is async test
        if !self.isAsync { return }
