deadunit-core - npm Package Compare versions

Comparing version 2.0.9 to 3.0.0

deadunitCore.js

@@ -48,4 +48,24 @@ "use strict";
         this.init = function(/*mainName=undefined, groups*/) {
+            var that = this
+            var args = arguments
             this.manager = EventManager()
 
+            setTimeout(function() {
+                runTest.call(that, args)
+            },0)
+        }
+
+        this.events = function(handlers) {
+            this.manager.add(handlers)
+            return this
+        }
+
+        this.results = function(printLateEvents) {
+            if(printLateEvents === undefined) printLateEvents = true
+            return processResults(this, printLateEvents)
+        }
+
+        // private
+
+        function runTest(args) {
             var fakeTest = new UnitTester()
@@ -66,3 +86,3 @@ fakeTest.id = undefined // fake test doesn't get an id
 
-            fakeTest.mainSubTest = UnitTester.prototype.test.apply(fakeTest, arguments) // set so the error handler can access the real test
+            fakeTest.mainSubTest = UnitTester.prototype.test.apply(fakeTest, args) // set so the error handler can access the real test
             this.mainTester = fakeTest
@@ -73,11 +93,2 @@
         }
-
-        this.events = function(handlers) {
-            this.manager.add(handlers)
-        }
-
-        this.results = function(printLateEvents) {
-            if(printLateEvents === undefined) printLateEvents = true
-            return processResults(this, printLateEvents)
-        }
     })
@@ -84,0 +95,0 @@

deadunitCore.node.js

@@ -79,6 +79,9 @@ "use strict";
         if(e.stack)
-            console.log(e.stack)
+            var errorString = e.stack
         else
-            console.log(e)
+            var errorString = e.toString()
+
+        if(errorString.red !== undefined) errorString = errorString.red
+            console.log(errorString)
     },0)
 }

