     # A list of suites and test runners.
     @_tests_and_suites = []
   
-  # (callback) -> undefined
-  _run: (callback,
-      before_alls=[], before_eachs=[], after_eachs=[], index=0,
-      report={
-        total_tests: 0
+  # (callback, before_alls=[], before_eachs=[], after_eachs=[],
+  #   index=0, report={}) -> undefined
+  #
+  # Params:
+  #   callback: A function called when the entirty of the suite is done.
+  #   before_alls: Optional. A list of before_alls to start with.
+  #   before_eachs: Optional. A list of before_eachs to start with.
+  #   after_eachs: Optional. A list of after_eachs to start with.
+  #   index: Optional. The index of @_tests_and_suites this recursive
+  #     iteration is currently at.
+  #   report: Optional. The compiled report from any tests and suites ran.
+  #
+  # Desc:
+  #   An internal function which iterates over @_tests_and_suites. It includes
+  #   optional arguments for parental pre/post hooks as well.
+  _run: (callback, before_alls=[], before_eachs=[], after_eachs=[], index=0,
+        report={
+          total_tests: 0
         }) =>
     
+    # If we're at the start of the iterations, append @this's pre/post
+    # hook runners to the supplied argument pre/post runners.
     if index is 0
       before_alls.push @_before_alls...
       before_eachs.push @_before_eachs...
+      # Note that the after_each's need to be added to the *beginning*
+      # of the list. This allows the following design..
+      # Their Befores > Our Befores > Test < Our Afters < Their Afters
       after_eachs[...0] = @_after_eachs
     
+    # Our test or suite
     item = @_tests_and_suites[index]
     
+    # If item does not exist, callback
     if not item?
+      # If we have one or more tests, run the after_all runners, and
+      # then callback.
       if report.total_tests > 0
         @_run_runners @_after_alls, ->
           callback report

      @_run callback, before_alls, before_eachs, after_eachs, ++index, report
    
    if item instanceof Test
      runners = []
      runners.push before_alls...
      runners.push before_eachs...
      @_run_runners runners, before_alls_callback
    else
      item._run suite_callback, before_alls[..],
        before_eachs[..], after_eachs[..]
  
  _run_runners: (runners, callback, index=0, reports=[]) =>
    runner = runners[index]
    
    if not runner?
      callback reports
      return
    
    runner.run (report) =>
      reports.push report
      @_run_runners runners, callback, ++index, reports

        callback report
      return
    
    # Called after @_run_runners is finished iterating through befores.
    # Note that these are both `before_alls` and `before_eachs`
    befores_callback = (runner_reports) =>
      # Since we just ran before_alls, empty it if we need to.
      if before_alls.length > 0
        before_alls = []
      item.run test_callback
    
    # Called when our test is done.
    test_callback = (test_report) =>
      # We're just faking the report for now.
      report.total_tests += 1
      @_run_runners after_eachs, after_eachs_callback
    
    # Called after `@_run_runners` is finished iterating through `after_eachs`
    after_eachs_callback = (runner_reports) =>
      @_run callback, before_alls, before_eachs, after_eachs, ++index, report
    
    # Called when item is a suite, and `item._run` has finished.
    suite_callback = (suite_report) =>
      if suite_report.total_tests > 0
        before_alls = []
