Merge pull request #228 from idrarig/multiline-comments

Multiline comments

lib/test.js

@@ -102,7 +102,10 @@ Test.prototype.test = function (name, opts, cb) {
 };
 
 Test.prototype.comment = function (msg) {
-    this.emit('result', trim(msg).replace(/^#\s*/, ''));
+    var that = this;
+    trim(msg).split('\n').forEach(function (aMsg) {
+        that.emit('result', trim(aMsg).replace(/^#\s*/, ''));
+    });
 };
 
 Test.prototype.plan = function (n) {

test/comment.js

@@ -0,0 +1,177 @@
+var concat = require('concat-stream');
+var tap = require('tap');
+var tape = require('../');
+
+// Exploratory test to ascertain proper output when no t.comment() call
+// is made.
+tap.test('no comment', function (assert) {
+    assert.plan(1);
+
+    var verify = function (output) {
+        assert.equal(output.toString('utf8'), [
+                'TAP version 13',
+                '# no comment',
+                '',
+                '1..0',
+                '# tests 0',
+                '# pass  0',
+                '',
+                '# ok',
+                ''
+        ].join('\n'));
+    };
+
+    var test = tape.createHarness();
+    test.createStream().pipe(concat(verify));
+    test('no comment', function (t) {
+        t.end();
+    });
+});
+
+// Exploratory test, can we call t.comment() passing nothing?
+tap.test('missing argument', function (assert) {
+    assert.plan(2);
+    var test = tape.createHarness();
+    test.createStream();
+    test('missing argument', function (t) {
+        try {
+            t.comment();
+            t.end();
+        } catch (err) {
+            assert.equal(err.constructor, TypeError);
+            assert.equal(err.message, 'Cannot call method on undefined');
+        } finally {
+            assert.end();
+        }
+    });
+});
+
+// Exploratory test, can we call t.comment() passing nothing?
+tap.test('null argument', function (assert) {
+    assert.plan(2);
+    var test = tape.createHarness();
+    test.createStream();
+    test('null argument', function (t) {
+        try {
+            t.comment(null);
+            t.end();
+        } catch (err) {
+            assert.equal(err.constructor, TypeError);
+            assert.equal(err.message, 'Cannot call method on null');
+        } finally {
+            assert.end();
+        }
+    });
+});
+
+
+// Exploratory test, how is whitespace treated?
+tap.test('whitespace', function (assert) {
+    assert.plan(1);
+
+    var verify = function (output) {
+        assert.equal(output.toString('utf8'), [
+                'TAP version 13',
+                '# whitespace',
+                '# ',
+                '# a',
+                '# a',
+                '# a',
+                '',
+                '1..0',
+                '# tests 0',
+                '# pass  0',
+                '',
+                '# ok',
+                ''
+        ].join('\n'));
+    };
+
+    var test = tape.createHarness();
+    test.createStream().pipe(concat(verify));
+    test('whitespace', function (t) {
+        t.comment(' ');
+        t.comment(' a');
+        t.comment('a ');
+        t.comment(' a ');
+        t.end();
+    });
+});
+
+// Exploratory test, how about passing types other than strings?
+tap.test('non-string types', function (assert) {
+    assert.plan(1);
+
+    var verify = function (output) {
+        assert.equal(output.toString('utf8'), [
+                'TAP version 13',
+                '# non-string types',
+                '# true',
+                '# false',
+                '# 42',
+                '# 6.66',
+                '# [object Object]',
+                '# [object Object]',
+                '# [object Object]',
+                '# function ConstructorFunction() {}',
+                '',
+                '1..0',
+                '# tests 0',
+                '# pass  0',
+                '',
+                '# ok',
+                ''
+        ].join('\n'));
+    };
+
+    var test = tape.createHarness();
+    test.createStream().pipe(concat(verify));
+    test('non-string types', function (t) {
+        t.comment(true);
+        t.comment(false);
+        t.comment(42);
+        t.comment(6.66);
+        t.comment({});
+        t.comment({"answer": 42});
+        function ConstructorFunction() {}
+        t.comment(new ConstructorFunction());
+        t.comment(ConstructorFunction);
+        t.end();
+    });
+});
+
+tap.test('multiline string', function (assert) {
+    assert.plan(1);
+
+    var verify = function (output) {
+        assert.equal(output.toString('utf8'), [
+                'TAP version 13',
+                '# multiline strings',
+                '# a',
+                '# b',
+                '# c',
+                '# d',
+                '',
+                '1..0',
+                '# tests 0',
+                '# pass  0',
+                '',
+                '# ok',
+                ''
+        ].join('\n'));
+    };
+
+    var test = tape.createHarness();
+    test.createStream().pipe(concat(verify));
+    test('multiline strings', function (t) {
+        t.comment([
+            'a',
+            'b',
+        ].join('\n'));
+        t.comment([
+            'c',
+            'd',
+        ].join('\r\n'));
+        t.end();
+    });
+});