package.json

 {"name":"deadunit-core",
  "description": "The core for deadunit - a dead-simple nestable unit testing library for javascript and node.js.",
  "keywords": ["unit", "test", "testing", "javascript", "node", "deadunit", "asynchronous"],
- "version":"2.0.9",
+ "version":"3.0.0",
  "dependencies":{
@@ -6,0 +6,0 @@ "stack-trace":"0.0.7",

processResults.js

@@ -70,3 +70,3 @@ module.exports = function returnResults(unitTestObject, printLateEvents) {
         exception: function(e) {
-            writeLateEvent(ended,"At time: "+e.time+" "+(e.error.stack?e.error.stack:e.error.toString()))
+            writeLateEvent(ended,"Error: At time: "+e.time+" "+(e.error.stack?e.error.stack:e.error.toString()))
 
@@ -73,0 +73,0 @@ groups[e.parent].exceptions.push(e.error)

README.md

@@ -28,5 +28,9 @@ **Status**: API finalized, needs testing
     this.done()
+}).events({
+ 	end: function() {
+    	console.dir(test.results())
+    }
 })
 
-console.dir(test.results())
+
 ```
@@ -42,4 +46,4 @@
 }).events({
-    group: function(e) {
-        console.log(e.name +" started at "+e.time)
+    group: function(g) {
+        console.log(g.name +" started at "+g.time)
     },
@@ -49,6 +53,6 @@ assert: function(e) {
     },
-    log: function(e) {
-        console.dir(e.values)
+    log: function(log) {
+        console.dir(log.values)
     },
-    end: function(e) {
+    end: function() {
         console.log("Done!")
@@ -58,3 +62,2 @@ }
 
-console.dir(test.results())
 ```
@@ -83,3 +86,3 @@
 
-`Unit.test([<name>, ]<testFunction>)` - runs a suite of unit tests. Returns a `UnitTest` object.
+`Unit.test([<name>, ]<testFunction>)` - runs a suite of unit tests. Returns a `UnitTest` object. Returns without having run the tests first - the tests are scheduled to run asynchronously soon thereafter.
 
@@ -292,2 +295,5 @@ * `<name>` - (optional) names the test
 
+* 3.0.0
+ * making top-level test run asynchronously to make some things work better with node fibers
+ * since this means you basically always have to wait for the 'end' event before getting results, it may break old tests (fixable with minor tweaking), so upping major versions
 * 2.0.9
@@ -294,0 +300,0 @@ * fixing silent-failure issue when the test times out before it completes synchronously

test/deadunitTests.js

@@ -13,35 +13,52 @@ "use strict";
         //*
-        this.test('simple success', function() {
+        this.test('simple success', function(t) {
+            this.count(3)
             var test = Unit.test(function() {
                 this.ok(true)
-            }).results()
+            }).events({
+                end: function() {
+                    var results = test.results()
 
-            this.ok(test.name === undefined, test.name)
-            this.ok(test.results.length === 1)
-            this.ok(test.results[0].success === true)
+                    t.ok(results.name === undefined, results.name)
+                    t.ok(results.results.length === 1)
+                    t.ok(results.results[0].success === true)
+                }
+            })
         })
 
-        this.test('simple failure', function() {
+        this.test('simple failure', function(t) {
+            this.count(3)
             var test = Unit.test(function() {
                 this.ok(false)
-            }).results()
+            }).events({
+                end: function() {
+                    var results = test.results()
 
-            this.ok(test.name === undefined)
-            this.ok(test.results.length === 1)
-            this.ok(test.results[0].success === false)
+                    t.ok(results.name === undefined)
+                    t.ok(results.results.length === 1)
+                    t.ok(results.results[0].success === false)
+                }
+            })
         })
-        this.test('simple exception', function() {
+        this.test('simple exception', function(t) {
+            this.count(4)
             var test = Unit.test(function() {
                 this.count(1)
-                this.timeout(100) // just to make the test end faster
+                this.timeout(0) // just to make the test end faster
                 throw Error("sync")
-            }).results()
+            }).events({
+                end: function() {
+                    var results = test.results()
 
-            this.ok(test.name === undefined)
-            this.ok(test.exceptions.length === 1)
-            this.ok(test.exceptions[0].message === 'sync')
-            this.ok(test.timeout === undefined, test.timeout) // the test hasn't end yet
+                    t.ok(results.name === undefined)
+                    t.ok(results.exceptions.length === 1)
+                    t.ok(results.exceptions[0].message === 'sync')
+                    t.ok(results.timeout === true, results.timeout)
+                }
+            })
         })
 
         this.test('simple async exception', function(t) {
+            this.count(4)
+
             var simpleAsyncExceptionFuture = new Future, simpleAsyncExceptionFutureDone = new Future
@@ -57,15 +74,17 @@ var simpleAsyncExceptionTest = Unit.test(function(t) {
                 }, 0)
-            })
+            }).events({
+                end: function() {
+                    simpleAsyncExceptionFuture.then(function() {
+                        var test = simpleAsyncExceptionTest.results()
 
-            simpleAsyncExceptionFuture.then(function() {
-                var test = simpleAsyncExceptionTest.results()
+                        t.ok(test.name === undefined)
+                        t.ok(test.exceptions.length === 1)
+                        t.ok(test.exceptions[0].message === 'Async')
+                        t.ok(test.timeout === false)
 
-                t.ok(test.name === undefined)
-                t.ok(test.exceptions.length === 1)
-                t.ok(test.exceptions[0].message === 'Async')
-                t.ok(test.timeout === false)
+                        simpleAsyncExceptionFutureDone.return()
+                    }).done()
+                }
+            })
 
-                simpleAsyncExceptionFutureDone.return()
-            }).done()
-
             moreFutures.push(simpleAsyncExceptionFutureDone)
@@ -149,145 +168,147 @@ })
                 },50)
