test: update travis config, handle errors properly, add TEST_LLNODE_DEBUG

.travis.yml

@@ -3,13 +3,13 @@ sudo: required
 dist: trusty
 before_install:
   - sudo apt-get -qq update
-  - sudo apt-get install lldb-3.6 lldb-3.6-dev -y
+  - sudo apt-get install lldb-3.9 liblldb-3.9-dev -y
   - git clone https://chromium.googlesource.com/external/gyp.git tools/gyp
 node_js:
   - "4"
-  - "5"
   - "6"
-  - "7"
+  - "8"
+  - "9"
 branches:
   only:
     - master

Makefile

@@ -19,9 +19,14 @@ uninstall-linux:
 format:
 	clang-format -i src/*
 
-_travis:
-	./gyp_llnode -Dlldb_dir=/usr/lib/llvm-3.6/ -f make
-	make -C out/
-	TEST_LLDB_BINARY=`which lldb-3.6` npm test
+configure: scripts/configure.js
+	node scripts/configure.js
+
+plugin: configure
+	./gyp_llnode
+	$(MAKE) -C out/
+
+_travis: plugin
+	TEST_LLDB_BINARY=`which lldb-3.9` TEST_LLNODE_DEBUG=true npm test
 
 .PHONY: all

test/common.js

@@ -8,27 +8,39 @@ const spawn = require('child_process').spawn;
 const EventEmitter = require('events').EventEmitter;
 
 exports.fixturesDir = path.join(__dirname, 'fixtures');
-exports.buildDir = path.join(__dirname, '..', 'out', 'Release');
+exports.projectDir = path.join(__dirname, '..');
 
 exports.core = path.join(os.tmpdir(), 'core');
-exports.ranges = exports.core + '.ranges';
+exports.promptDelay = 200;
+
+function llnodeDebug() {
+  // Node v4.x does not support rest
+  const args = Array.prototype.slice.call(arguments);
+  console.error.apply(console, [`[TEST][${process.pid}]`].concat(args));
+}
+
+const debug = exports.debug =
+  process.env.TEST_LLNODE_DEBUG ? llnodeDebug : () => { };
 
 let pluginName;
 if (process.platform === 'darwin')
   pluginName = 'llnode.dylib';
 else if (process.platform === 'windows')
   pluginName = 'llnode.dll';
 else
-  pluginName = path.join('lib.target', 'llnode.so');
+  pluginName = 'llnode.so';
 
-exports.llnodePath = path.join(exports.buildDir, pluginName);
+exports.llnodePath = path.join(exports.projectDir, pluginName);
+exports.saveCoreTimeout = 180 * 1000;
+exports.loadCoreTimeout = 20 * 1000;
 
-function SessionOutput(session, stream) {
+function SessionOutput(session, stream, timeout) {
   EventEmitter.call(this);
   this.waiting = false;
   this.waitQueue = [];
-
   let buf = '';
+  this.timeout = timeout || 10000;
+  this.session = session;
 
   stream.on('data', (data) => {
     buf += data;
@@ -44,15 +56,15 @@ function SessionOutput(session, stream) {
 
       if (/process \d+ exited/i.test(line))
         session.kill();
-      else if (session.initialized)
+      else
         this.emit('line', line);
-      else if (/process \d+ launched/i.test(line))
-        session.initialized = true;
     }
   });
 
   // Ignore errors
-  stream.on('error', () => {});
+  stream.on('error', (err) => {
+    debug('[stream error]', err);
+  });
 }
 util.inherits(SessionOutput, EventEmitter);
 
@@ -72,109 +84,171 @@ SessionOutput.prototype._unqueueWait = function _unqueueWait() {
     this.waitQueue.shift()();
 };
 
-SessionOutput.prototype.wait = function wait(regexp, callback) {
-  if (!this._queueWait(() => { this.wait(regexp, callback); }))
+SessionOutput.prototype.timeoutAfter = function timeoutAfter(timeout) {
+  this.timeout = timeout;
+};
+
+SessionOutput.prototype.wait = function wait(regexp, callback, allLines) {
+  if (!this._queueWait(() => { this.wait(regexp, callback, allLines); }))
     return;
 
   const self = this;
-  this.on('line', function onLine(line) {
+  const lines = [];
+
+  function onLine(line) {
+    lines.push(line);
+    debug('[LINE]', line);
+
     if (!regexp.test(line))
       return;
 
     self.removeListener('line', onLine);
     self._unqueueWait();
+    done = true;
 
-    callback(line);
-  });
-};
-
-SessionOutput.prototype.waitBreak = function waitBreak(callback) {
-  this.wait(/Process \d+ stopped/i, callback);
-};
-
-SessionOutput.prototype.linesUntil = function linesUntil(regexp, callback) {
-  if (!this._queueWait(() => { this.linesUntil(regexp, callback); }))
-    return;
-
-  const lines = [];
-  const self = this;
-  this.on('line', function onLine(line) {
-    lines.push(line);
+    callback(null, allLines ? lines : line);
+  }
 
-    if (!regexp.test(line))
+  let done = false;
+  const check = setTimeout(() => {
+    if (done)
       return;
 
     self.removeListener('line', onLine);
     self._unqueueWait();
+    console.error(`${'='.repeat(10)} lldb output ${'='.repeat(10)}`);
+    console.error(lines.join('\n'));
+    console.error('='.repeat(33));
+    const message = `Test timeout in ${this.timeout} ` +
+      `waiting for ${regexp}`;
+    callback(new Error(message));
+  }, this.timeout).unref();
+
+  this.on('line', onLine);
+};
 
-    callback(lines);
+SessionOutput.prototype.waitBreak = function waitBreak(callback) {
+  this.wait(/Process \d+ stopped/i, (err) => {
+    if (err)
+      return callback(err);
+
+    // Do not resume immediately since the process would print
+    // the instructions out and input sent before the stdout finish
+    // could be lost
+    setTimeout(callback, exports.promptDelay);
   });
 };
 
+SessionOutput.prototype.linesUntil = function linesUntil(regexp, callback) {
+  this.wait(regexp, callback, true);
+};
 
-function Session(scenario) {
+function Session(options) {
   EventEmitter.call(this);
+  const timeout = parseInt(process.env.TEST_TIMEOUT) || 10000;
+  const lldbBin = process.env.TEST_LLDB_BINARY || 'lldb';
+  const env = Object.assign({}, process.env);
+
+  if (options.ranges)
+    env.LLNODE_RANGESFILE = options.ranges;
+
+  debug('lldb binary:', lldbBin);
+  if (options.scenario) {
+    this.needToKill = true;
+    // lldb -- node scenario.js
+    const args = [
+      '--',
+      process.execPath,
+      '--abort_on_uncaught_exception',
+      '--expose_externalize_string',
+      path.join(exports.fixturesDir, options.scenario)
+    ];
+
+    debug('lldb args:', args);
+    this.lldb = spawn(lldbBin, args, {
+      stdio: ['pipe', 'pipe', 'pipe'],
+      env: env
+    });
+    this.lldb.stdin.write(`plugin load "${exports.llnodePath}"\n`);
+    this.lldb.stdin.write('run\n');
+  } else if (options.core) {
+    this.needToKill = false;
+    debug('loading core', options.core);
+    // lldb node -c core
+    this.lldb = spawn(lldbBin, [], {
+      stdio: ['pipe', 'pipe', 'pipe'],
+      env: env
+    });
+    this.lldb.stdin.write(`plugin load "${exports.llnodePath}"\n`);
+    this.lldb.stdin.write(`target create "${options.executable}"` +
+      ` --core "${options.core}"\n`);
+  }
+  this.stdout = new SessionOutput(this, this.lldb.stdout, timeout);
+  this.stderr = new SessionOutput(this, this.lldb.stderr, timeout);
 
-  // lldb -- node scenario.js
-  this.lldb = spawn(process.env.TEST_LLDB_BINARY || 'lldb', [
-    '--',
-    process.execPath,
-    '--abort_on_uncaught_exception',
-    '--expose_externalize_string',
-    path.join(exports.fixturesDir, scenario)
-  ], {
-    stdio: [ 'pipe', 'pipe', 'pipe' ],
-    env: util._extend(util._extend({}, process.env), {
-      LLNODE_RANGESFILE: exports.ranges
-    })
+  this.stderr.on('line', (line) => {
+    debug('[stderr]', line);
   });
 
-  this.lldb.stdin.write(`plugin load "${exports.llnodePath}"\n`);
-  this.lldb.stdin.write('run\n');
-
-  this.initialized = false;
-  this.stdout = new SessionOutput(this, this.lldb.stdout);
-  this.stderr = new SessionOutput(this, this.lldb.stderr);
-
   // Map these methods to stdout for compatibility with legacy tests.
   this.wait = SessionOutput.prototype.wait.bind(this.stdout);
   this.waitBreak = SessionOutput.prototype.waitBreak.bind(this.stdout);
   this.linesUntil = SessionOutput.prototype.linesUntil.bind(this.stdout);
+  this.timeoutAfter = SessionOutput.prototype.timeoutAfter.bind(this.stdout);
 }
 util.inherits(Session, EventEmitter);
 exports.Session = Session;
 
 Session.create = function create(scenario) {
-  return new Session(scenario);
+  return new Session({ scenario: scenario });
+};
+
+Session.loadCore = function loadCore(executable, core, ranges) {
+  return new Session({
+    executable: executable,
+    core: core,
+    ranges: ranges
+  });
+};
+
+Session.prototype.waitCoreLoad = function waitCoreLoad(callback) {
+  this.wait(/Core file[^\n]+was loaded/, callback);
 };
 
 Session.prototype.kill = function kill() {
-  this.lldb.kill();
-  this.lldb = null;
+  // if a 'quit' has been sent to lldb, killing it could result in ECONNRESET
+  if (this.lldb.channel) {
+    debug('kill lldb');
+    this.lldb.kill();
+    this.lldb = null;
+  }
 };
 
 Session.prototype.quit = function quit() {
-  this.send('kill');
+  if (this.needToKill)
+    this.send('kill'); // kill the process launched in lldb
+
   this.send('quit');
 };
 
 Session.prototype.send = function send(line, callback) {
+  debug('[SEND]', line);
   this.lldb.stdin.write(line + '\n', callback);
 };
 
-
-exports.generateRanges = function generateRanges(cb) {
+exports.generateRanges = function generateRanges(core, dest, cb) {
   let script;
   if (process.platform === 'darwin')
     script = path.join(__dirname, '..', 'scripts', 'otool2segments.py');
   else
     script = path.join(__dirname, '..', 'scripts', 'readelf2segments.py');
 
-  const proc = spawn(script, [ exports.core ], {
-    stdio: [ null, 'pipe', 'inherit' ]
+  debug('[RANGES]', `${script}, ${core}, ${dest}`);
+  const proc = spawn(script, [core], {
+    stdio: [null, 'pipe', 'inherit']
   });
 
-  proc.stdout.pipe(fs.createWriteStream(exports.ranges));
+  proc.stdout.pipe(fs.createWriteStream(dest));
 
   proc.on('exit', (status) => {
     cb(status === 0 ? null : new Error('Failed to generate ranges'));

test/frame-test.js

@@ -8,11 +8,13 @@ tape('v8 stack', (t) => {
   t.timeoutAfter(15000);
 
   const sess = common.Session.create('frame-scenario.js');
-  sess.waitBreak(() => {
+  sess.waitBreak((err) => {
+    t.error(err);
     sess.send('v8 bt');
   });
 
-  sess.linesUntil(/eyecatcher/, (lines) => {
+  sess.linesUntil(/eyecatcher/, (err, lines) => {
+    t.error(err);
     lines.reverse();
     t.ok(lines.length > 4, 'frame count');
     // FIXME(bnoordhuis) This can fail with versions of lldb that don't