// Transforms a stream of TAP into a stream of result objects
// and string comments.  Emits "results" event with summary.
var Writable = require('stream').Writable
/* istanbul ignore if */
if (!Writable) {
  try {
    Writable = require('readable-stream').Writable
  } catch (er) {
    throw new Error('Please install "readable-stream" to use this module ' +
                    'with Node.js v0.8 and before')
  }
}

var yaml = require('js-yaml')
var util = require('util')
var assert = require('assert')

util.inherits(Parser, Writable)

module.exports = Parser

// every line outside of a yaml block is one of these things, or
// a comment, or garbage.
var lineTypes = {
  testPoint: /^(not )?ok(?: ([0-9]+))?(?:(?: -)?( .*?))?(\{?)\n$/,
  pragma: /^pragma ([+-])([a-z]+)\n$/,
  bailout: /^bail out!(.*)\n$/i,
  version: /^TAP version ([0-9]+)\n$/i,
  childVersion: /^(    )+TAP version ([0-9]+)\n$/i,
  plan: /^([0-9]+)\.\.([0-9]+)(?:\s+(?:#\s*(.*)))?\n$/,
  subtest: /^# Subtest(?:: (.*))?\n$/,
  subtestIndent: /^    # Subtest(?:: (.*))?\n$/,
  comment: /^\s*#.*\n$/
}

var lineTypeNames = Object.keys(lineTypes)

function lineType (line) {
  for (var t in lineTypes) {
    var match = line.match(lineTypes[t])
    if (match)
      return [t, match]
  }
  return null
}

function parseDirective (line) {
  if (!line.trim())
    return false

  line = line.replace(/\{\s*$/, '').trim()
  var time = line.match(/^time=((?:[1-9][0-9]*|0)(?:\.[0-9]+)?)(ms|s)$/i)
  if (time) {
    var n = +time[1]
    if (time[2] === 's') {
      // JS does weird things with floats.  Round it off a bit.
      n *= 1000000
      n = Math.round(n)
      n /= 1000
    }
    return [ 'time', n ]
  }

  var type = line.match(/^(todo|skip)\b/i)
  if (!type)
    return false

  return [ type[1].toLowerCase(), line.substr(type[1].length).trim() || true ]
}

function Result (parsed, count) {
  var ok = !parsed[1]
  var id = +(parsed[2] || count + 1)
  var buffered = parsed[4]
  this.ok = ok
  this.id = id

  var rest = parsed[3] || ''
  var name
  rest = rest.replace(/([^\\]|^)((?:\\\\)*)#/g, '$1\n$2').split('\n')
  name = rest.shift()
  rest = rest.filter(function (r) { return r.trim() }).join('#')

  // now, let's see if there's a directive in there.
  var dir = parseDirective(rest.trim())
  if (!dir)
    name += (rest ? '#' + rest : '') + buffered
  else {
    // handle buffered subtests with todo/skip on them, like
    // ok 1 - bar # todo foo {\n
    var dirKey = dir[0]
    var dirValue = dir[1]
    this[dirKey] = dirValue
  }

  if (/\{\s*$/.test(name)) {
    name = name.replace(/\{\s*$/, '')
    buffered = '{'
  }

  if (buffered === '{')
    this.buffered = true

  if (name)
    this.name = name.trim()

  return this
}

function Parser (options, onComplete) {
  if (typeof options === 'function') {
    onComplete = options
    options = {}
  }

  if (!(this instanceof Parser))
    return new Parser(options, onComplete)

  options = options || {}
  if (onComplete)
    this.on('complete', onComplete)

  this.comments = []
  this.results = null
  this.braceLevel = null
  this.parent = options.parent || null
  this.failures = []
  if (options.passes)
    this.passes = []
  this.level = options.level || 0
  Writable.call(this)
  this.buffer = ''
  this.bail = !!options.bail
  this.bailingOut = false
  this.bailedOut = false
  this.syntheticBailout = false
  this.syntheticPlan = false
  this.omitVersion = !!options.omitVersion
  this.planStart = -1
  this.planEnd = -1
  this.planComment = ''
  this.yamlish = ''
  this.yind = ''
  this.child = null
  this.current = null
  this.maybeSubtest = null
  this.extraQueue = []
  this.buffered = options.buffered || null
  this.aborted = false
  this.preserveWhitespace = options.preserveWhitespace || false

  this.count = 0
  this.pass = 0
  this.fail = 0
  this.todo = 0
  this.skip = 0
  this.ok = true

  this.strict = options.strict || false
  this.pragmas = { strict: this.strict }

  this.postPlan = false
}

Parser.prototype.tapError = function (error, line) {
  if (line)
    this.emit('line', line)
  this.ok = false
  this.fail ++
  if (typeof error === 'string') {
    error = {
      tapError: error
    }
  }
  this.failures.push(error)
}

Parser.prototype.parseTestPoint = function (testPoint, line) {
  this.emitResult()
  if (this.bailedOut)
    return

  this.emit('line', line)
  var res = new Result(testPoint, this.count)
  if (this.planStart !== -1) {
    var lessThanStart = +res.id < this.planStart
    var greaterThanEnd = +res.id > this.planEnd
    if (lessThanStart || greaterThanEnd) {
      if (lessThanStart)
        res.tapError = 'id less than plan start'
      else
        res.tapError = 'id greater than plan end'
      res.plan = { start: this.planStart, end: this.planEnd }
      this.tapError(res)
    }
  }

  if (res.id) {
    if (!this.first || res.id < this.first)
      this.first = res.id
    if (!this.last || res.id > this.last)
      this.last = res.id
  }

  if (!res.skip && !res.todo)
    this.ok = this.ok && res.ok

  // hold onto it, because we might get yamlish diagnostics
  this.current = res
}

Parser.prototype.nonTap = function (data, didLine) {
  if (this.bailingOut && /^( {4})*\}\n$/.test(data))
    return

  if (this.strict) {
    var err = {
      tapError: 'Non-TAP data encountered in strict mode',
      data: data
    }
    this.tapError(err)
    if (this.parent)
      this.parent.tapError(err)
  }

  // emit each line, then the extra as a whole
  if (!didLine)
    data.split('\n').slice(0, -1).forEach(function (line) {
      line += '\n'
      if (this.current || this.extraQueue.length)
        this.extraQueue.push(['line', line])
      else
        this.emit('line', line)
    }, this)

  if (this.current || this.extraQueue.length)
    this.extraQueue.push(['extra', data])
  else
    this.emit('extra', data)
}

Parser.prototype.plan = function (start, end, comment, line) {
  // not allowed to have more than one plan
  if (this.planStart !== -1) {
    this.nonTap(line)
    return
  }

  // can't put a plan in a child.
  if (this.child || this.yind) {
    this.nonTap(line)
    return
  }

  this.emitResult()
  if (this.bailedOut)
    return

  // 1..0 is a special case. Otherwise, end must be >= start
  if (end < start && end !== 0 && start !== 1) {
    if (this.strict)
      this.tapError({
        tapError: 'plan end cannot be less than plan start',
        plan: {
          start: start,
          end: end
        }
      }, line)
    else
      this.nonTap(line)
    return
  }

  this.planStart = start
  this.planEnd = end
  var p = { start: start, end: end }
  if (comment)
    this.planComment = p.comment = comment

  // This means that the plan is coming at the END of all the tests
  // Plans MUST be either at the beginning or the very end.  We treat
  // plans like '1..0' the same, since they indicate that no tests
  // will be coming.
  if (this.count !== 0 || this.planEnd === 0)
    this.postPlan = true

  this.emit('line', line)
  this.emit('plan', p)
}

Parser.prototype.resetYamlish = function () {
  this.yind = ''
  this.yamlish = ''
}

// that moment when you realize it's not what you thought it was
Parser.prototype.yamlGarbage = function () {
  var yamlGarbage = this.yind + '---\n' + this.yamlish
  this.emitResult()
  if (this.bailedOut)
    return
  this.nonTap(yamlGarbage, true)
}

Parser.prototype.yamlishLine = function (line) {
  if (line === this.yind + '...\n') {
    // end the yaml block
    this.processYamlish()
  } else {
    this.yamlish += line
  }
}

Parser.prototype.processYamlish = function () {
  var yamlish = this.yamlish
  this.resetYamlish()

  try {
    var diags = yaml.safeLoad(yamlish)
  } catch (er) {
    this.nonTap(this.yind + '---\n' + yamlish + this.yind + '...\n', true)
    return
  }

  this.current.diag = diags
  // we still don't emit the result here yet, to support diags
  // that come ahead of buffered subtests.
}

Parser.prototype.write = function (chunk, encoding, cb) {
  if (this.aborted)
    return

  if (typeof encoding === 'string' && encoding !== 'utf8')
    chunk = new Buffer(chunk, encoding)

  if (Buffer.isBuffer(chunk))
    chunk += ''

  if (typeof encoding === 'function') {
    cb = encoding
    encoding = null
  }

  this.buffer += chunk
  do {
    var match = this.buffer.match(/^.*\r?\n/)
    if (!match)
      break

    this.buffer = this.buffer.substr(match[0].length)
    this.parse(match[0])
  } while (this.buffer.length)

  if (cb)
    process.nextTick(cb)
  return true
}

Parser.prototype.end = function (chunk, encoding, cb) {
  if (chunk) {
    if (typeof encoding === 'function') {
      cb = encoding
      encoding = null
    }
    this.write(chunk, encoding)
  }

  if (this.buffer)
    this.write('\n')

  // if we have yamlish, means we didn't finish with a ...
  if (this.yamlish)
    this.yamlGarbage()

  this.emitResult()

  if (this.syntheticBailout && this.level === 0) {
    var reason = this.bailedOut
    if (reason === true)
      reason = ''
    else
      reason = ' ' + reason
    this.emit('line', 'Bail out!' + reason + '\n')
  }

  var skipAll

  if (this.planEnd === 0 && this.planStart === 1) {
    skipAll = true
    if (this.count === 0) {
      this.ok = true
    } else {
      this.tapError('Plan of 1..0, but test points encountered')
    }
  } else if (!this.bailedOut && this.planStart === -1) {
    if (this.count === 0 && !this.syntheticPlan) {
      this.syntheticPlan = true
      this.plan(1, 0, 'no tests found', '1..0 # no tests found\n')
      skipAll = true
    } else {
      this.tapError('no plan')
    }
  } else if (this.ok && this.count !== (this.planEnd - this.planStart + 1)) {
    this.tapError('incorrect number of tests')
  }

  if (this.ok && !skipAll && this.first !== this.planStart) {
    this.tapError('first test id does not match plan start')
  }

  if (this.ok && !skipAll && this.last !== this.planEnd) {
    this.tapError('last test id does not match plan end')
  }

  Writable.prototype.end.call(this, null, null, cb)
  this.emitComplete(skipAll)
}

Parser.prototype.emitComplete = function (skipAll) {
  if (!this.results) {
    var res = this.results = new FinalResults(!!skipAll, this)

    if (!res.bailout) {
      // comment a bit at the end so we know what happened.
      // but don't repeat these comments if they're already present.
      if (res.plan.end !== res.count)
        this.emitComment('test count(' + res.count +
                         ') != plan(' + res.plan.end + ')', false, true)

      if (res.fail > 0 && !res.ok)
        this.emitComment('failed ' + res.fail +
                         (res.count > 1 ? ' of ' + res.count + ' tests'
                          : ' test'),
                         false, true)

      if (res.todo > 0)
        this.emitComment('todo: ' + res.todo, false, true)

      if (res.skip > 0)
        this.emitComment('skip: ' + res.skip, false, true)
    }

    this.emit('complete', this.results)
  }
}

function FinalResults (skipAll, self) {
  this.ok = self.ok
  this.count = self.count
  this.pass = self.pass
  this.fail = self.fail || 0
  this.bailout = self.bailedOut || false
  this.todo = self.todo || 0
  this.skip = skipAll ? self.count : self.skip || 0
  this.plan = new FinalPlan(skipAll, self)
  this.failures = self.failures
  if (self.passes)
    this.passes = self.passes
}

function FinalPlan (skipAll, self) {
  this.start = self.planStart === -1 ? null : self.planStart
  this.end = self.planStart === -1 ? null : self.planEnd
  this.skipAll = skipAll
  this.skipReason = skipAll ? self.planComment : ''
  this.comment = self.planComment || ''
}

Parser.prototype.version = function (version, line) {
  // If version is specified, must be at the very beginning.
  if (version >= 13 &&
      this.planStart === -1 &&
      this.count === 0 &&
      !this.current) {
    this.emit('line', line)
    this.emit('version', version)
  } else
    this.nonTap(line)
}

Parser.prototype.pragma = function (key, value, line) {
  // can't put a pragma in a child or yaml block
  if (this.child) {
    this.nonTap(line)
    return
  }

  this.emitResult()
  if (this.bailedOut)
    return
  // only the 'strict' pragma is currently relevant
  if (key === 'strict') {
    this.strict = value
  }
  this.pragmas[key] = value
  this.emit('line', line)
  this.emit('pragma', key, value)
}

Parser.prototype.bailout = function (reason, synthetic) {
  this.syntheticBailout = synthetic

  if (this.bailingOut)
    return

  // Guard because emitting a result can trigger a forced bailout
  // if the harness decides that failures should be bailouts.
  this.bailingOut = reason || true

  if (!synthetic)
    this.emitResult()
  else
    this.current = null

  this.bailedOut = this.bailingOut
  this.ok = false
  if (!synthetic) {
    // synthetic bailouts get emitted on end
    var line = 'Bail out!'
    if (reason)
      line += ' ' + reason
    this.emit('line', line + '\n')
  }
  this.emit('bailout', reason)
  if (this.parent) {
    this.end()
    this.parent.bailout(reason, true)
  }
}

Parser.prototype.clearExtraQueue = function () {
  for (var c = 0; c < this.extraQueue.length; c++) {
    this.emit(this.extraQueue[c][0], this.extraQueue[c][1])
  }
  this.extraQueue.length = 0
}

Parser.prototype.endChild = function () {
  if (this.child) {
    this.child.end()
    this.child = null
  }
}

Parser.prototype.emitResult = function () {
  if (this.bailedOut)
    return

  this.endChild()
  this.resetYamlish()

  if (!this.current)
    return this.clearExtraQueue()

  var res = this.current
  this.current = null

  this.count++
  if (res.ok) {
    this.pass++
    if (this.passes)
      this.passes.push(res)
  } else {
    this.fail++
    if (!res.todo && !res.skip) {
      this.ok = false
      this.failures.push(res)
    }
  }

  if (res.skip)
    this.skip++

  if (res.todo)
    this.todo++

  this.emit('assert', res)
  if (this.bail && !res.ok && !res.todo && !res.skip && !this.bailingOut) {
    this.maybeChild = null
    var ind = new Array(this.level + 1).join('    ')
    for (var p = this; p.parent; p = p.parent);
    var bailName = res.name ? ' # ' + res.name : ''
    p.parse(ind + 'Bail out!' + bailName + '\n')
  }
  this.clearExtraQueue()
}

// TODO: We COULD say that any "relevant tap" line that's indented
// by 4 spaces starts a child test, and just call it 'unnamed' if
// it does not have a prefix comment.  In that case, any number of
// 4-space indents can be plucked off to try to find a relevant
// TAP line type, and if so, start the unnamed child.
Parser.prototype.startChild = function (line) {
  var maybeBuffered = this.current && this.current.buffered
  var unindentStream = !maybeBuffered && this.maybeChild
  var indentStream = !maybeBuffered && !unindentStream &&
    lineTypes.subtestIndent.test(line)
  var unnamed = !maybeBuffered && !unindentStream && !indentStream

  // If we have any other result waiting in the wings, we need to emit
  // that now.  A buffered test emits its test point at the *end* of
  // the child subtest block, so as to match streamed test semantics.
  if (!maybeBuffered)
    this.emitResult()

  if (this.bailedOut)
    return

  this.child = new Parser({
    bail: this.bail,
    parent: this,
    level: this.level + 1,
    buffered: maybeBuffered,
    preserveWhitespace: this.preserveWhitespace,
    omitVersion: true,
    strict: this.strict
  })

  var self = this
  this.child.on('complete', function (results) {
    if (!results.ok)
      self.ok = false
  })

  this.child.on('line', function (l) {
    if (this.syntheticPlan)
      return

    if (l.trim() || self.preserveWhitespace)
      l = '    ' + l
    self.emit('line', l)
  })

  // Canonicalize the parsing result of any kind of subtest
  // if it's a buffered subtest or a non-indented Subtest directive,
  // then synthetically emit the Subtest comment
  line = line.substr(4)
  var subtestComment
  if (indentStream) {
    subtestComment = line
    line = null
  } else if (maybeBuffered) {
    subtestComment = '# Subtest: ' + this.current.name + '\n'
  } else {
    subtestComment = this.maybeChild || '# Subtest: (anonymous)\n'
  }

  this.maybeChild = null
  this.child.name = subtestComment.substr('# Subtest: '.length).trim()

  // at some point, we may wish to move 100% to preferring
  // the Subtest comment on the parent level.  If so, uncomment
  // this line, and remove the child.emitComment below.
  // this.emit('comment', subtestComment)
  if (!this.child.buffered)
    this.emit('line', subtestComment)
  this.emit('child', this.child)
  this.child.emitComment(subtestComment, true)
  if (line)
    this.child.parse(line)
}

Parser.prototype.abort = function (message, extra) {
  if (this.child) {
    var b = this.child.buffered
    this.child.abort(message, extra)
    extra = null
    if (b)
      this.write('\n}\n')
  }

  var dump
  if (extra && Object.keys(extra).length) {
    try {
      dump = yaml.safeDump(extra).trimRight()
    } catch (er) {}
  }

  var y
  if (dump)
    y = '  ---\n  ' + dump.split('\n').join('\n  ') + '\n  ...\n'
  else
    y = '\n'
  var n = (this.count || 0) + 1
  if (this.current)
    n += 1

  if (this.planEnd !== -1 && this.planEnd < n && this.parent) {
    // skip it, let the parent do this.
    this.aborted = true
    return
  }

  var ind = '' // new Array(this.level + 1).join('    ')
  message = message.replace(/[\n\r\s\t]/g, ' ')
  var point = '\nnot ok ' + n + ' - ' + message + '\n' + y

  if (this.planEnd === -1)
    point += '1..' + n + '\n'

  this.write(point)
  this.aborted = true
  this.end()
}

Parser.prototype.emitComment = function (line, skipLine, noDuplicate) {
  if (line.trim().charAt(0) !== '#')
    line = '# ' + line

  if (line.slice(-1) !== '\n')
    line += '\n'

  if (noDuplicate && this.comments.indexOf(line) !== -1)
    return

  this.comments.push(line)
  if (this.current || this.extraQueue.length) {
    // no way to get here with skipLine being true
    this.extraQueue.push(['line', line])
    this.extraQueue.push(['comment', line])
  } else {
    if (!skipLine)
      this.emit('line', line)
    this.emit('comment', line)
  }
}

Parser.prototype.parse = function (line) {
  // normalize line endings
  line = line.replace(/\r\n$/, '\n')

  // sometimes empty lines get trimmed, but are still part of
  // a subtest or a yaml block.  Otherwise, nothing to parse!
  if (line === '\n') {
    if (this.child)
      line = '    ' + line
    else if (this.yind)
      line = this.yind + line
  }

  // If we're bailing out, then the only thing we want to see is the
  // end of a buffered child test.  Anything else should be ignored.
  // But!  if we're bailing out a nested child, and ANOTHER nested child
  // comes after that one, then we don't want the second child's } to
  // also show up, or it looks weird.
  if (this.bailingOut) {
    if (!/^\s*}\n$/.test(line))
      return
    else if (!this.braceLevel || line.length < this.braceLevel)
      this.braceLevel = line.length
    else
      return
  }

  // This allows omitting even parsing the version if the test is
  // an indented child test.  Several parsers get upset when they
  // see an indented version field.
  if (this.omitVersion && lineTypes.version.test(line) && !this.yind)
    return

  // check to see if the line is indented.
  // if it is, then it's either a subtest, yaml, or garbage.
  var indent = line.match(/^[ \t]*/)[0]
  if (indent) {
    this.parseIndent(line, indent)
    return
  }

  // In any case where we're going to emitResult, that can trigger
  // a bailout, so we need to only emit the line once we know that
  // isn't happening, to prevent cases where there's a bailout, and
  // then one more line of output.  That'll also prevent the case
  // where the test point is emitted AFTER the line that follows it.

  // buffered subtests must end with a }
  if (this.child && this.child.buffered && line === '}\n') {
    this.endChild()
    this.emit('line', line)
    this.emitResult()
    return
  }

  // just a \n, emit only if we care about whitespace
  var validLine = this.preserveWhitespace || line.trim() || this.yind
  if (line === '\n')
    return validLine && this.emit('line', line)

  // buffered subtest with diagnostics
  if (this.current && line === '{\n' &&
      !this.current.buffered &&
      !this.child) {
    this.emit('line', line)
    this.current.buffered = true
    return
  }

  // now we know it's not indented, so if it's either valid tap
  // or garbage.  Get the type of line.
  var type = lineType(line)
  if (!type) {
    this.nonTap(line)
    return
  }

  if (type[0] === 'comment') {
    this.emitComment(line)
    return
  }

  // if we have any yamlish, it's garbage now.  We tolerate non-TAP and
  // comments in the midst of yaml (though, perhaps, that's questionable
  // behavior), but any actual TAP means that the yaml block was just
  // not valid.
  if (this.yind)
    this.yamlGarbage()

  // If it's anything other than a comment or garbage, then any
  // maybeChild is just an unsatisfied promise.
  if (this.maybeChild) {
    this.emitComment(this.maybeChild)
    this.maybeChild = null
  }

  // nothing but comments can come after a trailing plan
  if (this.postPlan) {
    this.nonTap(line)
    return
  }

  // ok, now it's maybe a thing
  if (type[0] === 'bailout') {
    this.bailout(type[1][1].trim(), false)
    return
  }

  if (type[0] === 'pragma') {
    var pragma = type[1]
    this.pragma(pragma[2], pragma[1] === '+', line)
    return
  }

  if (type[0] === 'version') {
    var version = type[1]
    this.version(parseInt(version[1], 10), line)
    return
  }

  if (type[0] === 'plan') {
    var plan = type[1]
    this.plan(+plan[1], +plan[2], (plan[3] || '').trim(), line)
    return
  }

  // streamed subtests will end when this test point is emitted
  if (type[0] === 'testPoint') {
    // note: it's weird, but possible, to have a testpoint ending in
    // { before a streamed subtest which ends with a test point
    // instead of a }.  In this case, the parser gets confused, but
    // also, even beginning to handle that means doing a much more
    // involved multi-line parse.  By that point, the subtest block
    // has already been emitted as a 'child' event, so it's too late
    // to really do the optimal thing.  The only way around would be
    // to buffer up everything and do a multi-line parse.  This is
    // rare and weird, and a multi-line parse would be a bigger
    // rewrite, so I'm allowing it as it currently is.
    this.parseTestPoint(type[1], line)
    return
  }

  // We already detected nontap up above, so the only case left
  // should be a `# Subtest:` comment.  Ignore for coverage, but
  // include the error here just for good measure.
  /* istanbul ignore else */
  if (type[0] === 'subtest') {
    // this is potentially a subtest.  Not indented.
    // hold until later.
    this.maybeChild = line
  } else {
    throw new Error('Unhandled case: ' + type[0])
  }
}

Parser.prototype.parseIndent = function (line, indent) {
  // still belongs to the child, so pass it along.
  if (this.child && line.substr(0, 4) === '    ') {
    line = line.substr(4)
    this.child.write(line)
    return
  }

  // one of:
  // - continuing yaml block
  // - starting yaml block
  // - ending yaml block
  // - body of a new child subtest that was previously introduced
  // - An indented subtest directive
  // - A comment, or garbage

  // continuing/ending yaml block
  if (this.yind) {
    if (line.indexOf(this.yind) === 0) {
      this.emit('line', line)
      this.yamlishLine(line)
      return
    } else {
      // oops!  that was not actually yamlish, I guess.
      // this is a case where the indent is shortened mid-yamlish block
      // treat existing yaml as garbage, continue parsing this line
      this.yamlGarbage()
    }
  }


  // start a yaml block under a test point
  if (this.current && !this.yind && line === indent + '---\n') {
    this.yind = indent
    this.emit('line', line)
    return
  }

  // at this point, not yamlish, and not an existing child test.
  // We may have already seen an unindented Subtest directive, or
  // a test point that ended in { indicating a buffered subtest
  // Child tests are always indented 4 spaces.
  if (line.substr(0, 4) === '    ') {
    if (this.maybeChild ||
        this.current && this.current.buffered ||
        lineTypes.subtestIndent.test(line)) {
      this.startChild(line)
      return
    }

    // It's _something_ indented, if the indentation is divisible by
    // 4 spaces, and the result is actual TAP of some sort, then do
    // a child subtest for it as well.
    //
    // This will lead to some ambiguity in cases where there are multiple
    // levels of non-signaled subtests, but a Subtest comment in the
    // middle of them, which may or may not be considered "indented"
    // See the subtest-no-comment-mid-comment fixture for an example
    // of this.  As it happens, the preference is towards an indented
    // Subtest comment as the interpretation, which is the only possible
    // way to resolve this, since otherwise there's no way to distinguish
    // between an anonymous subtest with a non-indented Subtest comment,
    // and an indented Subtest comment.
    var s = line.match(/( {4})+(.*\n)$/)
    if (s[2].charAt(0) !== ' ') {
      // integer number of indentations.
      var type = lineType(s[2])
      if (type) {
        if (type[0] === 'comment') {
          this.emit('line', line)
          this.emitComment(line)
        } else {
          // it's relevant!  start as an "unnamed" child subtest
          this.startChild(line)
        }
        return
      }
    }
  }

  // at this point, it's either a non-subtest comment, or garbage.

  if (lineTypes.comment.test(line)) {
    this.emitComment(line)
    return
  }

  this.nonTap(line)
}