-            })
+            }).events({end: function() {
 
-            var futuresForThisTest = Future.all(futuresToWaitOn)
-            moreFutures.push(futuresForThisTest)
-            futuresForThisTest.then(function() {
-                var test = testGroups.results()
+                var futuresForThisTest = Future.all(futuresToWaitOn)
+                moreFutures.push(futuresForThisTest)
+                futuresForThisTest.then(function() {
+                    var test = testGroups.results()
 
-                this.ok(test.timeout === false, test.timeout)
-                this.ok(test.type === "group")
-                this.ok(test.name === "Full deadunit test (results of this will be verified)")
-                this.ok(test.syncDuration !== undefined && test.syncDuration > 0, test.syncDuration)
-                this.ok(test.exceptions.length === 0)
-                this.ok(test.results.length === 4, test.results.length)
+                    this.ok(test.timeout === false, test.timeout)
+                    this.ok(test.type === "group")
+                    this.ok(test.name === "Full deadunit test (results of this will be verified)")
+                    this.ok(test.syncDuration !== undefined && test.syncDuration > 0, test.syncDuration)
+                    this.ok(test.exceptions.length === 0)
+                    this.ok(test.results.length === 4, test.results.length)
 
-                this.test("Verify 'Test Some Stuff'", function() {
-                    this.count(50)
+                    this.test("Verify 'Test Some Stuff'", function() {
+                        this.count(50)
 
-                    var subtest1 = test.results[0]
-                    this.ok(subtest1.type === "group")
-                    this.ok(subtest1.name === "Test Some Stuff")
-                    this.ok(subtest1.syncDuration !== undefined && subtest1.syncDuration > 0 && subtest1.syncDuration < 100, subtest1.syncDuration)
-                    this.ok(subtest1.totalSyncDuration !== undefined && subtest1.totalSyncDuration >= subtest1.totalSyncDuration)  // totalDuration is the duration including before and after
-                    this.ok(subtest1.exceptions.length === 0)
-                    this.ok(subtest1.results.length === 7, subtest1.results.length)
+                        var subtest1 = test.results[0]
+                        this.ok(subtest1.type === "group")
+                        this.ok(subtest1.name === "Test Some Stuff")
+                        this.ok(subtest1.syncDuration !== undefined && subtest1.syncDuration > 0 && subtest1.syncDuration < 100, subtest1.syncDuration)
+                        this.ok(subtest1.totalSyncDuration !== undefined && subtest1.totalSyncDuration >= subtest1.totalSyncDuration)  // totalDuration is the duration including before and after
+                        this.ok(subtest1.exceptions.length === 0)
+                        this.ok(subtest1.results.length === 7, subtest1.results.length)
 
-                    var subtest2 = subtest1.results[0]
-                    this.ok(subtest2.type === "group")
-                    this.ok(subtest2.name === "assertSomething")
-                    this.ok(subtest2.exceptions.length === 0)
-                    this.ok(subtest2.results.length === 1)
+                        var subtest2 = subtest1.results[0]
+                        this.ok(subtest2.type === "group")
+                        this.ok(subtest2.name === "assertSomething")
+                        this.ok(subtest2.exceptions.length === 0)
+                        this.ok(subtest2.results.length === 1)
 
-                    var subtest3 = subtest2.results[0]
-                    this.ok(subtest3.type === "assert")
-                    this.ok(subtest3.success === true)
-                    this.ok(subtest3.sourceLines.indexOf("5 === 5") !== -1)
-                    this.ok(subtest3.file === "deadunitTests.js")
-                    this.ok(subtest3.line === 80, subtest3.line)
-                    //this.ok(subtest3.column === 9, subtest3.column)
+                        var subtest3 = subtest2.results[0]
+                        this.ok(subtest3.type === "assert")
+                        this.ok(subtest3.success === true)
+                        this.ok(subtest3.sourceLines.indexOf("5 === 5") !== -1)
+                        this.ok(subtest3.file === "deadunitTests.js")
+                        this.ok(subtest3.line === 99, subtest3.line)
+                        //this.ok(subtest3.column === 9, subtest3.column)
 
-                    subtest2 = subtest1.results[1]
-                    this.ok(subtest2.name === "'shouldFail' fails correctly", subtest2.name)
-                    this.ok(subtest2.syncDuration !== undefined && subtest2.syncDuration >= 0 && subtest2.syncDuration < 10, subtest2.syncDuration)
-                    this.ok(subtest2.exceptions.length === 0)
-                    this.ok(subtest2.results.length === 4, subtest2.results.length)
+                        subtest2 = subtest1.results[1]
+                        this.ok(subtest2.name === "'shouldFail' fails correctly", subtest2.name)
+                        this.ok(subtest2.syncDuration !== undefined && subtest2.syncDuration >= 0 && subtest2.syncDuration < 10, subtest2.syncDuration)
+                        this.ok(subtest2.exceptions.length === 0)
+                        this.ok(subtest2.results.length === 4, subtest2.results.length)
 
-                    subtest3 = subtest2.results[0]
-                    this.ok(subtest3.success === false)
-                    this.ok(subtest3.sourceLines.indexOf("5 === 3") !== -1)
-                    this.ok(subtest3.actual === 'actual')
-                    this.ok(subtest3.expected === 'expected')
+                        subtest3 = subtest2.results[0]
+                        this.ok(subtest3.success === false)
+                        this.ok(subtest3.sourceLines.indexOf("5 === 3") !== -1)
+                        this.ok(subtest3.actual === 'actual')
+                        this.ok(subtest3.expected === 'expected')
 
-                    subtest3 = subtest2.results[1]
-                    this.ok(subtest3.success === false)
-                    this.ok(subtest3.sourceLines.indexOf("true, false") !== -1)
-                    this.ok(subtest3.file === "deadunitTests.js")
-                    this.ok(subtest3.line === 84, subtest3.line)
-                    //this.ok(subtest3.column === 9, subtest3.column)
+                        subtest3 = subtest2.results[1]
+                        this.ok(subtest3.success === false)
+                        this.ok(subtest3.sourceLines.indexOf("true, false") !== -1)
+                        this.ok(subtest3.file === "deadunitTests.js")
+                        this.ok(subtest3.line === 103, subtest3.line)
+                        //this.ok(subtest3.column === 9, subtest3.column)
 
-                    subtest3 = subtest2.results[2]
-                    this.ok(subtest3.type === "log")
-                    this.ok(subtest3.values.length === 1)
-                    this.ok(subtest3.values[0] === "test log")
+                        subtest3 = subtest2.results[2]
+                        this.ok(subtest3.type === "log")
+                        this.ok(subtest3.values.length === 1)
+                        this.ok(subtest3.values[0] === "test log")
 
 
-                    subtest3 = subtest2.results[3]      // count
-                    this.ok(subtest3.type === "assert", subtest3.type)
-                    this.ok(subtest3.success === true, subtest3.success)
+                        subtest3 = subtest2.results[3]      // count
+                        this.ok(subtest3.type === "assert", subtest3.type)
+                        this.ok(subtest3.success === true, subtest3.success)
 
-                    subtest2 = subtest1.results[2]
-                    this.ok(subtest2.name === "shouldThrowException")
-                    this.ok(subtest2.syncDuration !== undefined && subtest2.syncDuration >= 0 && subtest2.syncDuration < 10, subtest2.syncDuration)
-                    this.ok(subtest2.exceptions.length === 1)
-                    this.ok(subtest2.exceptions[0].message === "Ahhhhh!")
-                    this.ok(subtest2.results.length === 2, subtest2.results.length)
+                        subtest2 = subtest1.results[2]
+                        this.ok(subtest2.name === "shouldThrowException")
+                        this.ok(subtest2.syncDuration !== undefined && subtest2.syncDuration >= 0 && subtest2.syncDuration < 10, subtest2.syncDuration)
+                        this.ok(subtest2.exceptions.length === 1)
+                        this.ok(subtest2.exceptions[0].message === "Ahhhhh!")
+                        this.ok(subtest2.results.length === 2, subtest2.results.length)
 
-                    subtest3 = subtest2.results[0]
-                    this.ok(subtest3.success === true)
+                        subtest3 = subtest2.results[0]
+                        this.ok(subtest3.success === true)
 
-                    subtest3 = subtest2.results[1]     // count
-                    this.ok(subtest3.success === true)
+                        subtest3 = subtest2.results[1]     // count
+                        this.ok(subtest3.success === true)
 
-                    subtest2 = subtest1.results[3]
-                    this.ok(subtest2.name === "should throw an asynchronous exception")
-                    this.ok(subtest2.exceptions.length === 1)
-                    this.ok(subtest2.exceptions[0].message === "Asynchronous Ahhhhh!")
-                    this.ok(subtest2.results.length === 2, subtest2.results.length)
+                        subtest2 = subtest1.results[3]
+                        this.ok(subtest2.name === "should throw an asynchronous exception")
+                        this.ok(subtest2.exceptions.length === 1)
+                        this.ok(subtest2.exceptions[0].message === "Asynchronous Ahhhhh!")
+                        this.ok(subtest2.results.length === 2, subtest2.results.length)
 
-                    this.ok(subtest1.results[4].type === 'log', subtest1.results[4].type) // log
-                    this.ok(subtest1.results[4].values[0] === 'subtest without a name')
+                        this.ok(subtest1.results[4].type === 'log', subtest1.results[4].type) // log
+                        this.ok(subtest1.results[4].values[0] === 'subtest without a name')
 
-                    subtest2 = subtest1.results[5]
-                    this.ok(subtest2.name === undefined)
-                    this.ok(subtest2.exceptions.length === 0)
-                    this.ok(subtest2.results.length === 1)
-                    this.ok(subtest2.results[0].success === true)
+                        subtest2 = subtest1.results[5]
+                        this.ok(subtest2.name === undefined)
+                        this.ok(subtest2.exceptions.length === 0)
+                        this.ok(subtest2.results.length === 1)
+                        this.ok(subtest2.results[0].success === true)
 
-                    subtest2 = subtest1.results[6]     // count
-                    this.ok(subtest2.success === false, subtest2.success)
-                })
+                        subtest2 = subtest1.results[6]     // count
+                        this.ok(subtest2.success === false, subtest2.success)
+                    })
 
-                this.test("Verify 'SuccessfulTestGroup'", function() {
-                    this.count(8)
+                    this.test("Verify 'SuccessfulTestGroup'", function() {
+                        this.count(8)
 
-                    var subtest1 = test.results[1]
-                    this.ok(subtest1.name === "SuccessfulTestGroup")
-                    this.ok(subtest1.exceptions.length === 0)
-                    this.ok(subtest1.results.length === 1)
+                        var subtest1 = test.results[1]
+                        this.ok(subtest1.name === "SuccessfulTestGroup")
+                        this.ok(subtest1.exceptions.length === 0)
+                        this.ok(subtest1.results.length === 1)
 
-                    var subtest2 = subtest1.results[0]
-                    this.ok(subtest2.name === "yay")
-                    this.ok(subtest2.exceptions.length === 0)
-                    this.ok(subtest2.results.length === 1)
+                        var subtest2 = subtest1.results[0]
+                        this.ok(subtest2.name === "yay")
+                        this.ok(subtest2.exceptions.length === 0)
+                        this.ok(subtest2.results.length === 1)
 
-                    var subtest3 = subtest2.results[0]
-                    this.ok(subtest3.success === true)
-                    this.ok(subtest3.sourceLines.indexOf("true") !== -1)
-                })
+                        var subtest3 = subtest2.results[0]
+                        this.ok(subtest3.success === true)
+                        this.ok(subtest3.sourceLines.indexOf("true") !== -1)
+                    })
 
-                this.test("Verify 'long before/after'", function() {
-                    this.count(5)
+                    this.test("Verify 'long before/after'", function() {
+                        this.count(5)
 
-                    var subtest1 = test.results[2]
-                    this.ok(subtest1.name === "long before/after")
-                    this.ok(subtest1.exceptions.length === 0)
-                    this.ok(subtest1.results.length === 1)
-                    this.ok(subtest1.results[0].name === 'one')
-                    this.ok(subtest1.results[0].results[0].success === true, subtest1.results[0].file)
-                })
+                        var subtest1 = test.results[2]
+                        this.ok(subtest1.name === "long before/after")
+                        this.ok(subtest1.exceptions.length === 0)
+                        this.ok(subtest1.results.length === 1)
+                        this.ok(subtest1.results[0].name === 'one')
+                        this.ok(subtest1.results[0].results[0].success === true, subtest1.results[0].file)
+                    })
 
-                this.test("Verify 'asynchronous errors'", function() {
-                    this.count(5)
+                    this.test("Verify 'asynchronous errors'", function() {
+                        this.count(5)
 
-                    var subtest1 = test.results[3]
-                    this.ok(subtest1.name === "asynchronous errors")
-                    this.ok(subtest1.exceptions.length === 2)
-                    this.ok(subtest1.results.length === 0)
+                        var subtest1 = test.results[3]
+                        this.ok(subtest1.name === "asynchronous errors")
+                        this.ok(subtest1.exceptions.length === 2)
+                        this.ok(subtest1.results.length === 0)
 
-                    this.ok(subtest1.exceptions[0].message === 'moo')
-                    this.ok(subtest1.exceptions[1] === 'thrown string')
-                })
+                        this.ok(subtest1.exceptions[0].message === 'moo')
+                        this.ok(subtest1.exceptions[1] === 'thrown string')
+                    })
 
-            }.bind(this)).done()
+                }.bind(this)).done()
 
+                }.bind(this)})
+
         })
