pad_spa/node_modules/bfj/test/unit/walk.js

'use strict'

const assert = require('chai').assert
const spooks = require('spooks')
const Readable = require('stream').Readable
const events = require('../../src/events')

const modulePath = '../../src/walk'

suite('walk:', () => {
  let log

  setup(() => {
    log = {}
  })

  test('require does not throw', () => {
    assert.doesNotThrow(() => {
      require(modulePath)
    })
  })

  test('require returns function', () => {
    assert.isFunction(require(modulePath))
  })

  suite('require:', () => {
    let walk

    setup(() => {
      walk = require(modulePath)
    })

    test('walk throws without readable stream', () => {
      assert.throws(() => {
        walk({ on: () => {} })
      })
    })

    test('walk does not throw with readable stream', () => {
      assert.doesNotThrow(() => {
        walk(new Readable())
      })
    })

    test('walk returns emitter', () => {
      assert.instanceOf(walk(new Readable()), require('events').EventEmitter)
    })

    test('EventEmitter is decorated with pause method', () => {
      assert.isFunction(walk(new Readable()).pause)
      assert.lengthOf(walk(new Readable()).pause, 0)
    })

    test('pause method returns continue function', () => {
      assert.isFunction(walk(new Readable()).pause())
      assert.lengthOf(walk(new Readable()).pause(), 0)
    })

    suite('empty json:', () => {
      let stream, emitter

      setup(done => {
        stream = new Readable()
        stream._read = () => {}

        emitter = walk(stream)

        stream.push('')
        stream.push(null)

        Object.keys(events).forEach(key => {
          emitter.on(events[key], spooks.fn({
            name: key,
            log: log
          }))
        })

        emitter.on(events.end, done)
      })

      test('end event occurred once', () => {
        assert.strictEqual(log.counts.end, 1)
      })

      test('end event was dispatched correctly', () => {
        assert.lengthOf(log.args.end[0], 0)
      })

      test('array event did not occur', () => {
        assert.strictEqual(log.counts.array, 0)
      })

      test('object event did not occur', () => {
        assert.strictEqual(log.counts.object, 0)
      })

      test('property event did not occur', () => {
        assert.strictEqual(log.counts.property, 0)
      })

      test('string event did not occur', () => {
        assert.strictEqual(log.counts.string, 0)
      })

      test('number event did not occur', () => {
        assert.strictEqual(log.counts.number, 0)
      })

      test('literal event did not occur', () => {
        assert.strictEqual(log.counts.literal, 0)
      })

      test('endArray event did not occur', () => {
        assert.strictEqual(log.counts.endArray, 0)
      })

      test('endObject event did not occur', () => {
        assert.strictEqual(log.counts.endObject, 0)
      })

      test('error event did not occur', () => {
        assert.strictEqual(log.counts.error, 0)
      })

      test('dataError event did not occur', () => {
        assert.strictEqual(log.counts.dataError, 0)
      })

      test('endLine event did not occur', () => {
        assert.strictEqual(log.counts.endLine, 0)
      })

      test('endPrefix event did not occur', () => {
        assert.strictEqual(log.counts.endPrefix, 0)
      })
    })

    suite('empty array:', () => {
      let stream, emitter

      setup(done => {
        stream = new Readable()
        stream._read = () => {}

        emitter = walk(stream)

        stream.push('[]')
        stream.push(null)

        Object.keys(events).forEach(key => {
          emitter.on(events[key], spooks.fn({
            name: key,
            log: log
          }))
        })

        emitter.on(events.end, done)
      })

      test('array event occurred once', () => {
        assert.strictEqual(log.counts.array, 1)
      })

      test('array event was dispatched correctly', () => {
        assert.lengthOf(log.args.array[0], 0)
      })

      test('endArray event occurred once', () => {
        assert.strictEqual(log.counts.endArray, 1)
      })

      test('endArray event was dispatched correctly', () => {
        assert.lengthOf(log.args.endArray[0], 0)
      })

      test('end event occurred once', () => {
        assert.strictEqual(log.counts.end, 1)
      })

      test('object event did not occur', () => {
        assert.strictEqual(log.counts.object, 0)
      })

      test('property event did not occur', () => {
        assert.strictEqual(log.counts.property, 0)
      })

      test('string event did not occur', () => {
        assert.strictEqual(log.counts.string, 0)
      })

      test('number event did not occur', () => {
        assert.strictEqual(log.counts.number, 0)
      })

      test('literal event did not occur', () => {
        assert.strictEqual(log.counts.literal, 0)
      })

      test('endObject event did not occur', () => {
        assert.strictEqual(log.counts.endObject, 0)
      })

      test('error event did not occur', () => {
        assert.strictEqual(log.counts.error, 0)
      })

      test('dataError event did not occur', () => {
        assert.strictEqual(log.counts.dataError, 0)
      })

      test('endLine event did not occur', () => {
        assert.strictEqual(log.counts.endLine, 0)
      })

      test('endPrefix event did not occur', () => {
        assert.strictEqual(log.counts.endPrefix, 0)
      })
    })

    suite('empty object:', () => {
      let stream, emitter

      setup(done => {
        stream = new Readable()
        stream._read = () => {}

        emitter = walk(stream)

        stream.push('{}')
        stream.push(null)

        Object.keys(events).forEach(key => {
          emitter.on(events[key], spooks.fn({
            name: key,
            log: log
          }))
        })

        emitter.on(events.end, done)
      })

      test('object event occurred once', () => {
        assert.strictEqual(log.counts.object, 1)
      })

      test('object event was dispatched correctly', () => {
        assert.lengthOf(log.args.object[0], 0)
      })

      test('endObject event occurred once', () => {
        assert.strictEqual(log.counts.endObject, 1)
      })

      test('endObject event was dispatched correctly', () => {
        assert.lengthOf(log.args.endObject[0], 0)
      })

      test('end event occurred once', () => {
        assert.strictEqual(log.counts.end, 1)
      })

      test('array event did not occur', () => {
        assert.strictEqual(log.counts.array, 0)
      })

      test('property event did not occur', () => {
        assert.strictEqual(log.counts.property, 0)
      })

      test('string event did not occur', () => {
        assert.strictEqual(log.counts.string, 0)
      })

      test('number event did not occur', () => {
        assert.strictEqual(log.counts.number, 0)
      })

      test('literal event did not occur', () => {
        assert.strictEqual(log.counts.literal, 0)
      })

      test('endArray event did not occur', () => {
        assert.strictEqual(log.counts.endArray, 0)
      })

      test('error event did not occur', () => {
        assert.strictEqual(log.counts.error, 0)
      })

      test('dataError event did not occur', () => {
        assert.strictEqual(log.counts.dataError, 0)
      })

      test('endLine event did not occur', () => {
        assert.strictEqual(log.counts.endLine, 0)
      })

      test('endPrefix event did not occur', () => {
        assert.strictEqual(log.counts.endPrefix, 0)
      })
    })

    suite('string:', () => {
      let stream, emitter

      setup(done => {
        stream = new Readable()
        stream._read = () => {}

        emitter = walk(stream)

        stream.push('"\\"the quick brown fox\r\n\\tjumps\\u00a0over the lazy\\u1680dog\\""')
        stream.push(null)

        Object.keys(events).forEach(key => {
          emitter.on(events[key], spooks.fn({
            name: key,
            log: log
          }))
        })

        emitter.on(events.end, done)
      })

      test('string event occurred once', () => {
        assert.strictEqual(log.counts.string, 1)
      })

      test('string event was dispatched correctly', () => {
        assert.lengthOf(log.args.string[0], 1)
        assert.strictEqual(log.args.string[0][0], '"the quick brown fox\r\n\tjumps\u00a0over the lazy\u1680dog"')
      })

      test('end event occurred once', () => {
        assert.strictEqual(log.counts.end, 1)
      })

      test('array event did not occur', () => {
        assert.strictEqual(log.counts.array, 0)
      })

      test('object event did not occur', () => {
        assert.strictEqual(log.counts.object, 0)
      })

      test('property event did not occur', () => {
        assert.strictEqual(log.counts.property, 0)
      })

      test('number event did not occur', () => {
        assert.strictEqual(log.counts.number, 0)
      })

      test('literal event did not occur', () => {
        assert.strictEqual(log.counts.literal, 0)
      })

      test('endArray event did not occur', () => {
        assert.strictEqual(log.counts.endArray, 0)
      })

      test('endObject event did not occur', () => {
        assert.strictEqual(log.counts.endObject, 0)
      })

      test('error event did not occur', () => {
        assert.strictEqual(log.counts.error, 0)
      })

      test('dataError event did not occur', () => {
        assert.strictEqual(log.counts.dataError, 0)
      })

      test('endLine event did not occur', () => {
        assert.strictEqual(log.counts.endLine, 0)
      })

      test('endPrefix event did not occur', () => {
        assert.strictEqual(log.counts.endPrefix, 0)
      })
    })

    suite('number:', () => {
      let stream, emitter

      setup(done => {
        stream = new Readable()
        stream._read = () => {}

        emitter = walk(stream)

        stream.push('-3.14159265359e+42')
        stream.push(null)

        Object.keys(events).forEach(key => {
          emitter.on(events[key], spooks.fn({
            name: key,
            log: log
          }))
        })

        emitter.on(events.end, done)
      })

      test('number event occurred once', () => {
        assert.strictEqual(log.counts.number, 1)
      })

      test('number event was dispatched correctly', () => {
        assert.lengthOf(log.args.number[0], 1)
        assert.strictEqual(log.args.number[0][0], -3.14159265359e+42)
      })

      test('end event occurred once', () => {
        assert.strictEqual(log.counts.end, 1)
      })

      test('array event did not occur', () => {
        assert.strictEqual(log.counts.array, 0)
      })

      test('object event did not occur', () => {
        assert.strictEqual(log.counts.object, 0)
      })

      test('property event did not occur', () => {
        assert.strictEqual(log.counts.property, 0)
      })

      test('string event did not occur', () => {
        assert.strictEqual(log.counts.string, 0)
      })

      test('literal event did not occur', () => {
        assert.strictEqual(log.counts.literal, 0)
      })

      test('endArray event did not occur', () => {
        assert.strictEqual(log.counts.endArray, 0)
      })

      test('endObject event did not occur', () => {
        assert.strictEqual(log.counts.endObject, 0)
      })

      test('error event did not occur', () => {
        assert.strictEqual(log.counts.error, 0)
      })

      test('dataError event did not occur', () => {
        assert.strictEqual(log.counts.dataError, 0)
      })

      test('endLine event did not occur', () => {
        assert.strictEqual(log.counts.endLine, 0)
      })

      test('endPrefix event did not occur', () => {
        assert.strictEqual(log.counts.endPrefix, 0)
      })
    })

    suite('literal false:', () => {
      let stream, emitter

      setup(done => {
        stream = new Readable()
        stream._read = () => {}

        emitter = walk(stream)

        stream.push('false')
        stream.push(null)

        Object.keys(events).forEach(key => {
          emitter.on(events[key], spooks.fn({
            name: key,
            log: log
          }))
        })

        emitter.on(events.end, done)
      })

      test('literal event occurred once', () => {
        assert.strictEqual(log.counts.literal, 1)
      })

      test('literal event was dispatched correctly', () => {
        assert.lengthOf(log.args.literal[0], 1)
        assert.strictEqual(log.args.literal[0][0], false)
      })

      test('end event occurred once', () => {
        assert.strictEqual(log.counts.end, 1)
      })

      test('array event did not occur', () => {
        assert.strictEqual(log.counts.array, 0)
      })

      test('object event did not occur', () => {
        assert.strictEqual(log.counts.object, 0)
      })

      test('property event did not occur', () => {
        assert.strictEqual(log.counts.property, 0)
      })

      test('string event did not occur', () => {
        assert.strictEqual(log.counts.string, 0)
      })

      test('number event did not occur', () => {
        assert.strictEqual(log.counts.number, 0)
      })

      test('endArray event did not occur', () => {
        assert.strictEqual(log.counts.endArray, 0)
      })

      test('endObject event did not occur', () => {
        assert.strictEqual(log.counts.endObject, 0)
      })

      test('error event did not occur', () => {
        assert.strictEqual(log.counts.error, 0)
      })

      test('dataError event did not occur', () => {
        assert.strictEqual(log.counts.dataError, 0)
      })

      test('endLine event did not occur', () => {
        assert.strictEqual(log.counts.endLine, 0)
      })

      test('endPrefix event did not occur', () => {
        assert.strictEqual(log.counts.endPrefix, 0)
      })
    })

    suite('literal null:', () => {
      let stream, emitter

      setup(done => {
        stream = new Readable()
        stream._read = () => {}

        emitter = walk(stream)

        stream.push('null')
        stream.push(null)

        Object.keys(events).forEach(key => {
          emitter.on(events[key], spooks.fn({
            name: key,
            log: log
          }))
        })

        emitter.on(events.end, done)
      })

      test('literal event occurred once', () => {
        assert.strictEqual(log.counts.literal, 1)
      })

      test('literal event was dispatched correctly', () => {
        assert.strictEqual(log.args.literal[0][0], null)
      })

      test('end event occurred once', () => {
        assert.strictEqual(log.counts.end, 1)
      })

      test('array event did not occur', () => {
        assert.strictEqual(log.counts.array, 0)
      })

      test('object event did not occur', () => {
        assert.strictEqual(log.counts.object, 0)
      })

      test('property event did not occur', () => {
        assert.strictEqual(log.counts.property, 0)
      })

      test('string event did not occur', () => {
        assert.strictEqual(log.counts.string, 0)
      })

      test('number event did not occur', () => {
        assert.strictEqual(log.counts.number, 0)
      })

      test('endArray event did not occur', () => {
        assert.strictEqual(log.counts.endArray, 0)
      })

      test('endObject event did not occur', () => {
        assert.strictEqual(log.counts.endObject, 0)
      })

      test('error event did not occur', () => {
        assert.strictEqual(log.counts.error, 0)
      })

      test('dataError event did not occur', () => {
        assert.strictEqual(log.counts.dataError, 0)
      })

      test('endLine event did not occur', () => {
        assert.strictEqual(log.counts.endLine, 0)
      })

      test('endPrefix event did not occur', () => {
        assert.strictEqual(log.counts.endPrefix, 0)
      })
    })

    suite('literal true:', () => {
      let stream, emitter

      setup(done => {
        stream = new Readable()
        stream._read = () => {}

        emitter = walk(stream)

        stream.push('true')
        stream.push(null)

        Object.keys(events).forEach(key => {
          emitter.on(events[key], spooks.fn({
            name: key,
            log: log
          }))
        })

        emitter.on(events.end, done)
      })

      test('literal event occurred once', () => {
        assert.strictEqual(log.counts.literal, 1)
      })

      test('literal event was dispatched correctly', () => {
        assert.strictEqual(log.args.literal[0][0], true)
      })

      test('end event occurred once', () => {
        assert.strictEqual(log.counts.end, 1)
      })

      test('array event did not occur', () => {
        assert.strictEqual(log.counts.array, 0)
      })

      test('object event did not occur', () => {
        assert.strictEqual(log.counts.object, 0)
      })

      test('property event did not occur', () => {
        assert.strictEqual(log.counts.property, 0)
      })

      test('string event did not occur', () => {
        assert.strictEqual(log.counts.string, 0)
      })

      test('number event did not occur', () => {
        assert.strictEqual(log.counts.number, 0)
      })

      test('endArray event did not occur', () => {
        assert.strictEqual(log.counts.endArray, 0)
      })

      test('endObject event did not occur', () => {
        assert.strictEqual(log.counts.endObject, 0)
      })

      test('error event did not occur', () => {
        assert.strictEqual(log.counts.error, 0)
      })

      test('dataError event did not occur', () => {
        assert.strictEqual(log.counts.dataError, 0)
      })

      test('endLine event did not occur', () => {
        assert.strictEqual(log.counts.endLine, 0)
      })

      test('endPrefix event did not occur', () => {
        assert.strictEqual(log.counts.endPrefix, 0)
      })
    })

    suite('badly-closed array:', () => {
      let stream, emitter

      setup(done => {
        stream = new Readable()
        stream._read = () => {}

        emitter = walk(stream)

        stream.push('[}')
        stream.push(null)

        Object.keys(events).forEach(key => {
          emitter.on(events[key], spooks.fn({
            name: key,
            log: log
          }))
        })

        emitter.on(events.end, done)
      })

      test('array event occurred once', () => {
        assert.strictEqual(log.counts.array, 1)
      })

      test('dataError event occurred twice', () => {
        assert.strictEqual(log.counts.dataError, 2)
      })

      test('dataError event was dispatched correctly first time', () => {
        assert.lengthOf(log.args.dataError[0], 1)
        assert.instanceOf(log.args.dataError[0][0], Error)
        assert.strictEqual(log.args.dataError[0][0].actual, '}')
        assert.strictEqual(log.args.dataError[0][0].expected, 'value')
        assert.strictEqual(log.args.dataError[0][0].lineNumber, 1)
        assert.strictEqual(log.args.dataError[0][0].columnNumber, 2)
      })

      test('dataError event was dispatched correctly second time', () => {
        assert.strictEqual(log.args.dataError[1][0].actual, 'EOF')
        assert.strictEqual(log.args.dataError[1][0].expected, ']')
        assert.strictEqual(log.args.dataError[1][0].lineNumber, 1)
        assert.strictEqual(log.args.dataError[1][0].columnNumber, 3)
      })

      test('end event occurred once', () => {
        assert.strictEqual(log.counts.end, 1)
      })

      test('object event did not occur', () => {
        assert.strictEqual(log.counts.object, 0)
      })

      test('endArray event did not occur', () => {
        assert.strictEqual(log.counts.endArray, 0)
      })

      test('endObject event did not occur', () => {
        assert.strictEqual(log.counts.endObject, 0)
      })
    })

    suite('badly-closed object:', () => {
      let stream, emitter

      setup(done => {
        stream = new Readable()
        stream._read = () => {}

        emitter = walk(stream)

        stream.push('{]')
        stream.push(null)

        Object.keys(events).forEach(key => {
          emitter.on(events[key], spooks.fn({
            name: key,
            log: log
          }))
        })

        emitter.on(events.end, done)
      })

      test('object event occurred once', () => {
        assert.strictEqual(log.counts.object, 1)
      })

      test('dataError event occurred three times', () => {
        assert.strictEqual(log.counts.dataError, 3)
      })

      test('dataError event was dispatched correctly first time', () => {
        assert.strictEqual(log.args.dataError[0][0].actual, ']')
        assert.strictEqual(log.args.dataError[0][0].expected, '"')
        assert.strictEqual(log.args.dataError[0][0].lineNumber, 1)
        assert.strictEqual(log.args.dataError[0][0].columnNumber, 2)
      })

      test('dataError event was dispatched correctly second time', () => {
        assert.strictEqual(log.args.dataError[1][0].actual, 'EOF')
        assert.strictEqual(log.args.dataError[1][0].expected, '"')
        assert.strictEqual(log.args.dataError[1][0].lineNumber, 1)
        assert.strictEqual(log.args.dataError[1][0].columnNumber, 3)
      })

      test('dataError event was dispatched correctly third time', () => {
        assert.strictEqual(log.args.dataError[2][0].actual, 'EOF')
        assert.strictEqual(log.args.dataError[2][0].expected, '}')
        assert.strictEqual(log.args.dataError[2][0].lineNumber, 1)
        assert.strictEqual(log.args.dataError[2][0].columnNumber, 3)
      })

      test('end event occurred once', () => {
        assert.strictEqual(log.counts.end, 1)
      })

      test('array event did not occur', () => {
        assert.strictEqual(log.counts.array, 0)
      })

      test('endArray event did not occur', () => {
        assert.strictEqual(log.counts.endArray, 0)
      })

      test('endObject event did not occur', () => {
        assert.strictEqual(log.counts.endObject, 0)
      })
    })

    suite('string containing bad escape sequence:', () => {
      let stream, emitter

      setup(done => {
        stream = new Readable()
        stream._read = () => {}

        emitter = walk(stream)

        stream.push('"\\"the quick brown fox\r\n\\tjumps over the lazy\\xdog\\""')
        stream.push(null)

        Object.keys(events).forEach(key => {
          emitter.on(events[key], spooks.fn({
            name: key,
            log: log
          }))
        })

        emitter.on(events.end, done)
      })

      test('dataError event occurred once', () => {
        assert.strictEqual(log.counts.dataError, 1)
      })

      test('dataError event was dispatched correctly', () => {
        assert.strictEqual(log.args.dataError[0][0].actual, 'x')
        assert.strictEqual(log.args.dataError[0][0].expected, 'escape character')
        assert.strictEqual(log.args.dataError[0][0].lineNumber, 2)
        assert.strictEqual(log.args.dataError[0][0].columnNumber, 23)
      })

      test('string event occurred once', () => {
        assert.strictEqual(log.counts.string, 1)
      })

      test('string event was dispatched correctly', () => {
        assert.strictEqual(log.args.string[0][0], '"the quick brown fox\r\n\tjumps over the lazy\\xdog"')
      })

      test('end event occurred once', () => {
        assert.strictEqual(log.counts.end, 1)
      })
    })

    suite('string containing bad unicode escape sequence:', () => {
      let stream, emitter

      setup(done => {
        stream = new Readable()
        stream._read = () => {}

        emitter = walk(stream)

        stream.push('"\\u012g"')
        stream.push(null)

        Object.keys(events).forEach(key => {
          emitter.on(events[key], spooks.fn({
            name: key,
            log: log
          }))
        })

        emitter.on(events.end, done)
      })

      test('dataError event occurred once', () => {
        assert.strictEqual(log.counts.dataError, 1)
      })

      test('dataError event was dispatched correctly', () => {
        assert.strictEqual(log.args.dataError[0][0].actual, 'g')
        assert.strictEqual(log.args.dataError[0][0].expected, 'hex digit')
        assert.strictEqual(log.args.dataError[0][0].lineNumber, 1)
        assert.strictEqual(log.args.dataError[0][0].columnNumber, 7)
      })

      test('string event occurred once', () => {
        assert.strictEqual(log.counts.string, 1)
      })

      test('string event was dispatched correctly', () => {
        assert.strictEqual(log.args.string[0][0], '\\u012g')
      })

      test('end event occurred once', () => {
        assert.strictEqual(log.counts.end, 1)
      })
    })

    suite('unterminated string:', () => {
      let stream, emitter

      setup(done => {
        stream = new Readable()
        stream._read = () => {}

        emitter = walk(stream)

        stream.push('"foo')
        stream.push(null)

        Object.keys(events).forEach(key => {
          emitter.on(events[key], spooks.fn({
            name: key,
            log: log
          }))
        })

        emitter.on(events.end, done)
      })

      test('dataError event occurred once', () => {
        assert.strictEqual(log.counts.dataError, 1)
      })

      test('dataError event was dispatched correctly', () => {
        assert.strictEqual(log.args.dataError[0][0].actual, 'EOF')
        assert.strictEqual(log.args.dataError[0][0].expected, '"')
        assert.strictEqual(log.args.dataError[0][0].lineNumber, 1)
        assert.strictEqual(log.args.dataError[0][0].columnNumber, 5)
      })

      test('end event occurred once', () => {
        assert.strictEqual(log.counts.end, 1)
      })

      test('string event did not occur', () => {
        assert.strictEqual(log.counts.string, 0)
      })
    })

    suite('bad number:', () => {
      let stream, emitter

      setup(done => {
        stream = new Readable()
        stream._read = () => {}

        emitter = walk(stream)

        stream.push('1e')
        stream.push(null)

        Object.keys(events).forEach(key => {
          emitter.on(events[key], spooks.fn({
            name: key,
            log: log
          }))
        })

        emitter.on(events.end, done)
      })

      test('number event did not occur', () => {
        assert.strictEqual(log.counts.number, 0)
      })

      test('dataError event occurred once', () => {
        assert.strictEqual(log.counts.dataError, 1)
      })

      test('dataError event was dispatched correctly first time', () => {
        assert.strictEqual(log.args.dataError[0][0].actual, 'EOF')
        assert.strictEqual(log.args.dataError[0][0].expected, 'exponent')
        assert.strictEqual(log.args.dataError[0][0].lineNumber, 1)
        assert.strictEqual(log.args.dataError[0][0].columnNumber, 3)
      })

      test('end event occurred once', () => {
        assert.strictEqual(log.counts.end, 1)
      })

      test('literal event did not occur', () => {
        assert.strictEqual(log.counts.literal, 0)
      })
    })

    suite('alternative bad number:', () => {
      let stream, emitter

      setup(done => {
        stream = new Readable()
        stream._read = () => {}

        emitter = walk(stream)

        stream.push('42f')
        stream.push(null)

        Object.keys(events).forEach(key => {
          emitter.on(events[key], spooks.fn({
            name: key,
            log: log
          }))
        })

        emitter.on(events.end, done)
      })

      test('number event occurred once', () => {
        assert.strictEqual(log.counts.number, 1)
      })

      test('number event was dispatched correctly', () => {
        assert.strictEqual(log.args.number[0][0], 42)
      })

      test('dataError event occurred twice', () => {
        assert.strictEqual(log.counts.dataError, 2)
      })

      test('dataError event was dispatched correctly first time', () => {
        assert.strictEqual(log.args.dataError[0][0].actual, 'f')
        assert.strictEqual(log.args.dataError[0][0].expected, 'EOF')
        assert.strictEqual(log.args.dataError[0][0].lineNumber, 1)
        assert.strictEqual(log.args.dataError[0][0].columnNumber, 3)
      })

      test('dataError event was dispatched correctly second time', () => {
        assert.strictEqual(log.args.dataError[1][0].actual, 'EOF')
        assert.strictEqual(log.args.dataError[1][0].expected, 'a')
        assert.strictEqual(log.args.dataError[1][0].lineNumber, 1)
        assert.strictEqual(log.args.dataError[1][0].columnNumber, 4)
      })

      test('end event occurred once', () => {
        assert.strictEqual(log.counts.end, 1)
      })

      test('literal event did not occur', () => {
        assert.strictEqual(log.counts.literal, 0)
      })
    })

    suite('bad literal false:', () => {
      let stream, emitter

      setup(done => {
        stream = new Readable()
        stream._read = () => {}

        emitter = walk(stream)

        stream.push('falsd')
        stream.push(null)

        Object.keys(events).forEach(key => {
          emitter.on(events[key], spooks.fn({
            name: key,
            log: log
          }))
        })

        emitter.on(events.end, done)
      })

      test('dataError event occurred once', () => {
        assert.strictEqual(log.counts.dataError, 1)
      })

      test('dataError event was dispatched correctly', () => {
        assert.strictEqual(log.args.dataError[0][0].actual, 'd')
        assert.strictEqual(log.args.dataError[0][0].expected, 'e')
        assert.strictEqual(log.args.dataError[0][0].lineNumber, 1)
        assert.strictEqual(log.args.dataError[0][0].columnNumber, 5)
      })

      test('end event occurred once', () => {
        assert.strictEqual(log.counts.end, 1)
      })

      test('literal event did not occur', () => {
        assert.strictEqual(log.counts.literal, 0)
      })
    })

    suite('bad literal null:', () => {
      let stream, emitter

      setup(done => {
        stream = new Readable()
        stream._read = () => {}

        emitter = walk(stream)

        stream.push('nul')
        stream.push(null)

        Object.keys(events).forEach(key => {
          emitter.on(events[key], spooks.fn({
            name: key,
            log: log
          }))
        })

        emitter.on(events.end, done)
      })

      test('dataError event occurred once', () => {
        assert.strictEqual(log.counts.dataError, 1)
      })

      test('dataError event was dispatched correctly', () => {
        assert.strictEqual(log.args.dataError[0][0].actual, 'EOF')
        assert.strictEqual(log.args.dataError[0][0].expected, 'l')
        assert.strictEqual(log.args.dataError[0][0].lineNumber, 1)
        assert.strictEqual(log.args.dataError[0][0].columnNumber, 4)
      })

      test('end event occurred once', () => {
        assert.strictEqual(log.counts.end, 1)
      })

      test('literal event did not occur', () => {
        assert.strictEqual(log.counts.literal, 0)
      })
    })

    suite('bad literal true:', () => {
      let stream, emitter

      setup(done => {
        stream = new Readable()
        stream._read = () => {}

        emitter = walk(stream)

        stream.push('tRue')
        stream.push(null)

        Object.keys(events).forEach(key => {
          emitter.on(events[key], spooks.fn({
            name: key,
            log: log
          }))
        })

        emitter.on(events.end, done)
      })

      test('dataError event occurred four times', () => {
        assert.strictEqual(log.counts.dataError, 4)
      })

      test('dataError event was dispatched correctly first time', () => {
        assert.strictEqual(log.args.dataError[0][0].actual, 'R')
        assert.strictEqual(log.args.dataError[0][0].expected, 'r')
        assert.strictEqual(log.args.dataError[0][0].lineNumber, 1)
        assert.strictEqual(log.args.dataError[0][0].columnNumber, 2)
      })

      test('dataError event was dispatched correctly second time', () => {
        assert.strictEqual(log.args.dataError[1][0].actual, 'u')
        assert.strictEqual(log.args.dataError[1][0].expected, 'EOF')
        assert.strictEqual(log.args.dataError[1][0].lineNumber, 1)
        assert.strictEqual(log.args.dataError[1][0].columnNumber, 3)
      })

      test('dataError event was dispatched correctly third time', () => {
        assert.strictEqual(log.args.dataError[2][0].actual, 'u')
        assert.strictEqual(log.args.dataError[2][0].expected, 'value')
        assert.strictEqual(log.args.dataError[2][0].lineNumber, 1)
        assert.strictEqual(log.args.dataError[2][0].columnNumber, 3)
      })

      test('dataError event was dispatched correctly fourth time', () => {
        assert.strictEqual(log.args.dataError[3][0].actual, 'e')
        assert.strictEqual(log.args.dataError[3][0].expected, 'value')
        assert.strictEqual(log.args.dataError[3][0].lineNumber, 1)
        assert.strictEqual(log.args.dataError[3][0].columnNumber, 4)
      })

      test('end event occurred once', () => {
        assert.strictEqual(log.counts.end, 1)
      })

      test('literal event did not occur', () => {
        assert.strictEqual(log.counts.literal, 0)
      })
    })

    suite('array inside array:', () => {
      let stream, emitter

      setup(done => {
        stream = new Readable()
        stream._read = () => {}

        emitter = walk(stream)

        stream.push('[[]]')
        stream.push(null)

        Object.keys(events).forEach(key => {
          emitter.on(events[key], spooks.fn({
            name: key,
            log: log
          }))
        })

        emitter.on(events.end, done)
      })

      test('array event occurred twice', () => {
        assert.strictEqual(log.counts.array, 2)
      })

      test('endArray event occurred twice', () => {
        assert.strictEqual(log.counts.endArray, 2)
      })

      test('end event occurred once', () => {
        assert.strictEqual(log.counts.end, 1)
      })

      test('error event did not occur', () => {
        assert.strictEqual(log.counts.error, 0)
      })

      test('dataError event did not occur', () => {
        assert.strictEqual(log.counts.dataError, 0)
      })

      test('endLine event did not occur', () => {
        assert.strictEqual(log.counts.endLine, 0)
      })
    })

    suite('two arrays inside array:', () => {
      let stream, emitter

      setup(done => {
        stream = new Readable()
        stream._read = () => {}

        emitter = walk(stream)

        stream.push('[[],[]]')
        stream.push(null)

        Object.keys(events).forEach(key => {
          emitter.on(events[key], spooks.fn({
            name: key,
            log: log
          }))
        })

        emitter.on(events.end, done)
      })

      test('array event occurred three times', () => {
        assert.strictEqual(log.counts.array, 3)
      })

      test('endArray event occurred three times', () => {
        assert.strictEqual(log.counts.endArray, 3)
      })

      test('end event occurred once', () => {
        assert.strictEqual(log.counts.end, 1)
      })

      test('error event did not occur', () => {
        assert.strictEqual(log.counts.error, 0)
      })

      test('dataError event did not occur', () => {
        assert.strictEqual(log.counts.dataError, 0)
      })
    })

    suite('two arrays inside array with whitespace:', () => {
      let stream, emitter

      setup(done => {
        stream = new Readable()
        stream._read = () => {}

        emitter = walk(stream)

        stream.push(' [ [] , [] ] ')
        stream.push(null)

        Object.keys(events).forEach(key => {
          emitter.on(events[key], spooks.fn({
            name: key,
            log: log
          }))
        })

        emitter.on(events.end, done)
      })

      test('array event occurred three times', () => {
        assert.strictEqual(log.counts.array, 3)
      })

      test('endArray event occurred three times', () => {
        assert.strictEqual(log.counts.endArray, 3)
      })

      test('end event occurred once', () => {
        assert.strictEqual(log.counts.end, 1)
      })

      test('error event did not occur', () => {
        assert.strictEqual(log.counts.error, 0)
      })

      test('dataError event did not occur', () => {
        assert.strictEqual(log.counts.dataError, 0)
      })
    })

    suite('two arrays inside array without comma:', () => {
      let stream, emitter

      setup(done => {
        stream = new Readable()
        stream._read = () => {}

        emitter = walk(stream)

        stream.push('[[][]]')
        stream.push(null)

        Object.keys(events).forEach(key => {
          emitter.on(events[key], spooks.fn({
            name: key,
            log: log
          }))
        })

        emitter.on(events.end, done)
      })

      test('array event occurred three times', () => {
        assert.strictEqual(log.counts.array, 3)
      })

      test('endArray event occurred three times', () => {
        assert.strictEqual(log.counts.endArray, 3)
      })

      test('dataError event occurred once', () => {
        assert.strictEqual(log.counts.dataError, 1)
      })

      test('dataError event was dispatched correctly', () => {
        assert.strictEqual(log.args.dataError[0][0].actual, '[')
        assert.strictEqual(log.args.dataError[0][0].expected, ',')
        assert.strictEqual(log.args.dataError[0][0].lineNumber, 1)
        assert.strictEqual(log.args.dataError[0][0].columnNumber, 4)
      })

      test('end event occurred once', () => {
        assert.strictEqual(log.counts.end, 1)
      })

      test('endObject event did not occur', () => {
        assert.strictEqual(log.counts.endObject, 0)
      })
    })

    suite('object inside array:', () => {
      let stream, emitter

      setup(done => {
        stream = new Readable()
        stream._read = () => {}

        emitter = walk(stream)

        stream.push('[{}]')
        stream.push(null)

        Object.keys(events).forEach(key => {
          emitter.on(events[key], spooks.fn({
            name: key,
            log: log
          }))
        })

        emitter.on(events.end, done)
      })

      test('array event occurred once', () => {
        assert.strictEqual(log.counts.array, 1)
      })

      test('object event occurred once', () => {
        assert.strictEqual(log.counts.object, 1)
      })

      test('endObject event occurred once', () => {
        assert.strictEqual(log.counts.endObject, 1)
      })

      test('endArray event occurred once', () => {
        assert.strictEqual(log.counts.endArray, 1)
      })

      test('end event occurred once', () => {
        assert.strictEqual(log.counts.end, 1)
      })

      test('error event did not occur', () => {
        assert.strictEqual(log.counts.error, 0)
      })

      test('dataError event did not occur', () => {
        assert.strictEqual(log.counts.dataError, 0)
      })

      test('endLine event did not occur', () => {
        assert.strictEqual(log.counts.endLine, 0)
      })
    })

    suite('two objects inside array:', () => {
      let stream, emitter

      setup(done => {
        stream = new Readable()
        stream._read = () => {}

        emitter = walk(stream)

        stream.push('[{},{}]')
        stream.push(null)

        Object.keys(events).forEach(key => {
          emitter.on(events[key], spooks.fn({
            name: key,
            log: log
          }))
        })

        emitter.on(events.end, done)
      })

      test('array event occurred once', () => {
        assert.strictEqual(log.counts.array, 1)
      })

      test('object event occurred twice', () => {
        assert.strictEqual(log.counts.object, 2)
      })

      test('endObject event occurred twice', () => {
        assert.strictEqual(log.counts.endObject, 2)
      })

      test('endArray event occurred once', () => {
        assert.strictEqual(log.counts.endArray, 1)
      })

      test('end event occurred once', () => {
        assert.strictEqual(log.counts.end, 1)
      })

      test('error event did not occur', () => {
        assert.strictEqual(log.counts.error, 0)
      })

      test('dataError event did not occur', () => {
        assert.strictEqual(log.counts.dataError, 0)
      })
    })

    suite('two objects inside array with whitespace:', () => {
      let stream, emitter

      setup(done => {
        stream = new Readable()
        stream._read = () => {}

        emitter = walk(stream)

        stream.push('\t[\t{}\t,\r{}\n]\r\n')
        stream.push(null)

        Object.keys(events).forEach(key => {
          emitter.on(events[key], spooks.fn({
            name: key,
            log: log
          }))
        })

        emitter.on(events.end, done)
      })

      test('array event occurred once', () => {
        assert.strictEqual(log.counts.array, 1)
      })

      test('object event occurred twice', () => {
        assert.strictEqual(log.counts.object, 2)
      })

      test('endObject event occurred twice', () => {
        assert.strictEqual(log.counts.endObject, 2)
      })

      test('endArray event occurred once', () => {
        assert.strictEqual(log.counts.endArray, 1)
      })

      test('end event occurred once', () => {
        assert.strictEqual(log.counts.end, 1)
      })

      test('error event did not occur', () => {
        assert.strictEqual(log.counts.error, 0)
      })

      test('dataError event did not occur', () => {
        assert.strictEqual(log.counts.dataError, 0)
      })
    })

    suite('two objects inside array without comma:', () => {
      let stream, emitter

      setup(done => {
        stream = new Readable()
        stream._read = () => {}

        emitter = walk(stream)

        stream.push('[ {} {} ]')
        stream.push(null)

        Object.keys(events).forEach(key => {
          emitter.on(events[key], spooks.fn({
            name: key,
            log: log
          }))
        })

        emitter.on(events.end, done)
      })

      test('array event occurred once', () => {
        assert.strictEqual(log.counts.array, 1)
      })

      test('object event occurred twice', () => {
        assert.strictEqual(log.counts.object, 2)
      })

      test('endObject event occurred twice', () => {
        assert.strictEqual(log.counts.endObject, 2)
      })

      test('dataError event occurred once', () => {
        assert.strictEqual(log.counts.dataError, 1)
      })

      test('dataError event was dispatched correctly', () => {
        assert.strictEqual(log.args.dataError[0][0].actual, '{')
        assert.strictEqual(log.args.dataError[0][0].expected, ',')
        assert.strictEqual(log.args.dataError[0][0].lineNumber, 1)
        assert.strictEqual(log.args.dataError[0][0].columnNumber, 6)
      })

      test('endArray event occurred once', () => {
        assert.strictEqual(log.counts.endArray, 1)
      })

      test('end event occurred once', () => {
        assert.strictEqual(log.counts.end, 1)
      })
    })

    suite('string inside array:', () => {
      let stream, emitter

      setup(done => {
        stream = new Readable()
        stream._read = () => {}

        emitter = walk(stream)

        stream.push('["foo"]')
        stream.push(null)

        Object.keys(events).forEach(key => {
          emitter.on(events[key], spooks.fn({
            name: key,
            log: log
          }))
        })

        emitter.on(events.end, done)
      })

      test('array event occurred once', () => {
        assert.strictEqual(log.counts.array, 1)
      })

      test('string event occurred once', () => {
        assert.strictEqual(log.counts.string, 1)
      })

      test('string event was dispatched correctly', () => {
        assert.strictEqual(log.args.string[0][0], 'foo')
      })

      test('endArray event occurred once', () => {
        assert.strictEqual(log.counts.endArray, 1)
      })

      test('end event occurred once', () => {
        assert.strictEqual(log.counts.end, 1)
      })

      test('object event did not occur', () => {
        assert.strictEqual(log.counts.object, 0)
      })

      test('error event did not occur', () => {
        assert.strictEqual(log.counts.error, 0)
      })

      test('dataError event did not occur', () => {
        assert.strictEqual(log.counts.dataError, 0)
      })

      test('endLine event did not occur', () => {
        assert.strictEqual(log.counts.endLine, 0)
      })
    })

    suite('two strings inside array:', () => {
      let stream, emitter

      setup(done => {
        stream = new Readable()
        stream._read = () => {}

        emitter = walk(stream)

        stream.push('["foo","bar"]')
        stream.push(null)

        Object.keys(events).forEach(key => {
          emitter.on(events[key], spooks.fn({
            name: key,
            log: log
          }))
        })

        emitter.on(events.end, done)
      })

      test('array event occurred once', () => {
        assert.strictEqual(log.counts.array, 1)
      })

      test('string event occurred twice', () => {
        assert.strictEqual(log.counts.string, 2)
      })

      test('string event was dispatched correctly first time', () => {
        assert.strictEqual(log.args.string[0][0], 'foo')
      })

      test('string event was dispatched correctly second time', () => {
        assert.strictEqual(log.args.string[1][0], 'bar')
      })

      test('endArray event occurred once', () => {
        assert.strictEqual(log.counts.endArray, 1)
      })

      test('end event occurred once', () => {
        assert.strictEqual(log.counts.end, 1)
      })

      test('error event did not occur', () => {
        assert.strictEqual(log.counts.error, 0)
      })

      test('dataError event did not occur', () => {
        assert.strictEqual(log.counts.dataError, 0)
      })
    })

    suite('two strings inside array with whitespace:', () => {
      let stream, emitter

      setup(done => {
        stream = new Readable()
        stream._read = () => {}

        emitter = walk(stream)

        stream.push('  [  "baz"  ,  "qux"  ]  ')
        stream.push(null)

        Object.keys(events).forEach(key => {
          emitter.on(events[key], spooks.fn({
            name: key,
            log: log
          }))
        })

        emitter.on(events.end, done)
      })

      test('array event occurred once', () => {
        assert.strictEqual(log.counts.array, 1)
      })

      test('string event occurred twice', () => {
        assert.strictEqual(log.counts.string, 2)
      })

      test('string event was dispatched correctly first time', () => {
        assert.strictEqual(log.args.string[0][0], 'baz')
      })

      test('string event was dispatched correctly second time', () => {
        assert.strictEqual(log.args.string[1][0], 'qux')
      })

      test('endArray event occurred once', () => {
        assert.strictEqual(log.counts.endArray, 1)
      })

      test('end event occurred once', () => {
        assert.strictEqual(log.counts.end, 1)
      })

      test('error event did not occur', () => {
        assert.strictEqual(log.counts.error, 0)
      })

      test('dataError event did not occur', () => {
        assert.strictEqual(log.counts.dataError, 0)
      })
    })

    suite('literal inside array:', () => {
      let stream, emitter

      setup(done => {
        stream = new Readable()
        stream._read = () => {}

        emitter = walk(stream)

        stream.push('[false]')
        stream.push(null)

        Object.keys(events).forEach(key => {
          emitter.on(events[key], spooks.fn({
            name: key,
            log: log
          }))
        })

        emitter.on(events.end, done)
      })

      test('array event occurred once', () => {
        assert.strictEqual(log.counts.array, 1)
      })

      test('literal event occurred once', () => {
        assert.strictEqual(log.counts.literal, 1)
      })

      test('literal event was dispatched correctly', () => {
        assert.strictEqual(log.args.literal[0][0], false)
      })

      test('endArray event occurred once', () => {
        assert.strictEqual(log.counts.endArray, 1)
      })

      test('end event occurred once', () => {
        assert.strictEqual(log.counts.end, 1)
      })

      test('error event did not occur', () => {
        assert.strictEqual(log.counts.error, 0)
      })

      test('dataError event did not occur', () => {
        assert.strictEqual(log.counts.dataError, 0)
      })
    })

    suite('two literals inside array:', () => {
      let stream, emitter

      setup(done => {
        stream = new Readable()
        stream._read = () => {}

        emitter = walk(stream)

        stream.push('[true,null]')
        stream.push(null)

        Object.keys(events).forEach(key => {
          emitter.on(events[key], spooks.fn({
            name: key,
            log: log
          }))
        })

        emitter.on(events.end, done)
      })

      test('array event occurred once', () => {
        assert.strictEqual(log.counts.array, 1)
      })

      test('literal event occurred twice', () => {
        assert.strictEqual(log.counts.literal, 2)
      })

      test('literal event was dispatched correctly first time', () => {
        assert.strictEqual(log.args.literal[0][0], true)
      })

      test('literal event was dispatched correctly second time', () => {
        assert.strictEqual(log.args.literal[1][0], null)
      })

      test('endArray event occurred once', () => {
        assert.strictEqual(log.counts.endArray, 1)
      })

      test('end event occurred once', () => {
        assert.strictEqual(log.counts.end, 1)
      })

      test('error event did not occur', () => {
        assert.strictEqual(log.counts.error, 0)
      })

      test('dataError event did not occur', () => {
        assert.strictEqual(log.counts.dataError, 0)
      })
    })

    suite('two literals inside array with whitespace:', () => {
      let stream, emitter

      setup(done => {
        stream = new Readable()
        stream._read = () => {}

        emitter = walk(stream)

        stream.push('[ null , false ]')
        stream.push(null)

        Object.keys(events).forEach(key => {
          emitter.on(events[key], spooks.fn({
            name: key,
            log: log
          }))
        })

        emitter.on(events.end, done)
      })

      test('array event occurred once', () => {
        assert.strictEqual(log.counts.array, 1)
      })

      test('literal event occurred twice', () => {
        assert.strictEqual(log.counts.literal, 2)
      })

      test('literal event was dispatched correctly first time', () => {
        assert.strictEqual(log.args.literal[0][0], null)
      })

      test('literal event was dispatched correctly second time', () => {
        assert.strictEqual(log.args.literal[1][0], false)
      })

      test('endArray event occurred once', () => {
        assert.strictEqual(log.counts.endArray, 1)
      })

      test('end event occurred once', () => {
        assert.strictEqual(log.counts.end, 1)
      })

      test('error event did not occur', () => {
        assert.strictEqual(log.counts.error, 0)
      })

      test('dataError event did not occur', () => {
        assert.strictEqual(log.counts.dataError, 0)
      })
    })

    suite('number inside array:', () => {
      let stream, emitter

      setup(done => {
        stream = new Readable()
        stream._read = () => {}

        emitter = walk(stream)

        stream.push('[0]')
        stream.push(null)

        Object.keys(events).forEach(key => {
          emitter.on(events[key], spooks.fn({
            name: key,
            log: log
          }))
        })

        emitter.on(events.end, done)
      })

      test('array event occurred once', () => {
        assert.strictEqual(log.counts.array, 1)
      })

      test('number event occurred once', () => {
        assert.strictEqual(log.counts.number, 1)
      })

      test('number event was dispatched correctly', () => {
        assert.strictEqual(log.args.number[0][0], 0)
      })

      test('endArray event occurred once', () => {
        assert.strictEqual(log.counts.endArray, 1)
      })

      test('end event occurred once', () => {
        assert.strictEqual(log.counts.end, 1)
      })

      test('error event did not occur', () => {
        assert.strictEqual(log.counts.error, 0)
      })

      test('dataError event did not occur', () => {
        assert.strictEqual(log.counts.dataError, 0)
      })
    })

    suite('two numbers inside array:', () => {
      let stream, emitter

      setup(done => {
        stream = new Readable()
        stream._read = () => {}

        emitter = walk(stream)

        stream.push('[1,2]')
        stream.push(null)

        Object.keys(events).forEach(key => {
          emitter.on(events[key], spooks.fn({
            name: key,
            log: log
          }))
        })

        emitter.on(events.end, done)
      })

      test('array event occurred once', () => {
        assert.strictEqual(log.counts.array, 1)
      })

      test('number event occurred twice', () => {
        assert.strictEqual(log.counts.number, 2)
      })

      test('number event was dispatched correctly first time', () => {
        assert.strictEqual(log.args.number[0][0], 1)
      })

      test('number event was dispatched correctly second time', () => {
        assert.strictEqual(log.args.number[1][0], 2)
      })

      test('endArray event occurred once', () => {
        assert.strictEqual(log.counts.endArray, 1)
      })

      test('end event occurred once', () => {
        assert.strictEqual(log.counts.end, 1)
      })

      test('error event did not occur', () => {
        assert.strictEqual(log.counts.error, 0)
      })

      test('dataError event did not occur', () => {
        assert.strictEqual(log.counts.dataError, 0)
      })
    })

    suite('two numbers inside array with whitespace:', () => {
      let stream, emitter

      setup(done => {
        stream = new Readable()
        stream._read = () => {}

        emitter = walk(stream)

        stream.push('[ 1977 , -1977 ]')
        stream.push(null)

        Object.keys(events).forEach(key => {
          emitter.on(events[key], spooks.fn({
            name: key,
            log: log
          }))
        })

        emitter.on(events.end, done)
      })

      test('array event occurred once', () => {
        assert.strictEqual(log.counts.array, 1)
      })

      test('number event occurred twice', () => {
        assert.strictEqual(log.counts.number, 2)
      })

      test('number event was dispatched correctly first time', () => {
        assert.strictEqual(log.args.number[0][0], 1977)
      })

      test('number event was dispatched correctly second time', () => {
        assert.strictEqual(log.args.number[1][0], -1977)
      })

      test('endArray event occurred once', () => {
        assert.strictEqual(log.counts.endArray, 1)
      })

      test('end event occurred once', () => {
        assert.strictEqual(log.counts.end, 1)
      })

      test('error event did not occur', () => {
        assert.strictEqual(log.counts.error, 0)
      })

      test('dataError event did not occur', () => {
        assert.strictEqual(log.counts.dataError, 0)
      })
    })

    suite('object inside object:', () => {
      let stream, emitter

      setup(done => {
        stream = new Readable()
        stream._read = () => {}

        emitter = walk(stream)

        stream.push('{"foo":{}}')
        stream.push(null)

        Object.keys(events).forEach(key => {
          emitter.on(events[key], spooks.fn({
            name: key,
            log: log
          }))
        })

        emitter.on(events.end, done)
      })

      test('object event occurred twice', () => {
        assert.strictEqual(log.counts.object, 2)
      })

      test('property event occurred once', () => {
        assert.strictEqual(log.counts.property, 1)
      })

      test('property event was dispatched correctly', () => {
        assert.lengthOf(log.args.property[0], 1)
        assert.strictEqual(log.args.property[0][0], 'foo')
      })

      test('endObject event occurred twice', () => {
        assert.strictEqual(log.counts.endObject, 2)
      })

      test('end event occurred once', () => {
        assert.strictEqual(log.counts.end, 1)
      })

      test('error event did not occur', () => {
        assert.strictEqual(log.counts.error, 0)
      })

      test('dataError event did not occur', () => {
        assert.strictEqual(log.counts.dataError, 0)
      })
    })

    suite('array and object inside object:', () => {
      let stream, emitter

      setup(done => {
        stream = new Readable()
        stream._read = () => {}

        emitter = walk(stream)

        stream.push('{"wibble wobble":[],"jelly on the plate":{}}')
        stream.push(null)

        Object.keys(events).forEach(key => {
          emitter.on(events[key], spooks.fn({
            name: key,
            log: log
          }))
        })

        emitter.on(events.end, done)
      })

      test('object event occurred twice', () => {
        assert.strictEqual(log.counts.object, 2)
      })

      test('property event occurred twice', () => {
        assert.strictEqual(log.counts.property, 2)
      })

      test('property event was dispatched correctly first time', () => {
        assert.strictEqual(log.args.property[0][0], 'wibble wobble')
      })

      test('property event was dispatched correctly second time', () => {
        assert.strictEqual(log.args.property[1][0], 'jelly on the plate')
      })

      test('array event occurred once', () => {
        assert.strictEqual(log.counts.array, 1)
      })

      test('endArray event occurred once', () => {
        assert.strictEqual(log.counts.endArray, 1)
      })

      test('endObject event occurred twice', () => {
        assert.strictEqual(log.counts.endObject, 2)
      })

      test('end event occurred once', () => {
        assert.strictEqual(log.counts.end, 1)
      })

      test('error event did not occur', () => {
        assert.strictEqual(log.counts.error, 0)
      })

      test('dataError event did not occur', () => {
        assert.strictEqual(log.counts.dataError, 0)
      })
    })

    suite('string, literal and number inside object with whitespace:', () => {
      let stream, emitter

      setup(done => {
        stream = new Readable()
        stream._read = () => {}

        emitter = walk(stream)

        stream.push('   { "foo" : "bar" ,\t"baz"\t:\tnull\t,\r\n"qux"\r\n:\r\n3.14159265359\r\n} ')
        stream.push(null)

        Object.keys(events).forEach(key => {
          emitter.on(events[key], spooks.fn({
            name: key,
            log: log
          }))
        })

        emitter.on(events.end, done)
      })

      test('object event occurred once', () => {
        assert.strictEqual(log.counts.object, 1)
      })

      test('property event occurred three times', () => {
        assert.strictEqual(log.counts.property, 3)
      })

      test('property event was dispatched correctly first time', () => {
        assert.strictEqual(log.args.property[0][0], 'foo')
      })

      test('property event was dispatched correctly second time', () => {
        assert.strictEqual(log.args.property[1][0], 'baz')
      })

      test('property event was dispatched correctly third time', () => {
        assert.strictEqual(log.args.property[2][0], 'qux')
      })

      test('string event occurred once', () => {
        assert.strictEqual(log.counts.string, 1)
      })

      test('string event was dispatched correctly', () => {
        assert.strictEqual(log.args.string[0][0], 'bar')
      })

      test('literal event occurred once', () => {
        assert.strictEqual(log.counts.literal, 1)
      })

      test('literal event was dispatched correctly', () => {
        assert.isNull(log.args.literal[0][0])
      })

      test('number event occurred once', () => {
        assert.strictEqual(log.counts.number, 1)
      })

      test('number event was dispatched correctly', () => {
        assert.strictEqual(log.args.number[0][0], 3.14159265359)
      })

      test('endObject event occurred once', () => {
        assert.strictEqual(log.counts.endObject, 1)
      })

      test('end event occurred once', () => {
        assert.strictEqual(log.counts.end, 1)
      })

      test('error event did not occur', () => {
        assert.strictEqual(log.counts.error, 0)
      })

      test('dataError event did not occur', () => {
        assert.strictEqual(log.counts.dataError, 0)
      })
    })

    suite('two objects inside object without comma:', () => {
      let stream, emitter

      setup(done => {
        stream = new Readable()
        stream._read = () => {}

        emitter = walk(stream)

        stream.push('{"foo":{}"bar":{}}')
        stream.push(null)

        Object.keys(events).forEach(key => {
          emitter.on(events[key], spooks.fn({
            name: key,
            log: log
          }))
        })

        emitter.on(events.end, done)
      })

      test('object event occurred three times', () => {
        assert.strictEqual(log.counts.object, 3)
      })

      test('property event occurred twice', () => {
        assert.strictEqual(log.counts.property, 2)
      })

      test('property event was dispatched correctly first time', () => {
        assert.strictEqual(log.args.property[0][0], 'foo')
      })

      test('property event was dispatched correctly second time', () => {
        assert.strictEqual(log.args.property[1][0], 'bar')
      })

      test('dataError event occurred once', () => {
        assert.strictEqual(log.counts.dataError, 1)
      })

      test('dataError event was dispatched correctly', () => {
        assert.strictEqual(log.args.dataError[0][0].actual, '"')
        assert.strictEqual(log.args.dataError[0][0].expected, ',')
        assert.strictEqual(log.args.dataError[0][0].lineNumber, 1)
        assert.strictEqual(log.args.dataError[0][0].columnNumber, 10)
      })

      test('endObject event occurred three times', () => {
        assert.strictEqual(log.counts.endObject, 3)
      })

      test('end event occurred once', () => {
        assert.strictEqual(log.counts.end, 1)
      })
    })

    suite('unquoted property:', () => {
      let stream, emitter

      setup(done => {
        stream = new Readable()
        stream._read = () => {}

        emitter = walk(stream)

        stream.push('{foo:{}}')
        stream.push(null)

        Object.keys(events).forEach(key => {
          emitter.on(events[key], spooks.fn({
            name: key,
            log: log
          }))
        })

        emitter.on(events.end, done)
      })

      test('object event occurred once', () => {
        assert.strictEqual(log.counts.object, 1)
      })

      test('dataError event occurred once', () => {
        assert.strictEqual(log.counts.dataError, 3)
      })

      test('dataError event was dispatched correctly first time', () => {
        assert.strictEqual(log.args.dataError[0][0].actual, 'f')
        assert.strictEqual(log.args.dataError[0][0].expected, '"')
        assert.strictEqual(log.args.dataError[0][0].lineNumber, 1)
        assert.strictEqual(log.args.dataError[0][0].columnNumber, 2)
      })

      test('dataError event was dispatched correctly second time', () => {
        assert.strictEqual(log.args.dataError[1][0].actual, 'EOF')
        assert.strictEqual(log.args.dataError[1][0].expected, '"')
        assert.strictEqual(log.args.dataError[1][0].lineNumber, 1)
        assert.strictEqual(log.args.dataError[1][0].columnNumber, 9)
      })

      test('dataError event was dispatched correctly third time', () => {
        assert.strictEqual(log.args.dataError[2][0].actual, 'EOF')
        assert.strictEqual(log.args.dataError[2][0].expected, '}')
        assert.strictEqual(log.args.dataError[2][0].lineNumber, 1)
        assert.strictEqual(log.args.dataError[2][0].columnNumber, 9)
      })

      test('end event occurred once', () => {
        assert.strictEqual(log.counts.end, 1)
      })
    })

    suite('duplicate property:', () => {
      let stream, emitter

      setup(done => {
        stream = new Readable()
        stream._read = () => {}

        emitter = walk(stream)

        // NOTE: RFC 7159 is wishy washy on the subject of duplicates:
        //
        //   "The names within an object SHOULD be unique
        //
        //   ...
        //
        //   An object whose names are all unique is interoperable
        //   in the sense that all software implementations receiving
        //   that object will agree on the name/value mappings. When
        //   the names within an object are not unique, the behavior
        //   of software that receives such an object is unpredictable.
        //   Many implementations report the last name/value pair only.
        //   Other implementations report an error or fail to parse the
        //   object, and some implementations report all of the name/value
        //   pairs, including duplicates."
        //
        //   https://tools.ietf.org/html/rfc7159#section-4
        stream.push('{"foo":{},"foo":{}}')
        stream.push(null)

        Object.keys(events).forEach(key => {
          emitter.on(events[key], spooks.fn({
            name: key,
            log: log
          }))
        })

        emitter.on(events.end, done)
      })

      test('object event occurred three times', () => {
        assert.strictEqual(log.counts.object, 3)
      })

      test('property event occurred twice', () => {
        assert.strictEqual(log.counts.property, 2)
      })

      test('property event was dispatched correctly first time', () => {
        assert.strictEqual(log.args.property[0][0], 'foo')
      })

      test('property event was dispatched correctly second time', () => {
        assert.strictEqual(log.args.property[1][0], 'foo')
      })

      test('endObject event occurred three times', () => {
        assert.strictEqual(log.counts.endObject, 3)
      })

      test('end event occurred once', () => {
        assert.strictEqual(log.counts.end, 1)
      })

      test('error event did not occur', () => {
        assert.strictEqual(log.counts.error, 0)
      })

      test('dataError event did not occur', () => {
        assert.strictEqual(log.counts.dataError, 0)
      })
    })

    suite('empty array containing whitespace:', () => {
      let stream, emitter

      setup(done => {
        stream = new Readable()
        stream._read = () => {}

        emitter = walk(stream)

        stream.push('[ ]')
        stream.push(null)

        Object.keys(events).forEach(key => {
          emitter.on(events[key], spooks.fn({
            name: key,
            log: log
          }))
        })

        emitter.on(events.end, done)
      })

      test('array event occurred once', () => {
        assert.strictEqual(log.counts.array, 1)
      })

      test('endArray event occurred once', () => {
        assert.strictEqual(log.counts.endArray, 1)
      })

      test('end event occurred once', () => {
        assert.strictEqual(log.counts.end, 1)
      })

      test('error event did not occur', () => {
        assert.strictEqual(log.counts.error, 0)
      })

      test('dataError event did not occur', () => {
        assert.strictEqual(log.counts.dataError, 0)
      })
    })

    suite('chunked empty array:', () => {
      let stream, emitter

      setup(done => {
        stream = new Readable()
        stream._read = () => {}

        emitter = walk(stream)

        stream.push('[')

        Object.keys(events).forEach(key => {
          emitter.on(events[key], spooks.fn({
            name: key,
            log: log
          }))
        })

        emitter.on(events.end, done)
        emitter.on(events.array, stream.push.bind(stream, ']'))
        emitter.on(events.endArray, stream.push.bind(stream, null))
      })

      test('array event occurred once', () => {
        assert.strictEqual(log.counts.array, 1)
      })

      test('endArray event occurred once', () => {
        assert.strictEqual(log.counts.endArray, 1)
      })

      test('end event occurred once', () => {
        assert.strictEqual(log.counts.end, 1)
      })

      test('error event did not occur', () => {
        assert.strictEqual(log.counts.error, 0)
      })

      test('dataError event did not occur', () => {
        assert.strictEqual(log.counts.dataError, 0)
      })
    })

    suite('chunked empty object with whitespace:', () => {
      let stream, emitter

      setup(done => {
        stream = new Readable()
        stream._read = () => {}

        emitter = walk(stream)

        stream.push(' {')

        Object.keys(events).forEach(key => {
          emitter.on(events[key], spooks.fn({
            name: key,
            log: log
          }))
        })

        emitter.on(events.end, done)

        emitter.on(events.object, () => {
          setTimeout(stream.push.bind(stream, ' }'), 20)
        })

        emitter.on(events.endObject, () => {
          setTimeout(stream.push.bind(stream, null), 20)
        })
      })

      test('object event occurred once', () => {
        assert.strictEqual(log.counts.object, 1)
      })

      test('endObject event occurred once', () => {
        assert.strictEqual(log.counts.endObject, 1)
      })

      test('end event occurred once', () => {
        assert.strictEqual(log.counts.end, 1)
      })

      test('error event did not occur', () => {
        assert.strictEqual(log.counts.error, 0)
      })

      test('dataError event did not occur', () => {
        assert.strictEqual(log.counts.dataError, 0)
      })
    })

    suite('chunked string:', () => {
      let stream, emitter

      setup(done => {
        stream = new Readable()
        stream._read = () => {}

        emitter = walk(stream)

        stream.push('"')

        Object.keys(events).forEach(key => {
          emitter.on(events[key], spooks.fn({
            name: key,
            log: log
          }))
        })

        emitter.on(events.end, done)

        emitter.on(events.string, () => {
          setTimeout(stream.push.bind(stream, null), 20)
        })

        setTimeout(stream.push.bind(stream, '\\'), 20)
        setTimeout(stream.push.bind(stream, 't\\u'), 40)
        setTimeout(stream.push.bind(stream, '00'), 60)
        setTimeout(stream.push.bind(stream, 'a0'), 80)
        setTimeout(stream.push.bind(stream, '"'), 100)
      })

      test('string event occurred once', () => {
        assert.strictEqual(log.counts.string, 1)
      })

      test('string event was dispatched correctly', () => {
        assert.strictEqual(log.args.string[0][0], '\t\u00a0')
      })

      test('end event occurred once', () => {
        assert.strictEqual(log.counts.end, 1)
      })

      test('error event did not occur', () => {
        assert.strictEqual(log.counts.error, 0)
      })

      test('dataError event did not occur', () => {
        assert.strictEqual(log.counts.dataError, 0)
      })
    })

    suite('chunked number:', () => {
      let stream, emitter

      setup(done => {
        stream = new Readable()
        stream._read = () => {}

        emitter = walk(stream)

        stream.push('-')

        Object.keys(events).forEach(key => {
          emitter.on(events[key], spooks.fn({
            name: key,
            log: log
          }))
        })

        emitter.on(events.end, done)

        setTimeout(stream.push.bind(stream, '3'), 20)
        setTimeout(stream.push.bind(stream, '.'), 40)
        setTimeout(stream.push.bind(stream, '14159'), 60)
        setTimeout(stream.push.bind(stream, '265359'), 80)
        setTimeout(stream.push.bind(stream, 'e'), 100)
        setTimeout(stream.push.bind(stream, '-'), 120)
        setTimeout(stream.push.bind(stream, '7'), 140)
        setTimeout(stream.push.bind(stream, null), 160)
      })

      test('number event occurred once', () => {
        assert.strictEqual(log.counts.number, 1)
      })

      test('number event was dispatched correctly', () => {
        assert.strictEqual(log.args.number[0][0], -3.14159265359e-7)
      })

      test('end event occurred once', () => {
        assert.strictEqual(log.counts.end, 1)
      })

      test('error event did not occur', () => {
        assert.strictEqual(log.counts.error, 0)
      })

      test('dataError event did not occur', () => {
        assert.strictEqual(log.counts.dataError, 0)
      })
    })

    suite('chunked literal:', () => {
      let stream, emitter

      setup(done => {
        stream = new Readable()
        stream._read = () => {}

        emitter = walk(stream)

        stream.push('n')

        Object.keys(events).forEach(key => {
          emitter.on(events[key], spooks.fn({
            name: key,
            log: log
          }))
        })

        emitter.on(events.end, done)

        setTimeout(stream.push.bind(stream, 'u'), 20)
        setTimeout(stream.push.bind(stream, 'l'), 40)
        setTimeout(stream.push.bind(stream, 'l'), 60)
        setTimeout(stream.push.bind(stream, null), 80)
      })

      test('literal event occurred once', () => {
        assert.strictEqual(log.counts.literal, 1)
      })

      test('literal event was dispatched correctly', () => {
        assert.strictEqual(log.args.literal[0][0], null)
      })

      test('end event occurred once', () => {
        assert.strictEqual(log.counts.end, 1)
      })

      test('error event did not occur', () => {
        assert.strictEqual(log.counts.error, 0)
      })

      test('dataError event did not occur', () => {
        assert.strictEqual(log.counts.dataError, 0)
      })
    })

    suite('populated array with discard=1:', () => {
      let stream, emitter

      setup(done => {
        stream = new Readable()
        stream._read = () => {}

        emitter = walk(stream, { discard: 1 })

        stream.push(' ')

        Object.keys(events).forEach(key => {
          emitter.on(events[key], spooks.fn({
            name: key,
            log: log
          }))
        })

        emitter.on(events.end, done)

        emitter.on(events.array, () => {
          stream.push(' ""')
        })

        emitter.on(events.string, () => {
          stream.push(' ]')
        })

        emitter.on(events.endArray, () => {
          stream.push(null)
        })

        setImmediate(stream.push.bind(stream, '['))
      })

      test('array event occurred once', () => {
        assert.strictEqual(log.counts.array, 1)
      })

      test('string event was dispatched correctly', () => {
        assert.strictEqual(log.args.string[0][0], "")
      })

      test('endArray event occurred once', () => {
        assert.strictEqual(log.counts.endArray, 1)
      })

      test('end event occurred once', () => {
        assert.strictEqual(log.counts.end, 1)
      })

      test('string event occurred once', () => {
        assert.strictEqual(log.counts.string, 1)
      })

      test('error event did not occur', () => {
        assert.strictEqual(log.counts.error, 0)
      })

      test('dataError event did not occur', () => {
        assert.strictEqual(log.counts.dataError, 0)
      })
    })

    suite('throw errors from event handlers:', () => {
      let stream, emitter

      setup(done => {
        stream = new Readable()
        stream._read = () => {}

        emitter = walk(stream)

        stream.push('[null,false,true,0,"",{"foo":"bar"}]')
        stream.push(null)

        Object.keys(events).forEach(key => {
          const event = events[key]
          emitter.on(event, spooks.fn({
            name: key,
            log: log
          }))
          if (event !== events.end) {
            emitter.on(event, () => { throw 0 })
          }
        })

        emitter.on(events.end, done)
      })

      test('array event occurred once', () => {
        assert.strictEqual(log.counts.array, 1)
      })

      test('endArray event occurred once', () => {
        assert.strictEqual(log.counts.endArray, 1)
      })

      test('literal event occurred three times', () => {
        assert.strictEqual(log.counts.literal, 3)
      })

      test('number event occurred once', () => {
        assert.strictEqual(log.counts.number, 1)
      })

      test('string event occurred twice', () => {
        assert.strictEqual(log.counts.string, 2)
      })

      test('property event occurred once', () => {
        assert.strictEqual(log.counts.property, 1)
      })

      test('object event occurred once', () => {
        assert.strictEqual(log.counts.object, 1)
      })

      test('endObject event occurred once', () => {
        assert.strictEqual(log.counts.endObject, 1)
      })

      test('error event occurred eleven times', () => {
        assert.strictEqual(log.counts.error, 11)
      })

      test('end event occurred once', () => {
        assert.strictEqual(log.counts.end, 1)
      })

      test('dataError event did not occur', () => {
        assert.strictEqual(log.counts.dataError, 0)
      })
    })

    suite('error occurs on stream:', () => {
      let stream, emitter

      setup(done => {
        stream = new Readable()
        stream._read = () => {}

        emitter = walk(stream)

        Object.keys(events).forEach(key => {
          emitter.on(events[key], spooks.fn({
            name: key,
            log: log
          }))
        })

        stream.emit('error', new Error('wibble'))
        stream.push(null)

        emitter.on(events.end, done)
      })

      test('error event occurred once', () => {
        assert.strictEqual(log.counts.error, 1)
      })

      test('error event was dispatched correctly', () => {
        assert.strictEqual(log.args.error[0][0].message, 'wibble')
        assert.isUndefined(log.args.error[0][0].actual)
        assert.isUndefined(log.args.error[0][0].expected)
        assert.isUndefined(log.args.error[0][0].lineNumber)
        assert.isUndefined(log.args.error[0][0].columnNumber)
      })

      test('end event occurred once', () => {
        assert.strictEqual(log.counts.end, 1)
      })

      test('dataError event did not occur', () => {
        assert.strictEqual(log.counts.dataError, 0)
      })
    })

    suite('two values separated by newline:', () => {
      let stream, emitter

      setup(done => {
        stream = new Readable()
        stream._read = () => {}

        emitter = walk(stream)

        stream.push('[]\n"foo"')
        stream.push(null)

        Object.keys(events).forEach(key => {
          emitter.on(events[key], spooks.fn({
            name: key,
            log: log
          }))
        })

        emitter.on(events.end, done)
      })

      test('array event occurred once', () => {
        assert.strictEqual(log.counts.array, 1)
      })

      test('endArray event occurred once', () => {
        assert.strictEqual(log.counts.endArray, 1)
      })

      test('string event occurred once', () => {
        assert.strictEqual(log.counts.string, 1)
      })

      test('dataError event occurred once', () => {
        assert.strictEqual(log.counts.dataError, 1)
      })

      test('end event occurred once', () => {
        assert.strictEqual(log.counts.end, 1)
      })

      test('endLine event did not occur', () => {
        assert.strictEqual(log.counts.endLine, 0)
      })
    })

    suite('two values separated by newline, ndjson=true:', () => {
      let stream, emitter

      setup(done => {
        stream = new Readable()
        stream._read = () => {}

        emitter = walk(stream, { ndjson: true })

        stream.push('[]\n"foo"')
        stream.push(null)

        Object.keys(events).forEach(key => {
          emitter.on(events[key], spooks.fn({
            name: key,
            log: log
          }))
        })

        emitter.on(events.end, done)
      })

      test('array event occurred once', () => {
        assert.strictEqual(log.counts.array, 1)
      })

      test('endArray event occurred once', () => {
        assert.strictEqual(log.counts.endArray, 1)
      })

      test('string event occurred once', () => {
        assert.strictEqual(log.counts.string, 1)
      })

      test('endLine event occurred once', () => {
        assert.strictEqual(log.counts.endLine, 1)
      })

      test('end event occurred once', () => {
        assert.strictEqual(log.counts.end, 1)
      })

      test('error event did not occur', () => {
        assert.strictEqual(log.counts.error, 0)
      })

      test('dataError event did not occur', () => {
        assert.strictEqual(log.counts.dataError, 0)
      })
    })

    suite('two values separated by newline, ndjson=true, with embedded newlines in a value:', () => {
      let stream, emitter

      setup(done => {
        stream = new Readable()
        stream._read = () => {}

        emitter = walk(stream, { ndjson: true })

        stream.push('[\n\n\n"foo"\n\n,\n"bar"]\n"baz"')
        stream.push(null)

        Object.keys(events).forEach(key => {
          emitter.on(events[key], spooks.fn({
            name: key,
            log: log
          }))
        })

        emitter.on(events.end, done)
      })

      test('array event occurred once', () => {
        assert.strictEqual(log.counts.array, 1)
      })

      test('endArray event occurred once', () => {
        assert.strictEqual(log.counts.endArray, 1)
      })

      test('string event occurred three times', () => {
        assert.strictEqual(log.counts.string, 3)
      })

      test('endLine event occurred once', () => {
        assert.strictEqual(log.counts.endLine, 1)
      })

      test('end event occurred once', () => {
        assert.strictEqual(log.counts.end, 1)
      })

      test('error event did not occur', () => {
        assert.strictEqual(log.counts.error, 0)
      })

      test('dataError event did not occur', () => {
        assert.strictEqual(log.counts.dataError, 0)
      })
    })

    suite('two values not separated by newline, ndjson=true:', () => {
      let stream, emitter

      setup(done => {
        stream = new Readable()
        stream._read = () => {}

        emitter = walk(stream, { ndjson: true })

        stream.push('[]"foo"')
        stream.push(null)

        Object.keys(events).forEach(key => {
          emitter.on(events[key], spooks.fn({
            name: key,
            log: log
          }))
        })

        emitter.on(events.end, done)
      })

      test('array event occurred once', () => {
        assert.strictEqual(log.counts.array, 1)
      })

      test('endArray event occurred once', () => {
        assert.strictEqual(log.counts.endArray, 1)
      })

      test('end event occurred once', () => {
        assert.strictEqual(log.counts.end, 1)
      })

      test('dataError event occurred five times', () => {
        assert.strictEqual(log.counts.dataError, 5)
      })

      test('string event did not occurr', () => {
        assert.strictEqual(log.counts.string, 0)
      })

      test('endLine event did not occur', () => {
        assert.strictEqual(log.counts.endLine, 0)
      })
    })

    suite('two values separated by two newlines, ndjson=true:', () => {
      let stream, emitter

      setup(done => {
        stream = new Readable()
        stream._read = () => {}

        emitter = walk(stream, { ndjson: true })

        stream.push('[]\r\n\r\n"foo"')
        stream.push(null)

        Object.keys(events).forEach(key => {
          emitter.on(events[key], spooks.fn({
            name: key,
            log: log
          }))
        })

        emitter.on(events.end, done)
      })

      test('array event occurred once', () => {
        assert.strictEqual(log.counts.array, 1)
      })

      test('endArray event occurred once', () => {
        assert.strictEqual(log.counts.endArray, 1)
      })

      test('string event occurred once', () => {
        assert.strictEqual(log.counts.string, 1)
      })

      test('endLine event occurred twice', () => {
        assert.strictEqual(log.counts.endLine, 2)
      })

      test('end event occurred once', () => {
        assert.strictEqual(log.counts.end, 1)
      })

      test('error event did not occur', () => {
        assert.strictEqual(log.counts.error, 0)
      })

      test('dataError event did not occur', () => {
        assert.strictEqual(log.counts.dataError, 0)
      })
    })

    suite('chunked ndjson:', () => {
      let stream, emitter

      setup(done => {
        stream = new Readable()
        stream._read = () => {}

        emitter = walk(stream, { ndjson: true })

        stream.push('[]')

        Object.keys(events).forEach(key => {
          emitter.on(events[key], spooks.fn({
            name: key,
            log: log
          }))
        })

        emitter.on(events.end, done)

        setTimeout(stream.push.bind(stream, ' '), 20)
        setTimeout(stream.push.bind(stream, '\n'), 40)
        setTimeout(stream.push.bind(stream, ' '), 60)
        setTimeout(stream.push.bind(stream, '"'), 80)
        setTimeout(stream.push.bind(stream, 'foo"'), 100)
        setTimeout(stream.push.bind(stream, null), 120)
      })

      test('array event occurred once', () => {
        assert.strictEqual(log.counts.array, 1)
      })

      test('endArray event occurred once', () => {
        assert.strictEqual(log.counts.endArray, 1)
      })

      test('endLine event occurred once', () => {
        assert.strictEqual(log.counts.endLine, 1)
      })

      test('string event occurred once', () => {
        assert.strictEqual(log.counts.string, 1)
      })

      test('end event occurred once', () => {
        assert.strictEqual(log.counts.end, 1)
      })

      test('error event did not occur', () => {
        assert.strictEqual(log.counts.error, 0)
      })

      test('dataError event did not occur', () => {
        assert.strictEqual(log.counts.dataError, 0)
      })
    })
  })
})