Updates node_modules
DISABLE_THIRD_PARTY_CHECK=Package needs updating with node_modules
Change-Id: I889f1b86c586e37307a3e13ad762aa56d1ece150
Reviewed-on: https://chromium-review.googlesource.com/c/devtools/devtools-frontend/+/1946468
Commit-Queue: Paul Lewis <aerotwist@chromium.org>
Reviewed-by: Tim van der Lippe <tvanderlippe@chromium.org>
diff --git a/node_modules/treeify/test/tree-test.js b/node_modules/treeify/test/tree-test.js
new file mode 100644
index 0000000..c5841e9
--- /dev/null
+++ b/node_modules/treeify/test/tree-test.js
@@ -0,0 +1,347 @@
+var treeify = require('../treeify'),
+ vows = require('vows'),
+ assert = require('assert'),
+ events = require('events');
+
+// - helper functions -----------------
+
+function treeifyByLineGuts(args) {
+ var emitter = new events.EventEmitter(),
+ lineNum = 0;
+ args.push(function(line) {
+ emitter.emit('success', line);
+ emitter.emit('line ' + (++lineNum), line);
+ });
+ treeify.asLines.apply(this, args);
+ return emitter;
+}
+
+function treeifyByLine(obj) {
+ return function(showValues) {
+ var arguments = [ obj, showValues ];
+ return treeifyByLineGuts(arguments);
+ };
+}
+
+function treeifyByLineWithHideFunctionsArgument(obj) {
+ return function(showValues, hideFunctions) {
+ var arguments = [ obj, showValues, hideFunctions ];
+ return treeifyByLineGuts(arguments);
+ };
+}
+
+function treeifyEntirely(obj) {
+ return function(showValues, hideFunctions) {
+ return treeify.asTree(obj, showValues, hideFunctions);
+ };
+}
+
+function withValuesShown(showValues) {
+ return function(func){ return func(showValues, false) };
+}
+
+function withValuesShownFunctionsHidden() {
+ return function(func){ return func(true, true) };
+
+}
+
+function is(content, arrayIndex) {
+ return function(lines) {
+ var toCheck = lines;
+ if (arrayIndex !== undefined) {
+ toCheck = lines[arrayIndex];
+ }
+ assert.strictEqual(toCheck, content, 'should be "' + content + '" but was "' + toCheck + '"');
+ };
+}
+
+function checkLines(/* ... */) {
+ var ret = {}, entry;
+ for (var line = 1; line <= arguments.length; line++) {
+ if ( ! arguments[line - 1])
+ continue;
+ entry = {};
+ entry['branches correctly on line '+line] = is(arguments[line - 1]);
+ ret['line '+line] = entry;
+ }
+ return ret;
+}
+
+// - the beautiful test suite ---------
+
+vows.describe('tree-test').addBatch({
+
+ 'A tree created from an empty object': {
+ topic: {},
+
+ 'when returned as a whole tree': {
+ topic: treeifyEntirely,
+
+ 'with values hidden': {
+ topic: withValuesShown(false),
+ 'is an empty string': is('')
+ },
+ 'with values shown': {
+ topic: withValuesShown(true),
+ 'is an empty string': is('')
+ }
+ }
+ },
+
+ 'A tree created from a single-level object': {
+ topic: {
+ apples: 'gala', // ├─ apples: gala
+ oranges: 'mandarin' // └─ oranges: mandarin
+ },
+
+ 'when returned line-by-line': {
+ topic: treeifyByLine,
+
+ 'with values hidden': {
+ topic: withValuesShown(false),
+
+ 'is two lines long': function(err, line) {
+ this.expect(2);
+ },
+ on: checkLines('├─ apples',
+ '└─ oranges')
+ },
+ 'with values shown': {
+ topic: withValuesShown(true),
+
+ 'is two lines long': function(err, line) {
+ this.expect(2);
+ },
+ on: checkLines('├─ apples: gala',
+ '└─ oranges: mandarin')
+ }
+ },
+
+ 'when returned as a whole tree': {
+ topic: treeifyEntirely,
+
+ 'with values hidden': {
+ topic: withValuesShown(false),
+
+ 'is not empty': function(tree) {
+ assert.notEqual(tree, '', 'should not be empty');
+ },
+ 'contains 2 line breaks': function(tree) {
+ assert.strictEqual(tree.match(/\n/g).length, 2, 'should contain 2 x \n');
+ },
+ '(split into an array of lines)': {
+ topic: function(tree) { return tree.split(/\n/g) },
+ 'has a correct first line': is('├─ apples', 0),
+ 'has a correct second line': is('└─ oranges', 1),
+ 'has nothing at the end': is('', 2)
+ }
+ },
+ 'with values shown': {
+ topic: withValuesShown(true),
+
+ 'is not empty': function(tree) {
+ assert.notEqual(tree, '', 'should not be empty');
+ },
+ 'contains 2 line breaks': function(tree) {
+ assert.strictEqual(tree.match(/\n/g).length, 2, 'should contain 2 x \n');
+ },
+ '(split into an array of lines)': {
+ topic: function(tree) { return tree.split(/\n/g) },
+ 'has a correct first line': is('├─ apples: gala', 0),
+ 'has a correct second line': is('└─ oranges: mandarin', 1),
+ 'has nothing at the end': is('', 2)
+ }
+ }
+ }
+ },
+
+ 'A tree created from a multi-level object': {
+ topic: {
+ oranges: { // ├─ oranges
+ 'mandarin': { // │ └─ mandarin
+ clementine: null, // │ ├─ clementine
+ tangerine: // │ └─ tangerine
+ 'so cheap and juicy!'
+ }
+ },
+ apples: { // └─ apples
+ 'gala': null, // ├─ gala
+ 'pink lady': null // └─ pink lady
+ }
+ },
+
+ 'when returned line-by-line': {
+ topic: treeifyByLine,
+
+ 'with values hidden': {
+ topic: withValuesShown(false),
+
+ 'is seven lines long': function(err, line) {
+ this.expect(7);
+ },
+ on: checkLines('├─ oranges',
+ '│ └─ mandarin',
+ '│ ├─ clementine',
+ '│ └─ tangerine',
+ '└─ apples',
+ ' ├─ gala',
+ ' └─ pink lady')
+ },
+ 'with values shown': {
+ topic: withValuesShown(true),
+ on: checkLines(null, null, null,
+ '│ └─ tangerine: so cheap and juicy!')
+ }
+ },
+
+ 'when returned as a whole tree': {
+ topic: treeifyEntirely,
+
+ 'with values shown': {
+ topic: withValuesShown(true),
+
+ '(split into an array of lines)': {
+ topic: function(tree) { return tree.split(/\n/g) },
+ 'has a correct first line': is('├─ oranges', 0),
+ 'has a correct third line': is('│ └─ tangerine: so cheap and juicy!', 3),
+ 'has nothing at the end': is('', 7)
+ }
+ }
+ }
+ },
+
+ 'A tree created from an object with not so circular references': {
+ topic: function() {
+ var obj = { one: 'one', two: { four: 'four' } };
+ obj['three'] = obj.two;
+ return obj;
+ },
+
+ 'when returned line-by-line': {
+ topic: treeifyByLine,
+
+ 'with values shown': {
+ topic: withValuesShown(true),
+ on: checkLines('├─ one: one',
+ '├─ two',
+ '│ └─ four: four',
+ '└─ three',
+ ' └─ four: four')
+ }
+ }
+ },
+
+ 'A tree created from an object with circular references': {
+ topic: function() {
+ var obj = { one: 'one', two: 'two' };
+ obj['three'] = obj;
+ return obj;
+ },
+
+ 'when returned line-by-line': {
+ topic: treeifyByLine,
+
+ 'with values shown': {
+ topic: withValuesShown(true),
+ on: checkLines('├─ one: one',
+ '├─ two: two',
+ '└─ three (circular ref.)')
+ }
+ }
+ },
+
+ 'A tree created from an object containing various types': {
+ topic: {
+ array: [ 'one', 'two' ],
+ numeric: 42,
+ decimal: 42.24,
+ bool: false,
+ nil: null,
+ undef: undefined,
+ date: new Date(2018,0,1)
+ },
+
+ 'when returned line-by-line': {
+ topic: treeifyByLine,
+
+ 'with values shown': {
+ topic: withValuesShown(true),
+ on: checkLines('├─ array',
+ '│ ├─ 0: one',
+ '│ └─ 1: two',
+ '├─ numeric: 42',
+ '├─ decimal: 42.24',
+ '├─ bool: false',
+ '├─ nil',
+ '├─ undef: undefined',
+ '└─ date: Mon Jan 01 2018 00:00:00 GMT+0000 (UTC)')
+ }
+ }
+ },
+
+ 'A tree created from an object with prototyped functions': {
+ topic: function() {
+ var func = function(){
+ this.Friendly = 'stuff';
+ }
+ func.prototype.Nasty = function(){}
+ return new func();
+ },
+
+ 'when returned as a whole tree': {
+ topic: treeifyEntirely,
+
+ 'with values shown': {
+ topic: withValuesShown(true),
+
+ 'and split into an array of lines': {
+ topic: function(tree) { return tree.split(/\n/g) },
+ 'is a one liner output (with a following blank line)': function(lines) {
+ assert.equal(lines.length, 2);
+ },
+ 'has a correct first line': is('└─ Friendly: stuff', 0)
+ }
+ }
+ }
+ },
+ 'A tree with functions': {
+ topic: {
+ func:function(){},
+ Friendly:"stuff",
+ Another:"stuff"
+ },
+
+ 'when returned line-by-line': {
+ topic: treeifyByLineWithHideFunctionsArgument,
+
+ 'with values shown, but functions hidden': {
+ topic: withValuesShownFunctionsHidden(),
+
+ 'is two lines long': function(err, line) {
+ this.expect(2);
+ },
+ on: checkLines('├─ Friendly: stuff',
+ '└─ Another: stuff')
+ }
+ },
+
+ 'when returned as a whole tree': {
+ topic: treeifyEntirely,
+
+ 'with values shown, but functions hidden': {
+ topic: withValuesShownFunctionsHidden(),
+
+ 'and split into an array of lines': {
+ topic: function(tree) {
+ console.error(tree);
+ return tree.split(/\n/g) },
+ 'is a one liner output (with a following blank line)': function(lines) {
+ assert.equal(lines.length, 3);
+ },
+ 'has a correct first line': is('├─ Friendly: stuff', 0)
+ }
+ }
+ }
+ }
+
+}).export(module);