@@ -495,24 +516,28 @@
 
-            }).results()
+            }).events({end: function() {
+                var results = test.results()
 
-            this.ok(test.exceptions.length === 0)
-            this.ok(test.results.length === 9)
-            this.ok(test.results[0].values.length === 1)
-            this.ok(test.results[0].values[0] === "string")
-            this.ok(test.results[1].values.length === 1)
-            this.ok(test.results[1].values[0] === object, test.results[1].values)
-            this.ok(test.results[2].values.length === 1)
-            this.ok(test.results[2].values[0] === array, test.results[2].values)
-            this.ok(test.results[3].values.length === 1)
-            this.ok(test.results[3].values[0] === error, test.results[3].values)
-            this.ok(test.results[4].values.length === 4)
-            this.ok(test.results[4].values[0] === "string", test.results[4].values[0])
-            this.ok(test.results[4].values[1] === object, test.results[4].values[1])
-            this.ok(test.results[4].values[2] === array, test.results[4].values[2])
-            this.ok(test.results[4].values[3] === error, test.results[4].values[3])
+                this.ok(results.exceptions.length === 0)
+                this.ok(results.results.length === 9)
+                this.ok(results.results[0].values.length === 1)
+                this.ok(results.results[0].values[0] === "string")
+                this.ok(results.results[1].values.length === 1)
+                this.ok(results.results[1].values[0] === object, results.results[1].values)
+                this.ok(results.results[2].values.length === 1)
+                this.ok(results.results[2].values[0] === array, results.results[2].values)
+                this.ok(results.results[3].values.length === 1)
+                this.ok(results.results[3].values[0] === error, results.results[3].values)
+                this.ok(results.results[4].values.length === 4)
+                this.ok(results.results[4].values[0] === "string", results.results[4].values[0])
+                this.ok(results.results[4].values[1] === object, results.results[4].values[1])
+                this.ok(results.results[4].values[2] === array, results.results[4].values[2])
+                this.ok(results.results[4].values[3] === error, results.results[4].values[3])
 
-            this.ok(test.results[5].actual === "string", test.results[5].actual)
-            this.ok(test.results[6].actual === object, test.results[6].actual)
-            this.ok(test.results[7].actual === array, test.results[7].actual)
-            this.ok(test.results[8].actual === error, test.results[8].actual)
+                this.ok(results.results[5].actual === "string", results.results[5].actual)
+                this.ok(results.results[6].actual === object, results.results[6].actual)
+                this.ok(results.results[7].actual === array, results.results[7].actual)
+                this.ok(results.results[8].actual === error, results.results[8].actual)
+            }.bind(this)})
+
+
         })
