diff --git a/akka-docs/scala/testing.rst b/akka-docs/scala/testing.rst
index f3bb07c5bb..e8b20aa830 100644
--- a/akka-docs/scala/testing.rst
+++ b/akka-docs/scala/testing.rst
@@ -288,6 +288,13 @@ assertions concerning received messages. Here is the full list:
     does a conformance check; if you need the class to be equal, have a look at
     :meth:`expectMsgAllClassOf` with a single given class argument.
 
+  * :meth:`expectMsgType[T: Manifest](d: Duration)`
+
+    An object which is an instance of the given type (after erasure) must be
+    received within the allotted time frame; the object will be returned. This
+    method is approximately equivalent to
+    ``expectMsgClass(manifest[T].erasure)``.
+
   * :meth:`expectMsgAnyOf[T](d: Duration, obj: T*): T`
 
     An object must be received within the given time, and it must be equal (
@@ -398,21 +405,25 @@ is between :obj:`min` and :obj:`max`, where the former defaults to zero. The
 deadline calculated by adding the :obj:`max` parameter to the block's start
 time is implicitly available within the block to all examination methods, if
 you do not specify it, is is inherited from the innermost enclosing
-:meth:`within` block. It should be noted that using :meth:`expectNoMsg` will
-terminate upon reception of a message or at the deadline, whichever occurs
-first; it follows that this examination usually is the last statement in a
 :meth:`within` block.
 
+It should be noted that if the last message-receiving assertion of the block is
+:meth:`expectNoMsg` or :meth:`receiveWhile`, the final check of the
+:meth:`within` is skipped in order to avoid false positives due to wake-up
+latencies. This means that while individual contained assertions still use the
+maximum time bound, the overall block may take arbitrarily longer in this case.
+
 .. code-block:: scala
 
   class SomeSpec extends WordSpec with MustMatchers with TestKit {
     "A Worker" must {
       "send timely replies" in {
         val worker = actorOf(...)
-        within (50 millis) {
+        within (500 millis) {
           worker ! "some work"
           expectMsg("some result")
-          expectNoMsg
+          expectNoMsg        // will block for the rest of the 500ms
+          Thread.sleep(1000) // will NOT make this block fail
         }
       }
     }
diff --git a/akka-testkit/src/main/scala/akka/testkit/TestKit.scala b/akka-testkit/src/main/scala/akka/testkit/TestKit.scala
index bb9f69168b..10727ffc7c 100644
--- a/akka-testkit/src/main/scala/akka/testkit/TestKit.scala
+++ b/akka-testkit/src/main/scala/akka/testkit/TestKit.scala
@@ -110,13 +110,12 @@ trait TestKitLight {
   val senderOption = Some(testActor)
 
   private var end: Duration = Duration.Inf
-  /*
-   * THIS IS A HACK: expectNoMsg and receiveWhile are bounded by `end`, but
-   * running them should not trigger an AssertionError, so mark their end
-   * time here and do not fail at the end of `within` if that time is not
-   * long gone.
+
+  /**
+   * if last assertion was expectNoMsg, disable timing failure upon within()
+   * block end.
    */
-  private var lastSoftTimeout: Duration = now - 5.millis
+  private var lastWasNoMsg = false
 
   /**
    * Stop test actor. Should be done at the end of the test unless relying on
@@ -211,6 +210,8 @@ trait TestKitLight {
     val rem = end - start
     assert(rem >= min, "required min time " + min + " not possible, only " + format(min.unit, rem) + " left")
 
+    lastWasNoMsg = false
+
     val max_diff = _max min rem
     val prev_end = end
     end = start + max_diff
@@ -219,13 +220,8 @@ trait TestKitLight {
 
     val diff = now - start
     assert(min <= diff, "block took " + format(min.unit, diff) + ", should at least have been " + min)
-    /*
-     * caution: HACK AHEAD
-     */
-    if (now - lastSoftTimeout > 5.millis) {
+    if (!lastWasNoMsg) {
       assert(diff <= max_diff, "block took " + format(_max.unit, diff) + ", exceeding " + format(_max.unit, max_diff))
-    } else {
-      lastSoftTimeout -= 5.millis
     }
 
     ret
@@ -302,6 +298,20 @@ trait TestKitLight {
     f(o)
   }
 
+  /**
+   * Same as `expectMsgType[T](remaining)`, but correctly treating the timeFactor.
+   */
+  def expectMsgType[T](implicit m: Manifest[T]): T = expectMsgClass_internal(remaining, m.erasure.asInstanceOf[Class[T]])
+
+  /**
+   * Receive one message from the test actor and assert that it conforms to the
+   * given type (after erasure). Wait time is bounded by the given duration,
+   * with an AssertionFailure being thrown in case of timeout.
+   *
+   * @return the received object
+   */
+  def expectMsgType[T](max: Duration)(implicit m: Manifest[T]): T = expectMsgClass_internal(max.dilated, m.erasure.asInstanceOf[Class[T]])
+
   /**
    * Same as `expectMsgClass(remaining, c)`, but correctly treating the timeFactor.
    */
@@ -454,7 +464,7 @@ trait TestKitLight {
   private def expectNoMsg_internal(max: Duration) {
     val o = receiveOne(max)
     assert(o eq null, "received unexpected message " + o)
-    lastSoftTimeout = now
+    lastWasNoMsg = true
   }
 
   /**
@@ -503,7 +513,7 @@ trait TestKitLight {
     }
 
     val ret = doit(Nil)
-    lastSoftTimeout = now
+    lastWasNoMsg = true
     ret
   }
 
@@ -543,6 +553,7 @@ trait TestKitLight {
       } else {
         queue.takeFirst
       }
+    lastWasNoMsg = false
     message match {
       case null ⇒
         lastMessage = NullMessage