text: 'use strict';
  
  const common = require('../common');
  
  const assert = require('assert');
  const { Console } = require('console');
  
  const queue = [];
  
  const console = new Console({ write: (x) => {
    queue.push(x);
  }, removeListener: () => {} }, process.stderr, false);
  
  function test(data, only, expected) {
    if (arguments.length === 2) {
      expected = only;
      only = undefined;
    }
    console.table(data, only);
    assert.deepStrictEqual(
      queue.shift().split('\n'),
      expected.trimLeft().split('\n')
    );
  }
  
  common.expectsError(() => console.table([], false), {
    code: 'ERR_INVALID_ARG_TYPE',
  });
  
  test(null, 'null\n');
  test(undefined, 'undefined\n');
  test(false, 'false\n');
  test('hi', 'hi\n');
  test(Symbol(), 'Symbol()\n');
  test(function() {}, '[Function]\n');
  
  test([1, 2, 3], `
  ┌─────────┬────────┐
  │ (index) │ Values │
  ├─────────┼────────┤
  │    0    │   1    │
  │    1    │   2    │
  │    2    │   3    │
  └─────────┴────────┘
  `);
  
  test([Symbol(), 5, [10]], `
  ┌─────────┬────┬──────────┐
  │ (index) │ 0  │  Values  │
  ├─────────┼────┼──────────┤
  │    0    │    │ Symbol() │
  │    1    │    │    5     │
  │    2    │ 10 │          │
  └─────────┴────┴──────────┘
  `);
  
  test([null, 5], `
  ┌─────────┬────────┐
  │ (index) │ Values │
  ├─────────┼────────┤
  │    0    │  null  │
  │    1    │   5    │
  └─────────┴────────┘
  `);
  
  test([undefined, 5], `
  ┌─────────┬───────────┐
  │ (index) │  Values   │
  ├─────────┼───────────┤
  │    0    │ undefined │
  │    1    │     5     │
  └─────────┴───────────┘
  `);
  
  test({ a: 1, b: Symbol(), c: [10] }, `
  ┌─────────┬────┬──────────┐
  │ (index) │ 0  │  Values  │
  ├─────────┼────┼──────────┤
  │    a    │    │    1     │
  │    b    │    │ Symbol() │
  │    c    │ 10 │          │
  └─────────┴────┴──────────┘
  `);
  
  test(new Map([ ['a', 1], [Symbol(), [2]] ]), `
  ┌───────────────────┬──────────┬────────┐
  │ (iteration index) │   Key    │ Values │
  ├───────────────────┼──────────┼────────┤
  │         0         │   'a'    │   1    │
  │         1         │ Symbol() │ [ 2 ]  │
  └───────────────────┴──────────┴────────┘
  `);
  
  test(new Set([1, 2, Symbol()]), `
  ┌───────────────────┬──────────┐
  │ (iteration index) │  Values  │
  ├───────────────────┼──────────┤
  │         0         │    1     │
  │         1         │    2     │
  │         2         │ Symbol() │
  └───────────────────┴──────────┘
  `);
  
  test({ a: 1, b: 2 }, ['a'], `
  ┌─────────┬───┐
  │ (index) │ a │
  ├─────────┼───┤
  │    a    │   │
  │    b    │   │
  └─────────┴───┘
  `);
  
  test([{ a: 1, b: 2 }, { a: 3, c: 4 }], ['a'], `
  ┌─────────┬───┐
  │ (index) │ a │
  ├─────────┼───┤
  │    0    │ 1 │
  │    1    │ 3 │
  └─────────┴───┘
  `);
  
  test(new Map([[1, 1], [2, 2], [3, 3]]).entries(), `
  ┌───────────────────┬─────┬────────┐
  │ (iteration index) │ Key │ Values │
  ├───────────────────┼─────┼────────┤
  │         0         │  1  │   1    │
  │         1         │  2  │   2    │
  │         2         │  3  │   3    │
  └───────────────────┴─────┴────────┘
  `);
  
  test(new Map([[1, 1], [2, 2], [3, 3]]).values(), `
  ┌───────────────────┬────────┐
  │ (iteration index) │ Values │
  ├───────────────────┼────────┤
  │         0         │   1    │
  │         1         │   2    │
  │         2         │   3    │
  └───────────────────┴────────┘
  `);
  
  test(new Map([[1, 1], [2, 2], [3, 3]]).keys(), `
  ┌───────────────────┬────────┐
  │ (iteration index) │ Values │
  ├───────────────────┼────────┤
  │         0         │   1    │
  │         1         │   2    │
  │         2         │   3    │
  └───────────────────┴────────┘
  `);
  
  test(new Set([1, 2, 3]).values(), `
  ┌───────────────────┬────────┐
  │ (iteration index) │ Values │
  ├───────────────────┼────────┤
  │         0         │   1    │
  │         1         │   2    │
  │         2         │   3    │
  └───────────────────┴────────┘
  `);
  
  
  test({ a: { a: 1, b: 2, c: 3 } }, `
  ┌─────────┬───┬───┬───┐
  │ (index) │ a │ b │ c │
  ├─────────┼───┼───┼───┤
  │    a    │ 1 │ 2 │ 3 │
  └─────────┴───┴───┴───┘
  `);
  
  test({ a: { a: { a: 1, b: 2, c: 3 } } }, `
  ┌─────────┬──────────┐
  │ (index) │    a     │
  ├─────────┼──────────┤
  │    a    │ [Object] │
  └─────────┴──────────┘
  `);
  
  test({ a: [1, 2] }, `
  ┌─────────┬───┬───┐
  │ (index) │ 0 │ 1 │
  ├─────────┼───┼───┤
  │    a    │ 1 │ 2 │
  └─────────┴───┴───┘
  `);
  
  test({ a: [1, 2, 3, 4, 5], b: 5, c: { e: 5 } }, `
  ┌─────────┬───┬───┬───┬───┬───┬───┬────────┐
  │ (index) │ 0 │ 1 │ 2 │ 3 │ 4 │ e │ Values │
  ├─────────┼───┼───┼───┼───┼───┼───┼────────┤
  │    a    │ 1 │ 2 │ 3 │ 4 │ 5 │   │        │
  │    b    │   │   │   │   │   │   │   5    │
  │    c    │   │   │   │   │   │ 5 │        │
  └─────────┴───┴───┴───┴───┴───┴───┴────────┘
  `);
  
  test(new Uint8Array([1, 2, 3]), `
  ┌─────────┬────────┐
  │ (index) │ Values │
  ├─────────┼────────┤
  │    0    │   1    │
  │    1    │   2    │
  │    2    │   3    │
  └─────────┴────────┘
  `);
  
  test(Buffer.from([1, 2, 3]), `
  ┌─────────┬────────┐
  │ (index) │ Values │
  ├─────────┼────────┤
  │    0    │   1    │
  │    1    │   2    │
  │    2    │   3    │
  └─────────┴────────┘
  `);
  
  test({ a: undefined }, ['x'], `
  ┌─────────┬───┐
  │ (index) │ x │
  ├─────────┼───┤
  │    a    │   │
  └─────────┴───┘
  `);
  
  test([], `
  ┌─────────┐
  │ (index) │
  ├─────────┤
  └─────────┘
  `);
  
  test(new Map(), `
  ┌───────────────────┬─────┬────────┐
  │ (iteration index) │ Key │ Values │
  ├───────────────────┼─────┼────────┤
  └───────────────────┴─────┴────────┘
  `);
  
  test([{ a: 1, b: 'Y' }, { a: 'Z', b: 2 }], `
  ┌─────────┬─────┬─────┐
  │ (index) │  a  │  b  │
  ├─────────┼─────┼─────┤
  │    0    │  1  │ 'Y' │
  │    1    │ 'Z' │  2  │
  └─────────┴─────┴─────┘
  `);
  