@@ -519,0 +544,0 @@

test/testDeadunit.node.js

@@ -13,3 +13,3 @@ "use strict";
     this.test('node-specific tests', function() {
-        this.count(2)
+        this.count(1)
 
@@ -21,2 +21,3 @@ // when using fibers/futures, sometimes incorrect causes a future to never be resolved,
             this.count(10)
+            this.timeout(300)
 
@@ -51,22 +52,25 @@ var Fiber = require('fibers')
                 }.bind(this),0)
-            })
+            }).events({end: function() {
+                Future.all([f,f2]).then(function() {
+                    var results = test.results()
 
-            Future.all([f,f2]).then(function() {
-                var results = test.results()
+                    t.ok(results.results.length === 2, results.results.length)
 
-                t.ok(results.results.length === 2, results.results.length)
+                    t.ok(results.results[0].exceptions.length === 0, require('util').inspect(results.results[0].exceptions))
+                    t.ok(results.results[0].results.length === 1)
+                    t.ok(results.results[0].results[0].success === true)
+                    t.ok(results.results[0].duration !== undefined, results.results[0].duration)
+                    t.ok(results.results[0].duration >= 0, results.results[0].duration)
 
-                t.ok(results.results[0].exceptions.length === 0, require('util').inspect(results.results[0].exceptions))
-                t.ok(results.results[0].results.length === 1)
-                t.ok(results.results[0].results[0].success === true)
-                t.ok(results.results[0].duration !== undefined, results.results[0].duration)
-                t.ok(results.results[0].duration >= 0, results.results[0].duration)
+                    t.ok(results.results[1].exceptions.length === 0, require('util').inspect(results.results[0].exceptions))
+                    t.ok(results.results[1].results.length === 0)
+                    t.ok(results.results[1].duration !== undefined, results.results[1].duration)
+                    t.ok(results.results[1].duration >= 0, results.results[1].duration)
+                }).done()
+            }})
 
-                t.ok(results.results[1].exceptions.length === 0, require('util').inspect(results.results[0].exceptions))
-                t.ok(results.results[1].results.length === 0)
-                t.ok(results.results[1].duration !== undefined, results.results[1].duration)
-                t.ok(results.results[1].duration >= 0, results.results[1].duration)
-            }).done()
+
         })
 
+        /* This test is no longer correct, but I don't know how to test it anymore since the original cause of the exception isn't reproducible now
         this.test('error hiding when internal exception is thrown', function(t) {
@@ -77,5 +81,6 @@ this.count(2)
 
-            Fiber(function() {
-                var test = Unit.test(function() {
-                    this.timeout(0)
+            var test = Unit.test(function(t) {
+                Fiber(function() {
+                    t.count(1) // to make it timeout
+                    t.timeout(0)
                     var f = new FibersFuture
@@ -86,15 +91,14 @@ setTimeout(function() {
                     f.wait()
-                    console.log('hi')
-                })
-
-                test.events({
-                    end: function() {
-                        console.log('oeviwew')
-                        var exceptions = test.results().exceptions
-                        t.ok(exceptions.length === 1, exceptions.length)
-                        t.ok(exceptions[0].message === "done called more than once (probably because the test timed out before it finished)", exceptions[0].message)
-                    }
-                })
-            }).run()
+                }).run()
+            }).events({
+                end: function() {
+                    var results = test.results()
+                    var exceptions = results.exceptions
+                    t.ok(results.timeout === true, results.timeout)
+                    t.ok(exceptions.length === 1, exceptions.length)
+                    t.ok(exceptions[0].message === "done called more than once (probably because the test timed out before it finished)", exceptions[0].message)
+                }
+            })
         })
+        */
     })
@@ -101,0 +105,0 @@

No alert changes

Improved metrics

Total package byte prevSize

101090

increased by2.58%

Lines of code

1980

increased by1.9%

Number of lines in readme file

321

increased by1.9%

No dependency changes