fsevents 1.0.0 → 1.0.1

package/node_modules/node-pre-gyp/node_modules/request/node_modules/hawk/node_modules/hoek/test/index.js

@@ -20,70 +20,70 @@ var it = lab.test;
 var expect = Code.expect;
 
 
-var nestedObj = {
+var nestedObj = {
     v: [7, 8, 9],
     w: /^something$/igm,
-    x: {
+    x: {
         a: [1, 2, 3],
         b: 123456,
         c: new Date(),
         d: /hi/igm,
-        e: /hello/
+        e: /hello/
     },
     y: 'y',
-    z: new Date(1378775452757)
+    z: new Date(1378775452757)
 };
 
 var dupsArray = [nestedObj, { z: 'z' }, nestedObj];
 var reducedDupsArray = [nestedObj, { z: 'z' }];
 
-describe('clone()', function () {
+describe('clone()', function () {
 
-    it('clones a nested object', function (done) {
+    it('clones a nested object', function (done) {
 
         var a = nestedObj;
         var b = Hoek.clone(a);
 
         expect(a).to.deep.equal(b);
         expect(a.z.getTime()).to.equal(b.z.getTime());
-        done();
+        done();
     });
 
-    it('clones a null object', function (done) {
+    it('clones a null object', function (done) {
 
         var b = Hoek.clone(null);
 
         expect(b).to.equal(null);
-        done();
+        done();
     });
 
-    it('should not convert undefined properties to null', function (done) {
+    it('should not convert undefined properties to null', function (done) {
 
         var obj = { something: undefined };
         var b = Hoek.clone(obj);
 
         expect(typeof b.something).to.equal('undefined');
-        done();
+        done();
     });
 
-    it('should not throw on circular reference', function (done) {
+    it('should not throw on circular reference', function (done) {
 
         var a = {};
         a.x = a;
 
-        var test = function () {
+        var test = function () {
 
-            var b = Hoek.clone(a);
+            var b = Hoek.clone(a);
         };
 
         expect(test).to.not.throw();
-        done();
+        done();
     });
 
-    it('clones circular reference', function (done) {
+    it('clones circular reference', function (done) {
 
-        var x = {
-            'z': new Date()
+        var x = {
+            'z': new Date()
         };
         x.y = x;
 
@@ -94,50 +94,50 @@ describe('clone()', function () {
         expect(b.y.z).to.not.equal(x.y.z);
         expect(b.y).to.equal(b);
         expect(b.y.y.y.y).to.equal(b);
-        done();
+        done();
     });
 
-    it('clones an object with a null prototype', function (done) {
+    it('clones an object with a null prototype', function (done) {
 
         var obj = Object.create(null);
         var b = Hoek.clone(obj);
 
         expect(b).to.deep.equal(obj);
-        done();
+        done();
     });
 
-    it('clones deeply nested object', function (done) {
+    it('clones deeply nested object', function (done) {
 
-        var a = {
-            x: {
-                y: {
+        var a = {
+            x: {
+                y: {
                     a: [1, 2, 3],
                     b: 123456,
                     c: new Date(),
                     d: /hi/igm,
-                    e: /hello/
-                }
-            }
+                    e: /hello/
+                }
+            }
         };
 
         var b = Hoek.clone(a);
 
         expect(a).to.deep.equal(b);
         expect(a.x.y.c.getTime()).to.equal(b.x.y.c.getTime());
-        done();
+        done();
     });
 
-    it('clones arrays', function (done) {
+    it('clones arrays', function (done) {
 
         var a = [1, 2, 3];
 
         var b = Hoek.clone(a);
 
         expect(a).to.deep.equal(b);
-        done();
+        done();
     });
 
-    it('performs actual copy for shallow keys (no pass by reference)', function (done) {
+    it('performs actual copy for shallow keys (no pass by reference)', function (done) {
 
         var x = Hoek.clone(nestedObj);
         var y = Hoek.clone(nestedObj);
@@ -159,10 +159,10 @@ describe('clone()', function () {
         expect(x.y).to.not.equal(nestedObj.y);
         expect(x.y).to.not.equal(y.y);
 
-        done();
+        done();
     });
 
-    it('performs actual copy for deep keys (no pass by reference)', function (done) {
+    it('performs actual copy for deep keys (no pass by reference)', function (done) {
 
         var x = Hoek.clone(nestedObj);
         var y = Hoek.clone(nestedObj);
@@ -172,22 +172,22 @@ describe('clone()', function () {
 
         expect(x.x.c.getTime()).to.equal(nestedObj.x.c.getTime());
         expect(x.x.c.getTime()).to.equal(y.x.c.getTime());
-        done();
+        done();
     });
 
-    it('copies functions with properties', function (done) {
+    it('copies functions with properties', function (done) {
+
+        var a = {
+            x: function () {
 
-        var a = {
-            x: function () {
-
-                return 1;
+                return 1;
             },
-            y: {}
+            y: {}
         };
         a.x.z = 'string in function';
-        a.x.v = function () {
-
-            return 2;
+        a.x.v = function () {
+
+            return 2;
         };
         a.y.u = a.x;
 
@@ -196,14 +196,14 @@ describe('clone()', function () {
         expect(b.x.v()).to.equal(2);
         expect(b.y.u).to.equal(b.x);
         expect(b.x.z).to.equal('string in function');
-        done();
+        done();
     });
 
     it('should copy a buffer', function (done) {
 
         var tls = {
             key: new Buffer([1, 2, 3, 4, 5]),
-            cert: new Buffer([1, 2, 3, 4, 5, 6, 10])
+            cert: new Buffer([1, 2, 3, 4, 5, 6, 10])
         };
 
         var copiedTls = Hoek.clone(tls);
@@ -211,14 +211,14 @@ describe('clone()', function () {
         expect(JSON.stringify(copiedTls.key)).to.equal(JSON.stringify(tls.key));
         expect(Buffer.isBuffer(copiedTls.cert)).to.equal(true);
         expect(JSON.stringify(copiedTls.cert)).to.equal(JSON.stringify(tls.cert));
-        done();
+        done();
     });
 
-    it('clones an object with a prototype', function (done) {
+    it('clones an object with a prototype', function (done) {
 
-        var Obj = function () {
+        var Obj = function () {
 
-            this.a = 5;
+            this.a = 5;
         };
 
         Obj.prototype.b = function () {
@@ -232,38 +232,38 @@ describe('clone()', function () {
         expect(b.a).to.equal(5);
         expect(b.b()).to.equal('c');
         expect(a).to.deep.equal(b);
-        done();
+        done();
     });
 
-    it('reuses cloned Date object', function (done) {
+    it('reuses cloned Date object', function (done) {
 
-        var obj = {
-            a: new Date()
+        var obj = {
+            a: new Date()
         };
 
         obj.b = obj.a;
 
         var copy = Hoek.clone(obj);
         expect(copy.a).to.equal(copy.b);
-        done();
+        done();
     });
 
-    it('shallow copies an object with a prototype and isImmutable flag', function (done) {
+    it('shallow copies an object with a prototype and isImmutable flag', function (done) {
 
-        var Obj = function () {
+        var Obj = function () {
 
-            this.value = 5;
+            this.value = 5;
         };
 
-        Obj.prototype.b = function () {
-
-            return 'c';
+        Obj.prototype.b = function () {
+
+            return 'c';
         };
 
         Obj.prototype.isImmutable = true;
 
-        var obj = {
-            a: new Obj()
+        var obj = {
+            a: new Obj()
         };
 
         var copy = Hoek.clone(obj);
@@ -272,117 +272,132 @@ describe('clone()', function () {
         expect(copy.a.value).to.equal(5);
         expect(copy.a.b()).to.equal('c');
         expect(obj.a).to.equal(copy.a);
-        done();
+        done();
     });
 
-    it('clones an object with property getter without executing it', function (done) {
+    it('clones an object with property getter without executing it', function (done) {
 
         var obj = {};
         var value = 1;
         var execCount = 0;
 
-        Object.defineProperty(obj, 'test', {
+        Object.defineProperty(obj, 'test', {
             enumerable: true,
             configurable: true,
-            get: function () {
+            get: function () {
 
                 ++execCount;
-                return value;
-            }
+                return value;
+            }
         });
 
         var copy = Hoek.clone(obj);
         expect(execCount).to.equal(0);
         expect(copy.test).to.equal(1);
         expect(execCount).to.equal(1);
-        done();
+        done();
     });
 
-    it('clones an object with property getter and setter', function (done) {
+    it('clones an object with property getter and setter', function (done) {
 
-        var obj = {
-            _test: 0
+        var obj = {
+            _test: 0
         };
 
-        Object.defineProperty(obj, 'test', {
+        Object.defineProperty(obj, 'test', {
             enumerable: true,
             configurable: true,
-            get: function () {
+            get: function () {
 
-                return this._test;
+                return this._test;
             },
-            set: function (value) {
+            set: function (value) {
 
-                this._test = value - 1;
-            }
+                this._test = value - 1;
+            }
         });
 
         var copy = Hoek.clone(obj);
         expect(copy.test).to.equal(0);
         copy.test = 5;
         expect(copy.test).to.equal(4);
-        done();
+        done();
     });
 
-    it('clones an object with only property setter', function (done) {
+    it('clones an object with only property setter', function (done) {
 
-        var obj = {
-            _test: 0
+        var obj = {
+            _test: 0
         };
 
-        Object.defineProperty(obj, 'test', {
+        Object.defineProperty(obj, 'test', {
             enumerable: true,
             configurable: true,
-            set: function (value) {
+            set: function (value) {
 
-                this._test = value - 1;
-            }
+                this._test = value - 1;
+            }
         });
 
         var copy = Hoek.clone(obj);
         expect(copy._test).to.equal(0);
         copy.test = 5;
         expect(copy._test).to.equal(4);
-        done();
+        done();
     });
 
-    it('clones an object with non-enumerable properties', function (done) {
+    it('clones an object with non-enumerable properties', function (done) {
 
-        var obj = {
-            _test: 0
+        var obj = {
+            _test: 0
         };
 
-        Object.defineProperty(obj, 'test', {
+        Object.defineProperty(obj, 'test', {
             enumerable: false,
             configurable: true,
-            set: function (value) {
+            set: function (value) {
 
-                this._test = value - 1;
-            }
+                this._test = value - 1;
+            }
         });
 
         var copy = Hoek.clone(obj);
         expect(copy._test).to.equal(0);
         copy.test = 5;
         expect(copy._test).to.equal(4);
-        done();
-    });
+        done();
+    });
+
+    it('clones an object where getOwnPropertyDescriptor returns undefined', function (done) {
+
+        var oldGetOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+        var obj = { a: 'b' };
+        Object.getOwnPropertyDescriptor = function () {
+
+            return undefined;
+        };
+
+        var copy = Hoek.clone(obj);
+        Object.getOwnPropertyDescriptor = oldGetOwnPropertyDescriptor;
+        expect(copy).to.deep.equal(obj);
+        done();
+    });
 });
 
-describe('merge()', function () {
+describe('merge()', function () {
 
-    it('deep copies source items', function (done) {
+    it('deep copies source items', function (done) {
 
-        var target = {
+        var target = {
             b: 3,
-            d: []
+            d: []
         };
 
-        var source = {
-            c: {
-                d: 1
+        var source = {
+            c: {
+                d: 1
             },
-            d: [{ e: 1 }]
+            d: [{ e: 1 }]
         };
 
         Hoek.merge(target, source);
@@ -391,123 +406,123 @@ describe('merge()', function () {
         expect(target.d).to.not.equal(source.d);
         expect(target.d[0]).to.not.equal(source.d[0]);
         expect(target.d).to.deep.equal(source.d);
-        done();
+        done();
     });
 
-    it('merges array over an object', function (done) {
+    it('merges array over an object', function (done) {
 
-        var a = {
-            x: ['n', 'm']
+        var a = {
+            x: ['n', 'm']
         };
 
-        var b = {
-            x: {
+        var b = {
+            x: {
                 n: '1',
-                m: '2'
-            }
+                m: '2'
+            }
         };
 
         Hoek.merge(b, a);
         expect(a.x[0]).to.equal('n');
         expect(a.x.n).to.not.exist();
-        done();
+        done();
     });
 
-    it('merges object over an array', function (done) {
+    it('merges object over an array', function (done) {
 
-        var a = {
-            x: ['n', 'm']
+        var a = {
+            x: ['n', 'm']
         };
 
-        var b = {
-            x: {
+        var b = {
+            x: {
                 n: '1',
-                m: '2'
-            }
+                m: '2'
+            }
         };
 
         Hoek.merge(a, b);
         expect(a.x.n).to.equal('1');
         expect(a.x[0]).to.not.exist();
-        done();
+        done();
     });
 
-    it('does not throw if source is null', function (done) {
+    it('does not throw if source is null', function (done) {
 
         var a = {};
         var b = null;
         var c = null;
 
-        expect(function () {
+        expect(function () {
 
-            c = Hoek.merge(a, b);
+            c = Hoek.merge(a, b);
         }).to.not.throw();
 
         expect(c).to.equal(a);
-        done();
+        done();
     });
 
-    it('does not throw if source is undefined', function (done) {
+    it('does not throw if source is undefined', function (done) {
 
         var a = {};
         var b;
         var c = null;
 
-        expect(function () {
+        expect(function () {
 
-            c = Hoek.merge(a, b);
+            c = Hoek.merge(a, b);
         }).to.not.throw();
 
         expect(c).to.equal(a);
-        done();
+        done();
     });
 
-    it('throws if source is not an object', function (done) {
+    it('throws if source is not an object', function (done) {
 
-        expect(function () {
+        expect(function () {
 
             var a = {};
             var b = 0;
 
-            Hoek.merge(a, b);
+            Hoek.merge(a, b);
         }).to.throw('Invalid source value: must be null, undefined, or an object');
-        done();
+        done();
     });
 
-    it('throws if target is not an object', function (done) {
+    it('throws if target is not an object', function (done) {
 
-        expect(function () {
+        expect(function () {
 
             var a = 0;
             var b = {};
 
-            Hoek.merge(a, b);
+            Hoek.merge(a, b);
         }).to.throw('Invalid target value: must be an object');
-        done();
+        done();
     });
 
-    it('throws if target is not an array and source is', function (done) {
+    it('throws if target is not an array and source is', function (done) {
 
-        expect(function () {
+        expect(function () {
 
             var a = {};
             var b = [1, 2];
 
-            Hoek.merge(a, b);
+            Hoek.merge(a, b);
         }).to.throw('Cannot merge array onto an object');
-        done();
+        done();
     });
 
-    it('returns the same object when merging arrays', function (done) {
+    it('returns the same object when merging arrays', function (done) {
 
         var a = [];
         var b = [1, 2];
 
         expect(Hoek.merge(a, b)).to.equal(a);
-        done();
+        done();
     });
 
-    it('combines an empty object with a non-empty object', function (done) {
+    it('combines an empty object with a non-empty object', function (done) {
 
         var a = {};
         var b = nestedObj;
@@ -515,10 +530,10 @@ describe('merge()', function () {
         var c = Hoek.merge(a, b);
         expect(a).to.deep.equal(b);
         expect(c).to.deep.equal(b);
-        done();
+        done();
     });
 
-    it('overrides values in target', function (done) {
+    it('overrides values in target', function (done) {
 
         var a = { x: 1, y: 2, z: 3, v: 5, t: 'test', m: 'abc' };
         var b = { x: null, z: 4, v: 0, t: { u: 6 }, m: '123' };
@@ -530,10 +545,10 @@ describe('merge()', function () {
         expect(c.v).to.equal(0);
         expect(c.m).to.equal('123');
         expect(c.t).to.deep.equal({ u: 6 });
-        done();
+        done();
     });
 
-    it('overrides values in target (flip)', function (done) {
+    it('overrides values in target (flip)', function (done) {
 
         var a = { x: 1, y: 2, z: 3, v: 5, t: 'test', m: 'abc' };
         var b = { x: null, z: 4, v: 0, t: { u: 6 }, m: '123' };
@@ -545,98 +560,98 @@ describe('merge()', function () {
         expect(d.v).to.equal(5);
         expect(d.m).to.equal('abc');
         expect(d.t).to.deep.equal('test');
-        done();
+        done();
     });
 
-    it('retains Date properties', function (done) {
+    it('retains Date properties', function (done) {
 
         var a = { x: new Date(1378776452757) };
 
         var b = Hoek.merge({}, a);
         expect(a.x.getTime()).to.equal(b.x.getTime());
-        done();
+        done();
     });
 
-    it('retains Date properties when merging keys', function (done) {
+    it('retains Date properties when merging keys', function (done) {
 
         var a = { x: new Date(1378776452757) };
 
         var b = Hoek.merge({ x: {} }, a);
         expect(a.x.getTime()).to.equal(b.x.getTime());
-        done();
+        done();
     });
 
-    it('overrides Buffer', function (done) {
+    it('overrides Buffer', function (done) {
 
         var a = { x: new Buffer('abc') };
 
         var b = Hoek.merge({ x: {} }, a);
         expect(a.x.toString()).to.equal('abc');
-        done();
-    });
+        done();
+    });
 });
 
-describe('applyToDefaults()', function () {
+describe('applyToDefaults()', function () {
 
-    var defaults = {
+    var defaults = {
         a: 1,
         b: 2,
-        c: {
+        c: {
             d: 3,
-            e: [5, 6]
+            e: [5, 6]
         },
         f: 6,
-        g: 'test'
+        g: 'test'
     };
 
-    it('throws when target is null', function (done) {
+    it('throws when target is null', function (done) {
 
-        expect(function () {
+        expect(function () {
 
-            Hoek.applyToDefaults(null, {});
+            Hoek.applyToDefaults(null, {});
         }).to.throw('Invalid defaults value: must be an object');
-        done();
+        done();
     });
 
-    it('returns null if options is false', function (done) {
+    it('returns null if options is false', function (done) {
 
         var result = Hoek.applyToDefaults(defaults, false);
         expect(result).to.equal(null);
-        done();
+        done();
     });
 
-    it('returns null if options is null', function (done) {
+    it('returns null if options is null', function (done) {
 
         var result = Hoek.applyToDefaults(defaults, null);
         expect(result).to.equal(null);
-        done();
+        done();
     });
 
-    it('returns null if options is undefined', function (done) {
+    it('returns null if options is undefined', function (done) {
 
         var result = Hoek.applyToDefaults(defaults, undefined);
         expect(result).to.equal(null);
-        done();
+        done();
     });
 
-    it('returns a copy of defaults if options is true', function (done) {
+    it('returns a copy of defaults if options is true', function (done) {
 
         var result = Hoek.applyToDefaults(defaults, true);
         expect(result).to.deep.equal(defaults);
-        done();
+        done();
     });
 
-    it('applies object to defaults', function (done) {
+    it('applies object to defaults', function (done) {
 
-        var obj = {
+        var obj = {
             a: null,
-            c: {
-                e: [4]
+            c: {
+                e: [4]
             },
             f: 0,
-            g: {
-                h: 5
-            }
+            g: {
+                h: 5
+            }
         };
 
         var result = Hoek.applyToDefaults(defaults, obj);
@@ -645,20 +660,20 @@ describe('applyToDefaults()', function () {
         expect(result.b).to.equal(2);
         expect(result.f).to.equal(0);
         expect(result.g).to.deep.equal({ h: 5 });
-        done();
+        done();
     });
 
-    it('applies object to defaults with null', function (done) {
+    it('applies object to defaults with null', function (done) {
 
-        var obj = {
+        var obj = {
             a: null,
-            c: {
-                e: [4]
+            c: {
+                e: [4]
             },
             f: 0,
-            g: {
-                h: 5
-            }
+            g: {
+                h: 5
+            }
         };
 
         var result = Hoek.applyToDefaults(defaults, obj, true);
@@ -667,21 +682,21 @@ describe('applyToDefaults()', function () {
         expect(result.b).to.equal(2);
         expect(result.f).to.equal(0);
         expect(result.g).to.deep.equal({ h: 5 });
-        done();
-    });
+        done();
+    });
 });
 
-describe('cloneWithShallow()', function () {
+describe('cloneWithShallow()', function () {
 
-    it('deep clones except for listed keys', function (done) {
+    it('deep clones except for listed keys', function (done) {
 
-        var source = {
-            a: {
-                b: 5
+        var source = {
+            a: {
+                b: 5
             },
-            c: {
-                d: 6
-            }
+            c: {
+                d: 6
+            }
         };
 
         var copy = Hoek.cloneWithShallow(source, ['c']);
@@ -689,36 +704,36 @@ describe('cloneWithShallow()', function () {
         expect(copy).to.not.equal(source);
         expect(copy.a).to.not.equal(source.a);
         expect(copy.b).to.equal(source.b);
-        done();
+        done();
     });
 
-    it('returns immutable value', function (done) {
+    it('returns immutable value', function (done) {
 
         expect(Hoek.cloneWithShallow(5)).to.equal(5);
-        done();
+        done();
     });
 
-    it('returns null value', function (done) {
+    it('returns null value', function (done) {
 
         expect(Hoek.cloneWithShallow(null)).to.equal(null);
-        done();
+        done();
     });
 
-    it('returns undefined value', function (done) {
+    it('returns undefined value', function (done) {
 
         expect(Hoek.cloneWithShallow(undefined)).to.equal(undefined);
-        done();
+        done();
     });
 
-    it('deep clones except for listed keys (including missing keys)', function (done) {
+    it('deep clones except for listed keys (including missing keys)', function (done) {
 
-        var source = {
-            a: {
-                b: 5
+        var source = {
+            a: {
+                b: 5
             },
-            c: {
-                d: 6
-            }
+            c: {
+                d: 6
+            }
         };
 
         var copy = Hoek.cloneWithShallow(source, ['c', 'v']);
@@ -726,33 +741,33 @@ describe('cloneWithShallow()', function () {
         expect(copy).to.not.equal(source);
         expect(copy.a).to.not.equal(source.a);
         expect(copy.b).to.equal(source.b);
-        done();
-    });
+        done();
+    });
 });
 
-describe('applyToDefaultsWithShallow()', function () {
+describe('applyToDefaultsWithShallow()', function () {
 
-    it('shallow copies the listed keys from options without merging', function (done) {
+    it('shallow copies the listed keys from options without merging', function (done) {
 
-        var defaults = {
-            a: {
+        var defaults = {
+            a: {
                 b: 5,
-                e: 3
+                e: 3
             },
-            c: {
+            c: {
                 d: 7,
-                g: 1
-            }
+                g: 1
+            }
         };
 
-        var options = {
-            a: {
-                b: 4
+        var options = {
+            a: {
+                b: 4
             },
-            c: {
+            c: {
                 d: 6,
-                f: 7
-            }
+                f: 7
+            }
         };
 
         var merged = Hoek.applyToDefaultsWithShallow(defaults, options, ['a']);
@@ -761,235 +776,235 @@ describe('applyToDefaultsWithShallow()', function () {
         expect(merged.a).to.not.equal(defaults.a);
         expect(merged.c).to.not.equal(options.c);
         expect(merged.c).to.not.equal(defaults.c);
-        done();
+        done();
     });
 
-    it('shallow copies the nested keys (override)', function (done) {
+    it('shallow copies the nested keys (override)', function (done) {
 
-        var defaults = {
-            a: {
-                b: 5
+        var defaults = {
+            a: {
+                b: 5
             },
-            c: {
+            c: {
                 d: 7,
-                g: 1
-            }
+                g: 1
+            }
         };
 
-        var options = {
-            a: {
-                b: 4
+        var options = {
+            a: {
+                b: 4
             },
-            c: {
+            c: {
                 d: 6,
-                g: {
-                    h: 8
-                }
-            }
+                g: {
+                    h: 8
+                }
+            }
         };
 
         var merged = Hoek.applyToDefaultsWithShallow(defaults, options, ['c.g']);
         expect(merged).to.deep.equal({ a: { b: 4 }, c: { d: 6, g: { h: 8 } } });
         expect(merged.c.g).to.equal(options.c.g);
-        done();
+        done();
     });
 
-    it('shallow copies the nested keys (missing)', function (done) {
+    it('shallow copies the nested keys (missing)', function (done) {
 
-        var defaults = {
-            a: {
-                b: 5
-            }
+        var defaults = {
+            a: {
+                b: 5
+            }
         };
 
-        var options = {
-            a: {
-                b: 4
+        var options = {
+            a: {
+                b: 4
             },
-            c: {
-                g: {
-                    h: 8
-                }
-            }
+            c: {
+                g: {
+                    h: 8
+                }
+            }
         };
 
         var merged = Hoek.applyToDefaultsWithShallow(defaults, options, ['c.g']);
         expect(merged).to.deep.equal({ a: { b: 4 }, c: { g: { h: 8 } } });
         expect(merged.c.g).to.equal(options.c.g);
-        done();
+        done();
     });
 
-    it('shallow copies the nested keys (override)', function (done) {
+    it('shallow copies the nested keys (override)', function (done) {
 
-        var defaults = {
-            a: {
-                b: 5
+        var defaults = {
+            a: {
+                b: 5
             },
-            c: {
-                g: {
-                    d: 7
-                }
-            }
+            c: {
+                g: {
+                    d: 7
+                }
+            }
         };
 
-        var options = {
-            a: {
-                b: 4
+        var options = {
+            a: {
+                b: 4
             },
-            c: {
-                g: {
-                    h: 8
-                }
-            }
+            c: {
+                g: {
+                    h: 8
+                }
+            }
         };
 
         var merged = Hoek.applyToDefaultsWithShallow(defaults, options, ['c.g']);
         expect(merged).to.deep.equal({ a: { b: 4 }, c: { g: { h: 8 } } });
         expect(merged.c.g).to.equal(options.c.g);
-        done();
+        done();
     });
 
-    it('shallow copies the nested keys (deeper)', function (done) {
+    it('shallow copies the nested keys (deeper)', function (done) {
 
-        var defaults = {
-            a: {
-                b: 5
-            }
+        var defaults = {
+            a: {
+                b: 5
+            }
         };
 
-        var options = {
-            a: {
-                b: 4
+        var options = {
+            a: {
+                b: 4
             },
-            c: {
-                g: {
-                    r: {
-                        h: 8
-                    }
-                }
-            }
+            c: {
+                g: {
+                    r: {
+                        h: 8
+                    }
+                }
+            }
         };
 
         var merged = Hoek.applyToDefaultsWithShallow(defaults, options, ['c.g.r']);
         expect(merged).to.deep.equal({ a: { b: 4 }, c: { g: { r: { h: 8 } } } });
         expect(merged.c.g.r).to.equal(options.c.g.r);
-        done();
+        done();
     });
 
-    it('shallow copies the nested keys (not present)', function (done) {
+    it('shallow copies the nested keys (not present)', function (done) {
 
-        var defaults = {
-            a: {
-                b: 5
-            }
+        var defaults = {
+            a: {
+                b: 5
+            }
         };
 
-        var options = {
-            a: {
-                b: 4
+        var options = {
+            a: {
+                b: 4
             },
-            c: {
-                g: {
-                    r: {
-                        h: 8
-                    }
-                }
-            }
+            c: {
+                g: {
+                    r: {
+                        h: 8
+                    }
+                }
+            }
         };
 
         var merged = Hoek.applyToDefaultsWithShallow(defaults, options, ['x.y']);
         expect(merged).to.deep.equal({ a: { b: 4 }, c: { g: { r: { h: 8 } } } });
-        done();
+        done();
     });
 
-    it('shallow copies the listed keys in the defaults', function (done) {
+    it('shallow copies the listed keys in the defaults', function (done) {
 
-        var defaults = {
-            a: {
-                b: 1
-            }
+        var defaults = {
+            a: {
+                b: 1
+            }
         };
 
         var merged = Hoek.applyToDefaultsWithShallow(defaults, {}, ['a']);
         expect(merged.a).to.equal(defaults.a);
-        done();
+        done();
     });
 
-    it('shallow copies the listed keys in the defaults (true)', function (done) {
+    it('shallow copies the listed keys in the defaults (true)', function (done) {
 
-        var defaults = {
-            a: {
-                b: 1
-            }
+        var defaults = {
+            a: {
+                b: 1
+            }
         };
 
         var merged = Hoek.applyToDefaultsWithShallow(defaults, true, ['a']);
         expect(merged.a).to.equal(defaults.a);
-        done();
+        done();
     });
 
-    it('returns null on false', function (done) {
+    it('returns null on false', function (done) {
 
-        var defaults = {
-            a: {
-                b: 1
-            }
+        var defaults = {
+            a: {
+                b: 1
+            }
         };
 
         var merged = Hoek.applyToDefaultsWithShallow(defaults, false, ['a']);
         expect(merged).to.equal(null);
-        done();
+        done();
     });
 
-    it('throws on missing defaults', function (done) {
+    it('throws on missing defaults', function (done) {
 
-        expect(function () {
+        expect(function () {
 
-            Hoek.applyToDefaultsWithShallow(null, {}, ['a']);
+            Hoek.applyToDefaultsWithShallow(null, {}, ['a']);
         }).to.throw('Invalid defaults value: must be an object');
-        done();
+        done();
     });
 
-    it('throws on invalid defaults', function (done) {
+    it('throws on invalid defaults', function (done) {
 
-        expect(function () {
+        expect(function () {
 
-            Hoek.applyToDefaultsWithShallow('abc', {}, ['a']);
+            Hoek.applyToDefaultsWithShallow('abc', {}, ['a']);
         }).to.throw('Invalid defaults value: must be an object');
-        done();
+        done();
     });
 
-    it('throws on invalid options', function (done) {
+    it('throws on invalid options', function (done) {
 
-        expect(function () {
+        expect(function () {
 
-            Hoek.applyToDefaultsWithShallow({}, 'abc', ['a']);
+            Hoek.applyToDefaultsWithShallow({}, 'abc', ['a']);
         }).to.throw('Invalid options value: must be true, falsy or an object');
-        done();
+        done();
     });
 
-    it('throws on missing keys', function (done) {
+    it('throws on missing keys', function (done) {
 
-        expect(function () {
+        expect(function () {
 
-            Hoek.applyToDefaultsWithShallow({}, true);
+            Hoek.applyToDefaultsWithShallow({}, true);
         }).to.throw('Invalid keys');
-        done();
+        done();
     });
 
-    it('throws on invalid keys', function (done) {
+    it('throws on invalid keys', function (done) {
 
-        expect(function () {
+        expect(function () {
 
-            Hoek.applyToDefaultsWithShallow({}, true, 'a');
+            Hoek.applyToDefaultsWithShallow({}, true, 'a');
         }).to.throw('Invalid keys');
-        done();
-    });
+        done();
+    });
 });
 
-describe('deepEqual()', function () {
+describe('deepEqual()', function () {
 
-    it('compares simple values', function (done) {
+    it('compares simple values', function (done) {
 
         expect(Hoek.deepEqual('x', 'x')).to.be.true();
         expect(Hoek.deepEqual('x', 'y')).to.be.false();
@@ -1003,10 +1018,10 @@ describe('deepEqual()', function () {
         expect(Hoek.deepEqual(-1, 1)).to.be.false();
         expect(Hoek.deepEqual(NaN, 0)).to.be.false();
         expect(Hoek.deepEqual(NaN, NaN)).to.be.true();
-        done();
+        done();
     });
 
-    it('compares different types', function (done) {
+    it('compares different types', function (done) {
 
         expect(Hoek.deepEqual([], 5)).to.be.false();
         expect(Hoek.deepEqual(5, [])).to.be.false();
@@ -1014,116 +1029,116 @@ describe('deepEqual()', function () {
         expect(Hoek.deepEqual(null, {})).to.be.false();
         expect(Hoek.deepEqual('abc', {})).to.be.false();
         expect(Hoek.deepEqual({}, 'abc')).to.be.false();
-        done();
+        done();
     });
 
-    it('compares empty structures', function (done) {
+    it('compares empty structures', function (done) {
 
         expect(Hoek.deepEqual([], [])).to.be.true();
         expect(Hoek.deepEqual({}, {})).to.be.true();
         expect(Hoek.deepEqual([], {})).to.be.false();
-        done();
+        done();
     });
 
-    it('compares empty arguments object', function (done) {
+    it('compares empty arguments object', function (done) {
 
-        var compare = function () {
+        var compare = function () {
 
-            expect(Hoek.deepEqual([], arguments)).to.be.false();
+            expect(Hoek.deepEqual([], arguments)).to.be.false();
         };
 
         compare();
-        done();
+        done();
     });
 
-    it('compares empty arguments objects', function (done) {
+    it('compares empty arguments objects', function (done) {
 
-        var compare = function () {
+        var compare = function () {
 
             var arg1 = arguments;
 
-            var inner = function () {
+            var inner = function () {
 
                 expect(Hoek.deepEqual(arg1, arguments)).to.be.false(); // callee is not the same
             };
 
-            inner();
+            inner();
         };
 
         compare();
-        done();
+        done();
     });
 
-    it('compares dates', function (done) {
+    it('compares dates', function (done) {
 
         expect(Hoek.deepEqual(new Date(2015, 1, 1), new Date(2015, 1, 1))).to.be.true();
         expect(Hoek.deepEqual(new Date(100), new Date(101))).to.be.false();
         expect(Hoek.deepEqual(new Date(), {})).to.be.false();
-        done();
+        done();
     });
 
-    it('compares regular expressions', function (done) {
+    it('compares regular expressions', function (done) {
 
         expect(Hoek.deepEqual(/\s/, new RegExp('\\\s'))).to.be.true();
         expect(Hoek.deepEqual(/\s/g, /\s/g)).to.be.true();
         expect(Hoek.deepEqual(/a/, {})).to.be.false();
         expect(Hoek.deepEqual(/\s/g, /\s/i)).to.be.false();
         expect(Hoek.deepEqual(/a/g, /b/g)).to.be.false();
-        done();
+        done();
     });
 
-    it('compares arrays', function (done) {
+    it('compares arrays', function (done) {
 
         expect(Hoek.deepEqual([[1]], [[1]])).to.be.true();
         expect(Hoek.deepEqual([1, 2, 3], [1, 2, 3])).to.be.true();
         expect(Hoek.deepEqual([1, 2, 3], [1, 3, 2])).to.be.false();
         expect(Hoek.deepEqual([1, 2, 3], [1, 2])).to.be.false();
         expect(Hoek.deepEqual([1], [1])).to.be.true();
-        done();
+        done();
     });
 
-    it('compares buffers', function (done) {
+    it('compares buffers', function (done) {
 
         expect(Hoek.deepEqual(new Buffer([1, 2, 3]), new Buffer([1, 2, 3]))).to.be.true();
         expect(Hoek.deepEqual(new Buffer([1, 2, 3]), new Buffer([1, 3, 2]))).to.be.false();
         expect(Hoek.deepEqual(new Buffer([1, 2, 3]), new Buffer([1, 2]))).to.be.false();
         expect(Hoek.deepEqual(new Buffer([1, 2, 3]), {})).to.be.false();
         expect(Hoek.deepEqual(new Buffer([1, 2, 3]), [1, 2, 3])).to.be.false();
-        done();
+        done();
     });
 
-    it('compares objects', function (done) {
+    it('compares objects', function (done) {
 
         expect(Hoek.deepEqual({ a: 1, b: 2, c: 3 }, { a: 1, b: 2, c: 3 })).to.be.true();
         expect(Hoek.deepEqual({ foo: 'bar' }, { foo: 'baz' })).to.be.false();
         expect(Hoek.deepEqual({ foo: { bar: 'foo' } }, { foo: { bar: 'baz' } })).to.be.false();
-        done();
+        done();
     });
 
-    it('handles circular dependency', function (done) {
+    it('handles circular dependency', function (done) {
 
         var a = {};
         a.x = a;
 
         var b = Hoek.clone(a);
         expect(Hoek.deepEqual(a, b)).to.be.true();
-        done();
+        done();
     });
 
-    it('compares an object with property getter without executing it', function (done) {
+    it('compares an object with property getter without executing it', function (done) {
 
         var obj = {};
         var value = 1;
         var execCount = 0;
 
-        Object.defineProperty(obj, 'test', {
+        Object.defineProperty(obj, 'test', {
             enumerable: true,
             configurable: true,
-            get: function () {
+            get: function () {
 
                 ++execCount;
-                return value;
-            }
+                return value;
+            }
         });
 
         var copy = Hoek.clone(obj);
@@ -1131,13 +1146,13 @@ describe('deepEqual()', function () {
         expect(execCount).to.equal(0);
         expect(copy.test).to.equal(1);
         expect(execCount).to.equal(1);
-        done();
+        done();
     });
 
-    it('compares objects with property getters', function (done) {
+    it('compares objects with property getters', function (done) {
 
         var obj = {};
-        Object.defineProperty(obj, 'test', {
+        Object.defineProperty(obj, 'test', {
             enumerable: true,
             configurable: true,
             get: function () {
@@ -1147,7 +1162,7 @@ describe('deepEqual()', function () {
         });
 
         var ref = {};
-        Object.defineProperty(ref, 'test', {
+        Object.defineProperty(ref, 'test', {
             enumerable: true,
             configurable: true,
             get: function () {
@@ -1157,14 +1172,14 @@ describe('deepEqual()', function () {
         });
 
         expect(Hoek.deepEqual(obj, ref)).to.be.false();
-        done();
+        done();
     });
 
-    it('compares object prototypes', function (done) {
+    it('compares object prototypes', function (done) {
 
-        var Obj = function () {
+        var Obj = function () {
 
-            this.a = 5;
+            this.a = 5;
         };
 
         Obj.prototype.b = function () {
@@ -1172,9 +1187,9 @@ describe('deepEqual()', function () {
             return this.a;
         };
 
-        var Ref = function () {
+        var Ref = function () {
 
-            this.a = 5;
+            this.a = 5;
         };
 
         Ref.prototype.b = function () {
@@ -1185,10 +1200,10 @@ describe('deepEqual()', function () {
         expect(Hoek.deepEqual(new Obj(), new Ref())).to.be.false();
         expect(Hoek.deepEqual(new Obj(), new Obj())).to.be.true();
         expect(Hoek.deepEqual(new Ref(), new Ref())).to.be.true();
-        done();
+        done();
     });
 
-    it('compares plain objects', function (done) {
+    it('compares plain objects', function (done) {
 
         var a = Object.create(null);
         var b = Object.create(null);
@@ -1198,131 +1213,131 @@ describe('deepEqual()', function () {
 
         expect(Hoek.deepEqual(a, b)).to.be.true();
         expect(Hoek.deepEqual(a, { b: 'c' })).to.be.false();
-        done();
+        done();
     });
 
-    it('compares an object with an empty object', function (done) {
+    it('compares an object with an empty object', function (done) {
 
         var a = { a: 1, b: 2 };
 
         expect(Hoek.deepEqual({}, a)).to.be.false();
         expect(Hoek.deepEqual(a, {})).to.be.false();
-        done();
+        done();
     });
 
-    it('compares an object ignoring the prototype', function (done) {
+    it('compares an object ignoring the prototype', function (done) {
 
         var a = Object.create(null);
         var b = {};
 
         expect(Hoek.deepEqual(a, b, { prototype: false })).to.be.true();
-        done();
+        done();
     });
 
-    it('compares an object ignoring the prototype recursively', function (done) {
+    it('compares an object ignoring the prototype recursively', function (done) {
 
         var a = [Object.create(null)];
         var b = [{}];
 
         expect(Hoek.deepEqual(a, b, { prototype: false })).to.be.true();
-        done();
-    });
+        done();
+    });
 });
 
-describe('unique()', function () {
+describe('unique()', function () {
 
-    it('ensures uniqueness within array of objects based on subkey', function (done) {
+    it('ensures uniqueness within array of objects based on subkey', function (done) {
 
         var a = Hoek.unique(dupsArray, 'x');
         expect(a).to.deep.equal(reducedDupsArray);
-        done();
+        done();
     });
 
-    it('removes duplicated without key', function (done) {
+    it('removes duplicated without key', function (done) {
 
         expect(Hoek.unique([1, 2, 3, 4, 2, 1, 5])).to.deep.equal([1, 2, 3, 4, 5]);
-        done();
-    });
+        done();
+    });
 });
 
-describe('mapToObject()', function () {
+describe('mapToObject()', function () {
 
-    it('returns null on null array', function (done) {
+    it('returns null on null array', function (done) {
 
         var a = Hoek.mapToObject(null);
         expect(a).to.equal(null);
-        done();
+        done();
     });
 
-    it('converts basic array to existential object', function (done) {
+    it('converts basic array to existential object', function (done) {
 
         var keys = [1, 2, 3, 4];
         var a = Hoek.mapToObject(keys);
-        for (var i in keys) {
-            expect(a[keys[i]]).to.equal(true);
+        for (var i in keys) {
+            expect(a[keys[i]]).to.equal(true);
         }
-        done();
+        done();
     });
 
-    it('converts array of objects to existential object', function (done) {
+    it('converts array of objects to existential object', function (done) {
 
         var keys = [{ x: 1 }, { x: 2 }, { x: 3 }, { y: 4 }];
         var subkey = 'x';
         var a = Hoek.mapToObject(keys, subkey);
         expect(a).to.deep.equal({ 1: true, 2: true, 3: true });
-        done();
-    });
+        done();
+    });
 });
 
-describe('intersect()', function () {
+describe('intersect()', function () {
 
-    it('returns the common objects of two arrays', function (done) {
+    it('returns the common objects of two arrays', function (done) {
 
         var array1 = [1, 2, 3, 4, 4, 5, 5];
         var array2 = [5, 4, 5, 6, 7];
         var common = Hoek.intersect(array1, array2);
         expect(common.length).to.equal(2);
-        done();
+        done();
     });
 
-    it('returns just the first common object of two arrays', function (done) {
+    it('returns just the first common object of two arrays', function (done) {
 
         var array1 = [1, 2, 3, 4, 4, 5, 5];
         var array2 = [5, 4, 5, 6, 7];
         var common = Hoek.intersect(array1, array2, true);
         expect(common).to.equal(5);
-        done();
+        done();
     });
 
-    it('returns null when no common and returning just the first common object of two arrays', function (done) {
+    it('returns null when no common and returning just the first common object of two arrays', function (done) {
 
         var array1 = [1, 2, 3, 4, 4, 5, 5];
         var array2 = [6, 7];
         var common = Hoek.intersect(array1, array2, true);
         expect(common).to.equal(null);
-        done();
+        done();
     });
 
-    it('returns an empty array if either input is null', function (done) {
+    it('returns an empty array if either input is null', function (done) {
 
         expect(Hoek.intersect([1], null).length).to.equal(0);
         expect(Hoek.intersect(null, [1]).length).to.equal(0);
-        done();
+        done();
     });
 
-    it('returns the common objects of object and array', function (done) {
+    it('returns the common objects of object and array', function (done) {
 
         var array1 = [1, 2, 3, 4, 4, 5, 5];
         var array2 = [5, 4, 5, 6, 7];
         var common = Hoek.intersect(Hoek.mapToObject(array1), array2);
         expect(common.length).to.equal(2);
-        done();
-    });
+        done();
+    });
 });
 
-describe('contain()', function () {
+describe('contain()', function () {
 
-    it('tests strings', function (done) {
+    it('tests strings', function (done) {
 
         expect(Hoek.contain('abc', 'ab')).to.be.true();
         expect(Hoek.contain('abc', 'abc', { only: true })).to.be.true();
@@ -1337,10 +1352,10 @@ describe('contain()', function () {
         expect(Hoek.contain('abb', 'b', { once: true })).to.be.false();
         expect(Hoek.contain('abc', ['a', 'd'])).to.be.false();
         expect(Hoek.contain('abc', ['ab', 'bc'])).to.be.false();                      // Overlapping values not supported
-        done();
+        done();
     });
 
-    it('tests arrays', function (done) {
+    it('tests arrays', function (done) {
 
         expect(Hoek.contain([1, 2, 3], 1)).to.be.true();
         expect(Hoek.contain([{ a: 1 }], { a: 1 }, { deep: true })).to.be.true();
@@ -1361,10 +1376,10 @@ describe('contain()', function () {
         expect(Hoek.contain([1, 3, 2], [1, 2], { only: true })).to.be.false();
         expect(Hoek.contain([1, 2, 2], [1, 2], { once: true })).to.be.false();
         expect(Hoek.contain([0, 2, 3], [1, 4], { part: true })).to.be.false();
-        done();
+        done();
     });
 
-    it('tests objects', function (done) {
+    it('tests objects', function (done) {
 
         expect(Hoek.contain({ a: 1, b: 2, c: 3 }, 'a')).to.be.true();
         expect(Hoek.contain({ a: 1, b: 2, c: 3 }, ['a', 'c'])).to.be.true();
@@ -1399,10 +1414,10 @@ describe('contain()', function () {
         // Getter check
         var Foo = function (bar) {
 
-            this.bar = bar;
+            this.bar = bar;
         };
 
-        Object.defineProperty(Foo.prototype, 'baz', {
+        Object.defineProperty(Foo.prototype, 'baz', {
             enumerable: true,
             get: function () {
 
@@ -1417,230 +1432,238 @@ describe('contain()', function () {
         expect(Hoek.contain({ a: new Foo('b') }, { a: { baz: 'b' } }, { deep: true, part: false })).to.be.false();
         expect(Hoek.contain({ a: new Foo('b') }, { a: { baz: 'b' } }, { deep: true, part: true })).to.be.true();
 
-        done();
-    });
+        done();
+    });
 });
 
-describe('flatten()', function () {
+describe('flatten()', function () {
 
-    it('returns a flat array', function (done) {
+    it('returns a flat array', function (done) {
 
         var result = Hoek.flatten([1, 2, [3, 4, [5, 6], [7], 8], [9], [10, [11, 12]], 13]);
         expect(result.length).to.equal(13);
         expect(result).to.deep.equal([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]);
-        done();
-    });
+        done();
+    });
 });
 
-describe('reach()', function () {
+describe('reach()', function () {
 
-    var obj = {
-        a: {
-            b: {
-                c: {
+    var obj = {
+        a: {
+            b: {
+                c: {
                     d: 1,
-                    e: 2
+                    e: 2
                 },
-                f: 'hello'
+                f: 'hello'
             },
-            g: {
-                h: 3
-            }
+            g: {
+                h: 3
+            }
         },
         i: function () { },
         j: null,
-        k: [4, 8, 9, 1]
+        k: [4, 8, 9, 1]
     };
 
     obj.i.x = 5;
 
-    it('returns first value of array', function (done) {
+    it('returns object itself', function (done) {
+
+        expect(Hoek.reach(obj, null)).to.equal(obj);
+        expect(Hoek.reach(obj, false)).to.equal(obj);
+        expect(Hoek.reach(obj)).to.equal(obj);
+        done();
+    });
+
+    it('returns first value of array', function (done) {
 
         expect(Hoek.reach(obj, 'k.0')).to.equal(4);
-        done();
+        done();
     });
 
-    it('returns last value of array using negative index', function (done) {
+    it('returns last value of array using negative index', function (done) {
 
         expect(Hoek.reach(obj, 'k.-2')).to.equal(9);
-        done();
+        done();
     });
 
-    it('returns a valid member', function (done) {
+    it('returns a valid member', function (done) {
 
         expect(Hoek.reach(obj, 'a.b.c.d')).to.equal(1);
-        done();
+        done();
     });
 
-    it('returns a valid member with separator override', function (done) {
+    it('returns a valid member with separator override', function (done) {
 
         expect(Hoek.reach(obj, 'a/b/c/d', '/')).to.equal(1);
-        done();
+        done();
     });
 
-    it('returns undefined on null object', function (done) {
+    it('returns undefined on null object', function (done) {
 
         expect(Hoek.reach(null, 'a.b.c.d')).to.equal(undefined);
-        done();
+        done();
     });
 
-    it('returns undefined on missing object member', function (done) {
+    it('returns undefined on missing object member', function (done) {
 
         expect(Hoek.reach(obj, 'a.b.c.d.x')).to.equal(undefined);
-        done();
+        done();
     });
 
-    it('returns undefined on missing function member', function (done) {
+    it('returns undefined on missing function member', function (done) {
 
         expect(Hoek.reach(obj, 'i.y', { functions: true })).to.equal(undefined);
-        done();
+        done();
     });
 
-    it('throws on missing member in strict mode', function (done) {
+    it('throws on missing member in strict mode', function (done) {
 
-        expect(function () {
+        expect(function () {
 
-            Hoek.reach(obj, 'a.b.c.o.x', { strict: true });
+            Hoek.reach(obj, 'a.b.c.o.x', { strict: true });
         }).to.throw('Missing segment o in reach path  a.b.c.o.x');
 
-        done();
+        done();
     });
 
-    it('returns undefined on invalid member', function (done) {
+    it('returns undefined on invalid member', function (done) {
 
         expect(Hoek.reach(obj, 'a.b.c.d-.x')).to.equal(undefined);
-        done();
+        done();
     });
 
-    it('returns function member', function (done) {
+    it('returns function member', function (done) {
 
         expect(typeof Hoek.reach(obj, 'i')).to.equal('function');
-        done();
+        done();
     });
 
-    it('returns function property', function (done) {
+    it('returns function property', function (done) {
 
         expect(Hoek.reach(obj, 'i.x')).to.equal(5);
-        done();
+        done();
     });
 
-    it('returns null', function (done) {
+    it('returns null', function (done) {
 
         expect(Hoek.reach(obj, 'j')).to.equal(null);
-        done();
+        done();
     });
 
-    it('throws on function property when functions not allowed', function (done) {
+    it('throws on function property when functions not allowed', function (done) {
 
-        expect(function () {
+        expect(function () {
 
-            Hoek.reach(obj, 'i.x', { functions: false });
+            Hoek.reach(obj, 'i.x', { functions: false });
         }).to.throw('Invalid segment x in reach path  i.x');
 
-        done();
+        done();
     });
 
-    it('will return a default value if property is not found', function (done) {
+    it('will return a default value if property is not found', function (done) {
 
         expect(Hoek.reach(obj, 'a.b.q', { default: 'defaultValue' })).to.equal('defaultValue');
-        done();
+        done();
     });
 
-    it('will return a default value if path is not found', function (done) {
+    it('will return a default value if path is not found', function (done) {
 
         expect(Hoek.reach(obj, 'q', { default: 'defaultValue' })).to.equal('defaultValue');
-        done();
+        done();
     });
 
-    it('allows a falsey value to be used as the default value', function (done) {
+    it('allows a falsey value to be used as the default value', function (done) {
 
         expect(Hoek.reach(obj, 'q', { default: '' })).to.equal('');
-        done();
-    });
+        done();
+    });
 });
 
-describe('reachTemplate()', function () {
+describe('reachTemplate()', function () {
 
-    it('applies object to template', function (done) {
+    it('applies object to template', function (done) {
 
-        var obj = {
-            a: {
-                b: {
-                    c: {
-                        d: 1
-                    }
-                }
+        var obj = {
+            a: {
+                b: {
+                    c: {
+                        d: 1
+                    }
+                }
             },
             j: null,
-            k: [4, 8, 9, 1]
+            k: [4, 8, 9, 1]
         };
 
         var template = '{k.0}:{k.-2}:{a.b.c.d}:{x.y}:{j}';
 
         expect(Hoek.reachTemplate(obj, template)).to.equal('4:9:1::');
-        done();
-    });
-
-    it('applies object to template (options)', function (done) {
-
-        var obj = {
-            a: {
-                b: {
-                    c: {
-                        d: 1
-                    }
-                }
+        done();
+    });
+
+    it('applies object to template (options)', function (done) {
+
+        var obj = {
+            a: {
+                b: {
+                    c: {
+                        d: 1
+                    }
+                }
             },
             j: null,
-            k: [4, 8, 9, 1]
+            k: [4, 8, 9, 1]
         };
 
         var template = '{k/0}:{k/-2}:{a/b/c/d}:{x/y}:{j}';
 
         expect(Hoek.reachTemplate(obj, template, '/')).to.equal('4:9:1::');
-        done();
-    });
+        done();
+    });
 });
 
-describe('callStack()', function () {
+describe('callStack()', function () {
 
-    it('returns the full call stack', function (done) {
+    it('returns the full call stack', function (done) {
 
         var stack = Hoek.callStack();
         expect(stack[0][0]).to.contain('index.js');
         expect(stack[0][2]).to.equal(26);
-        done();
-    });
+        done();
+    });
 });
 
-describe('displayStack ()', function () {
+describe('displayStack ()', function () {
 
-    it('returns the full call stack for display', function (done) {
+    it('returns the full call stack for display', function (done) {
 
         var stack = Hoek.displayStack();
         expect(stack[0]).to.contain(Path.normalize('/test/index.js') + ':');
-        done();
+        done();
     });
 
-    it('includes constructor functions correctly', function (done) {
+    it('includes constructor functions correctly', function (done) {
 
-        var Something = function (next) {
+        var Something = function (next) {
 
-            next();
+            next();
         };
 
-        var something = new Something(function () {
+        var something = new Something(function () {
 
             var stack = Hoek.displayStack();
             expect(stack[1]).to.contain('new Something');
-            done();
-        });
-    });
+            done();
+        });
+    });
 });
 
-describe('abort()', function () {
+describe('abort()', function () {
 
-    it('exits process when not in test mode', function (done) {
+    it('exits process when not in test mode', function (done) {
 
         var env = process.env.NODE_ENV;
         var write = process.stdout.write;
@@ -1648,38 +1671,38 @@ describe('abort()', function () {
 
         process.env.NODE_ENV = 'nottatest';
         process.stdout.write = function () { };
-        process.exit = function (state) {
+        process.exit = function (state) {
 
             process.exit = exit;
             process.env.NODE_ENV = env;
             process.stdout.write = write;
 
             expect(state).to.equal(1);
-            done();
+            done();
         };
 
-        Hoek.abort('Boom');
+        Hoek.abort('Boom');
     });
 
-    it('throws when not in test mode and abortThrow is true', function (done) {
+    it('throws when not in test mode and abortThrow is true', function (done) {
 
         var env = process.env.NODE_ENV;
         process.env.NODE_ENV = 'nottatest';
         Hoek.abortThrow = true;
 
-        var fn = function () {
+        var fn = function () {
 
-            Hoek.abort('my error message');
+            Hoek.abort('my error message');
         };
 
         expect(fn).to.throw('my error message');
         Hoek.abortThrow = false;
         process.env.NODE_ENV = env;
 
-        done();
+        done();
     });
 
-    it('respects hideStack argument', function (done) {
+    it('respects hideStack argument', function (done) {
 
         var env = process.env.NODE_ENV;
         var write = process.stdout.write;
@@ -1688,9 +1711,9 @@ describe('abort()', function () {
 
         process.exit = function () { };
         process.env.NODE_ENV = '';
-        process.stdout.write = function (message) {
+        process.stdout.write = function (message) {
 
-            output = message;
+            output = message;
         };
 
         Hoek.abort('my error message', true);
@@ -1701,38 +1724,38 @@ describe('abort()', function () {
 
         expect(output).to.equal('ABORT: my error message\n\t\n');
 
-        done();
+        done();
     });
 
-    it('throws in test mode', function (done) {
+    it('throws in test mode', function (done) {
 
         var env = process.env.NODE_ENV;
         process.env.NODE_ENV = 'test';
 
-        expect(function () {
+        expect(function () {
 
-            Hoek.abort('my error message', true);
+            Hoek.abort('my error message', true);
         }).to.throw('my error message');
 
         process.env.NODE_ENV = env;
-        done();
+        done();
     });
 
-    it('throws in test mode with default message', function (done) {
+    it('throws in test mode with default message', function (done) {
 
         var env = process.env.NODE_ENV;
         process.env.NODE_ENV = 'test';
 
-        expect(function () {
+        expect(function () {
 
-            Hoek.abort('', true);
+            Hoek.abort('', true);
         }).to.throw('Unknown error');
 
         process.env.NODE_ENV = env;
-        done();
+        done();
     });
 
-    it('defaults to showing stack', function (done) {
+    it('defaults to showing stack', function (done) {
 
         var env = process.env.NODE_ENV;
         var write = process.stdout.write;
@@ -1741,9 +1764,9 @@ describe('abort()', function () {
 
         process.exit = function () { };
         process.env.NODE_ENV = '';
-        process.stdout.write = function (message) {
+        process.stdout.write = function (message) {
 
-            output = message;
+            output = message;
         };
 
         Hoek.abort('my error message');
@@ -1754,173 +1777,173 @@ describe('abort()', function () {
 
         expect(output).to.contain('index.js');
 
-        done();
-    });
+        done();
+    });
 });
 
-describe('assert()', function () {
+describe('assert()', function () {
 
-    it('throws an Error when using assert in a test', function (done) {
+    it('throws an Error when using assert in a test', function (done) {
 
-        var fn = function () {
+        var fn = function () {
 
-            Hoek.assert(false, 'my error message');
+            Hoek.assert(false, 'my error message');
         };
 
         expect(fn).to.throw('my error message');
-        done();
+        done();
     });
 
-    it('throws an Error when using assert in a test with no message', function (done) {
+    it('throws an Error when using assert in a test with no message', function (done) {
 
-        var fn = function () {
+        var fn = function () {
 
-            Hoek.assert(false);
+            Hoek.assert(false);
         };
 
         expect(fn).to.throw('Unknown error');
-        done();
+        done();
     });
 
-    it('throws an Error when using assert in a test with multipart message', function (done) {
+    it('throws an Error when using assert in a test with multipart message', function (done) {
 
-        var fn = function () {
+        var fn = function () {
 
-            Hoek.assert(false, 'This', 'is', 'my message');
+            Hoek.assert(false, 'This', 'is', 'my message');
         };
 
         expect(fn).to.throw('This is my message');
-        done();
+        done();
     });
 
-    it('throws an Error when using assert in a test with multipart message (empty)', function (done) {
+    it('throws an Error when using assert in a test with multipart message (empty)', function (done) {
 
-        var fn = function () {
+        var fn = function () {
 
-            Hoek.assert(false, 'This', 'is', '', 'my message');
+            Hoek.assert(false, 'This', 'is', '', 'my message');
         };
 
         expect(fn).to.throw('This is my message');
-        done();
+        done();
     });
 
-    it('throws an Error when using assert in a test with object message', function (done) {
+    it('throws an Error when using assert in a test with object message', function (done) {
 
-        var fn = function () {
+        var fn = function () {
 
-            Hoek.assert(false, 'This', 'is', { spinal: 'tap' });
+            Hoek.assert(false, 'This', 'is', { spinal: 'tap' });
         };
 
         expect(fn).to.throw('This is {"spinal":"tap"}');
-        done();
+        done();
     });
 
-    it('throws an Error when using assert in a test with multipart string and error messages', function (done) {
+    it('throws an Error when using assert in a test with multipart string and error messages', function (done) {
 
-        var fn = function () {
+        var fn = function () {
 
-            Hoek.assert(false, 'This', 'is', new Error('spinal'), new Error('tap'));
+            Hoek.assert(false, 'This', 'is', new Error('spinal'), new Error('tap'));
         };
 
         expect(fn).to.throw('This is spinal tap');
-        done();
+        done();
     });
 
-    it('throws an Error when using assert in a test with error object message', function (done) {
+    it('throws an Error when using assert in a test with error object message', function (done) {
 
-        var fn = function () {
+        var fn = function () {
 
-            Hoek.assert(false, new Error('This is spinal tap'));
+            Hoek.assert(false, new Error('This is spinal tap'));
         };
 
         expect(fn).to.throw('This is spinal tap');
-        done();
+        done();
     });
 
-    it('throws the same Error that is passed to it if there is only one error passed', function (done) {
+    it('throws the same Error that is passed to it if there is only one error passed', function (done) {
 
         var error = new Error('ruh roh');
         var error2 = new Error('ruh roh');
 
-        var fn = function () {
+        var fn = function () {
 
-            Hoek.assert(false, error);
+            Hoek.assert(false, error);
         };
 
-        try {
-            fn();
-        } catch (err) {
+        try {
+            fn();
+        } catch (err) {
             expect(error).to.equal(error);  // should be the same reference
             expect(error).to.not.equal(error2); // error with the same message should not match
         }
 
-        done();
-    });
+        done();
+    });
 });
 
-describe('Timer', function () {
+describe('Timer', function () {
 
-    it('returns time elapsed', function (done) {
+    it('returns time elapsed', function (done) {
 
         var timer = new Hoek.Timer();
-        setTimeout(function () {
+        setTimeout(function () {
 
             expect(timer.elapsed()).to.be.above(9);
-            done();
-        }, 12);
-    });
+            done();
+        }, 12);
+    });
 });
 
-describe('Bench', function () {
+describe('Bench', function () {
 
-    it('returns time elapsed', function (done) {
+    it('returns time elapsed', function (done) {
 
         var timer = new Hoek.Bench();
-        setTimeout(function () {
+        setTimeout(function () {
 
             expect(timer.elapsed()).to.be.above(9);
-            done();
-        }, 12);
-    });
+            done();
+        }, 12);
+    });
 });
 
-describe('escapeRegex()', function () {
+describe('escapeRegex()', function () {
 
-    it('escapes all special regular expression characters', function (done) {
+    it('escapes all special regular expression characters', function (done) {
 
         var a = Hoek.escapeRegex('4^f$s.4*5+-_?%=#!:@|~\\/`"(>)[<]d{}s,');
         expect(a).to.equal('4\\^f\\$s\\.4\\*5\\+\\-_\\?%\\=#\\!\\:@\\|~\\\\\\/`"\\(>\\)\\[<\\]d\\{\\}s\\,');
-        done();
-    });
+        done();
+    });
 });
 
-describe('Base64Url', function () {
+describe('Base64Url', function () {
 
     var base64str = 'AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0-P0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWltcXV5fYGFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6e3x9fn-AgYKDhIWGh4iJiouMjY6PkJGSk5SVlpeYmZqbnJ2en6ChoqOkpaanqKmqq6ytrq-wsbKztLW2t7i5uru8vb6_wMHCw8TFxsfIycrLzM3Oz9DR0tPU1dbX2Nna29zd3t_g4eLj5OXm5-jp6uvs7e7v8PHy8_T19vf4-fr7_P3-_w';
     var str = unescape('%00%01%02%03%04%05%06%07%08%09%0A%0B%0C%0D%0E%0F%10%11%12%13%14%15%16%17%18%19%1A%1B%1C%1D%1E%1F%20%21%22%23%24%25%26%27%28%29*+%2C-./0123456789%3A%3B%3C%3D%3E%3F@ABCDEFGHIJKLMNOPQRSTUVWXYZ%5B%5C%5D%5E_%60abcdefghijklmnopqrstuvwxyz%7B%7C%7D%7E%7F%80%81%82%83%84%85%86%87%88%89%8A%8B%8C%8D%8E%8F%90%91%92%93%94%95%96%97%98%99%9A%9B%9C%9D%9E%9F%A0%A1%A2%A3%A4%A5%A6%A7%A8%A9%AA%AB%AC%AD%AE%AF%B0%B1%B2%B3%B4%B5%B6%B7%B8%B9%BA%BB%BC%BD%BE%BF%C0%C1%C2%C3%C4%C5%C6%C7%C8%C9%CA%CB%CC%CD%CE%CF%D0%D1%D2%D3%D4%D5%D6%D7%D8%D9%DA%DB%DC%DD%DE%DF%E0%E1%E2%E3%E4%E5%E6%E7%E8%E9%EA%EB%EC%ED%EE%EF%F0%F1%F2%F3%F4%F5%F6%F7%F8%F9%FA%FB%FC%FD%FE%FF');
 
-    describe('base64urlEncode()', function () {
+    describe('base64urlEncode()', function () {
 
-        it('should base64 URL-safe a string', function (done) {
+        it('should base64 URL-safe a string', function (done) {
 
             expect(Hoek.base64urlEncode(str)).to.equal(base64str);
-            done();
+            done();
         });
 
-        it('encodes a buffer', function (done) {
+        it('encodes a buffer', function (done) {
 
             expect(Hoek.base64urlEncode(new Buffer(str, 'binary'))).to.equal(base64str);
-            done();
+            done();
         });
 
-        it('should base64 URL-safe a hex string', function (done) {
+        it('should base64 URL-safe a hex string', function (done) {
 
             var buffer = new Buffer(str, 'binary');
             expect(Hoek.base64urlEncode(buffer.toString('hex'), 'hex')).to.equal(base64str);
-            done();
+            done();
         });
 
-        it('works on larger input strings', function (done) {
+        it('works on larger input strings', function (done) {
 
             var input = Fs.readFileSync(Path.join(__dirname, 'index.js')).toString();
             var encoded = Hoek.base64urlEncode(input);
@@ -1931,145 +1954,145 @@ describe('Base64Url', function () {
             var decoded = Hoek.base64urlDecode(encoded);
 
             expect(decoded).to.equal(input);
-            done();
-        });
+            done();
+        });
     });
 
-    describe('base64urlDecode()', function () {
+    describe('base64urlDecode()', function () {
 
-        it('should un-base64 URL-safe a string', function (done) {
+        it('should un-base64 URL-safe a string', function (done) {
 
             expect(Hoek.base64urlDecode(base64str)).to.equal(str);
-            done();
+            done();
         });
 
-        it('should un-base64 URL-safe a string into hex', function (done) {
+        it('should un-base64 URL-safe a string into hex', function (done) {
 
             expect(Hoek.base64urlDecode(base64str, 'hex')).to.equal(new Buffer(str, 'binary').toString('hex'));
-            done();
+            done();
         });
 
-        it('should un-base64 URL-safe a string and return a buffer', function (done) {
+        it('should un-base64 URL-safe a string and return a buffer', function (done) {
 
             var buf = Hoek.base64urlDecode(base64str, 'buffer');
             expect(buf instanceof Buffer).to.equal(true);
             expect(buf.toString('binary')).to.equal(str);
-            done();
+            done();
         });
 
-        it('returns error on undefined input', function (done) {
+        it('returns error on undefined input', function (done) {
 
             expect(Hoek.base64urlDecode().message).to.exist();
-            done();
+            done();
         });
 
-        it('returns error on invalid input', function (done) {
+        it('returns error on invalid input', function (done) {
 
             expect(Hoek.base64urlDecode('*').message).to.exist();
-            done();
-        });
-    });
+            done();
+        });
+    });
 });
 
-describe('escapeHeaderAttribute()', function () {
+describe('escapeHeaderAttribute()', function () {
 
-    it('should not alter ascii values', function (done) {
+    it('should not alter ascii values', function (done) {
 
         var a = Hoek.escapeHeaderAttribute('My Value');
         expect(a).to.equal('My Value');
-        done();
+        done();
     });
 
-    it('escapes all special HTTP header attribute characters', function (done) {
+    it('escapes all special HTTP header attribute characters', function (done) {
 
         var a = Hoek.escapeHeaderAttribute('I said go!!!#"' + String.fromCharCode(92));
         expect(a).to.equal('I said go!!!#\\"\\\\');
-        done();
+        done();
     });
 
-    it('throws on large unicode characters', function (done) {
+    it('throws on large unicode characters', function (done) {
 
-        var fn = function () {
+        var fn = function () {
 
-            Hoek.escapeHeaderAttribute('this is a test' + String.fromCharCode(500) + String.fromCharCode(300));
+            Hoek.escapeHeaderAttribute('this is a test' + String.fromCharCode(500) + String.fromCharCode(300));
         };
 
         expect(fn).to.throw(Error);
-        done();
+        done();
     });
 
-    it('throws on CRLF to prevent response splitting', function (done) {
+    it('throws on CRLF to prevent response splitting', function (done) {
 
-        var fn = function () {
+        var fn = function () {
 
-            Hoek.escapeHeaderAttribute('this is a test\r\n');
+            Hoek.escapeHeaderAttribute('this is a test\r\n');
         };
 
         expect(fn).to.throw(Error);
-        done();
-    });
+        done();
+    });
 });
 
-describe('escapeHtml()', function () {
+describe('escapeHtml()', function () {
 
-    it('escapes all special HTML characters', function (done) {
+    it('escapes all special HTML characters', function (done) {
 
         var a = Hoek.escapeHtml('&<>"\'`');
         expect(a).to.equal('&amp;&lt;&gt;&quot;&#x27;&#x60;');
-        done();
+        done();
     });
 
-    it('returns empty string on falsy input', function (done) {
+    it('returns empty string on falsy input', function (done) {
 
         var a = Hoek.escapeHtml('');
         expect(a).to.equal('');
-        done();
+        done();
     });
 
-    it('returns unchanged string on no reserved input', function (done) {
+    it('returns unchanged string on no reserved input', function (done) {
 
         var a = Hoek.escapeHtml('abc');
         expect(a).to.equal('abc');
-        done();
-    });
+        done();
+    });
 });
 
-describe('nextTick()', function () {
+describe('nextTick()', function () {
 
-    it('calls the provided callback on nextTick', function (done) {
+    it('calls the provided callback on nextTick', function (done) {
 
         var a = 0;
 
-        var inc = function (step, next) {
+        var inc = function (step, next) {
 
             a += step;
-            next();
+            next();
         };
 
         var ticked = Hoek.nextTick(inc);
 
-        ticked(5, function () {
+        ticked(5, function () {
 
             expect(a).to.equal(6);
-            done();
+            done();
         });
 
         expect(a).to.equal(0);
-        inc(1, function () {
+        inc(1, function () {
 
-            expect(a).to.equal(1);
-        });
-    });
+            expect(a).to.equal(1);
+        });
+    });
 });
 
-describe('once()', function () {
+describe('once()', function () {
 
-    it('allows function to only execute once', function (done) {
+    it('allows function to only execute once', function (done) {
 
         var gen = 0;
-        var add = function (x) {
+        var add = function (x) {
 
-            gen += x;
+            gen += x;
         };
 
         add(5);
@@ -2079,23 +2102,23 @@ describe('once()', function () {
         expect(gen).to.equal(10);
         add(5);
         expect(gen).to.equal(10);
-        done();
+        done();
     });
 
-    it('double once wraps one time', function (done) {
+    it('double once wraps one time', function (done) {
 
         var method = function () { };
         method = Hoek.once(method);
         method.x = 1;
         method = Hoek.once(method);
         expect(method.x).to.equal(1);
-        done();
-    });
+        done();
+    });
 });
 
-describe('isAbsoltePath()', function () {
+describe('isAbsoltePath()', function () {
 
-    it('identifies if path is absolute on Unix without node support', { parallel: false }, function (done) {
+    it('identifies if path is absolute on Unix without node support', { parallel: false }, function (done) {
 
         var orig = Path.isAbsolute;
         Path.isAbsolute = undefined;
@@ -2108,15 +2131,15 @@ describe('isAbsoltePath()', function () {
 
         Path.isAbsolute = orig;
 
-        done();
+        done();
     });
 
-    it('identifies if path is absolute with fake node support', { parallel: false }, function (done) {
+    it('identifies if path is absolute with fake node support', { parallel: false }, function (done) {
 
         var orig = Path.isAbsolute;
-        Path.isAbsolute = function (path) {
-
-            return path[0] === '/';
+        Path.isAbsolute = function (path) {
+
+            return path[0] === '/';
         };
 
         expect(Hoek.isAbsolutePath('', 'linux')).to.equal(false);
@@ -2127,10 +2150,10 @@ describe('isAbsoltePath()', function () {
 
         Path.isAbsolute = orig;
 
-        done();
+        done();
     });
 
-    it('identifies if path is absolute on Windows without node support', { parallel: false }, function (done) {
+    it('identifies if path is absolute on Windows without node support', { parallel: false }, function (done) {
 
         var orig = Path.isAbsolute;
         Path.isAbsolute = undefined;
@@ -2147,13 +2170,13 @@ describe('isAbsoltePath()', function () {
 
         Path.isAbsolute = orig;
 
-        done();
-    });
+        done();
+    });
 });
 
-describe('isInteger()', function () {
+describe('isInteger()', function () {
 
-    it('validates integers', function (done) {
+    it('validates integers', function (done) {
 
         expect(Hoek.isInteger(0)).to.equal(true);
         expect(Hoek.isInteger(1)).to.equal(true);
@@ -2161,142 +2184,207 @@ describe('isInteger()', function () {
         expect(Hoek.isInteger('0')).to.equal(false);
         expect(Hoek.isInteger(1.0)).to.equal(true);
         expect(Hoek.isInteger(1.1)).to.equal(false);
-        done();
-    });
+        done();
+    });
 });
 
-describe('ignore()', function () {
+describe('ignore()', function () {
 
-    it('exists', function (done) {
+    it('exists', function (done) {
 
         expect(Hoek.ignore).to.exist();
         expect(typeof Hoek.ignore).to.equal('function');
-        done();
-    });
+        done();
+    });
 });
 
-describe('inherits()', function () {
+describe('inherits()', function () {
 
-    it('exists', function (done) {
+    it('exists', function (done) {
 
         expect(Hoek.inherits).to.exist();
         expect(typeof Hoek.inherits).to.equal('function');
-        done();
-    });
+        done();
+    });
 });
 
-describe('format()', function () {
+describe('format()', function () {
 
-    it('exists', function (done) {
+    it('exists', function (done) {
 
         expect(Hoek.format).to.exist();
         expect(typeof Hoek.format).to.equal('function');
-        done();
+        done();
     });
 
-    it('is a reference to Util.format', function (done) {
+    it('is a reference to Util.format', function (done) {
 
         expect(Hoek.format('hello %s', 'world')).to.equal('hello world');
-        done();
-    });
+        done();
+    });
 });
 
-describe('transform()', function () {
+describe('transform()', function () {
 
-    var source = {
-        address: {
+    var source = {
+        address: {
             one: '123 main street',
-            two: 'PO Box 1234'
+            two: 'PO Box 1234'
         },
-        zip: {
+        zip: {
             code: 3321232,
-            province: null
+            province: null
         },
         title: 'Warehouse',
-        state: 'CA'
+        state: 'CA'
     };
 
-    it('transforms an object based on the input object', function (done) {
+    var sourcesArray = [{
+        address: {
+            one: '123 main street',
+            two: 'PO Box 1234'
+        },
+        zip: {
+            code: 3321232,
+            province: null
+        },
+        title: 'Warehouse',
+        state: 'CA'
+    }, {
+        address: {
+            one: '456 market street',
+            two: 'PO Box 5678'
+        },
+        zip: {
+            code: 9876,
+            province: null
+        },
+        title: 'Garage',
+        state: 'NY'
+    }];
+
+    it('transforms an object based on the input object', function (done) {
 
-        var result = Hoek.transform(source, {
+        var result = Hoek.transform(source, {
             'person.address.lineOne': 'address.one',
             'person.address.lineTwo': 'address.two',
             'title': 'title',
             'person.address.region': 'state',
             'person.address.zip': 'zip.code',
-            'person.address.location': 'zip.province'
+            'person.address.location': 'zip.province'
         });
 
-        expect(result).to.deep.equal({
-            person: {
-                address: {
+        expect(result).to.deep.equal({
+            person: {
+                address: {
                     lineOne: '123 main street',
                     lineTwo: 'PO Box 1234',
                     region: 'CA',
                     zip: 3321232,
-                    location: null
-                }
+                    location: null
+                }
             },
-            title: 'Warehouse'
+            title: 'Warehouse'
+        });
+
+        done();
+    });
+
+    it('transforms an array of objects based on the input object', function (done) {
+
+        var result = Hoek.transform(sourcesArray, {
+            'person.address.lineOne': 'address.one',
+            'person.address.lineTwo': 'address.two',
+            'title': 'title',
+            'person.address.region': 'state',
+            'person.address.zip': 'zip.code',
+            'person.address.location': 'zip.province'
         });
 
-        done();
+        expect(result).to.deep.equal([
+            {
+                person: {
+                    address: {
+                        lineOne: '123 main street',
+                        lineTwo: 'PO Box 1234',
+                        region: 'CA',
+                        zip: 3321232,
+                        location: null
+                    }
+                },
+                title: 'Warehouse'
+            },
+            {
+                person: {
+                    address: {
+                        lineOne: '456 market street',
+                        lineTwo: 'PO Box 5678',
+                        region: 'NY',
+                        zip: 9876,
+                        location: null
+                    }
+                },
+                title: 'Garage'
+            }
+        ]);
+
+        done();
     });
 
-    it('uses the reach options passed into it', function (done) {
+    it('uses the reach options passed into it', function (done) {
 
-        var schema = {
+        var schema = {
             'person.address.lineOne': 'address-one',
             'person.address.lineTwo': 'address-two',
             'title': 'title',
             'person.address.region': 'state',
             'person.prefix': 'person-title',
-            'person.zip': 'zip-code'
+            'person.zip': 'zip-code'
         };
-        var options = {
+        var options = {
             separator: '-',
-            default: 'unknown'
+            default: 'unknown'
         };
         var result = Hoek.transform(source, schema, options);
 
-        expect(result).to.deep.equal({
-            person: {
-                address: {
+        expect(result).to.deep.equal({
+            person: {
+                address: {
                     lineOne: '123 main street',
                     lineTwo: 'PO Box 1234',
-                    region: 'CA'
+                    region: 'CA'
                 },
                 prefix: 'unknown',
-                zip: 3321232
+                zip: 3321232
             },
-            title: 'Warehouse'
+            title: 'Warehouse'
         });
 
-        done();
+        done();
     });
 
-    it('works to create shallow objects', function (done) {
+    it('works to create shallow objects', function (done) {
 
-        var result = Hoek.transform(source, {
+        var result = Hoek.transform(source, {
             lineOne: 'address.one',
             lineTwo: 'address.two',
             title: 'title',
             region: 'state',
-            province: 'zip.province'
+            province: 'zip.province'
         });
 
-        expect(result).to.deep.equal({
+        expect(result).to.deep.equal({
             lineOne: '123 main street',
             lineTwo: 'PO Box 1234',
             title: 'Warehouse',
             region: 'CA',
-            province: null
+            province: null
         });
 
-        done();
+        done();
     });
 
-    it('only allows strings in the map', function (done) {
+    it('only allows strings in the map', function (done) {
 
         expect(function () {
 
@@ -2305,121 +2393,121 @@ describe('transform()', function () {
             });
         }).to.throw('All mappings must be "." delineated strings');
 
-        done();
+        done();
     });
 
-    it('throws an error on invalid arguments', function (done) {
+    it('throws an error on invalid arguments', function (done) {
 
-        expect(function () {
+        expect(function () {
 
-            var result = Hoek.transform(NaN, {});
-        }).to.throw('Invalid source object: must be null, undefined, or an object');
+            var result = Hoek.transform(NaN, {});
+        }).to.throw('Invalid source object: must be null, undefined, an object, or an array');
 
-        done();
+        done();
     });
 
-    it('is safe to pass null', function (done) {
+    it('is safe to pass null', function (done) {
 
         var result = Hoek.transform(null, {});
         expect(result).to.deep.equal({});
 
-        done();
+        done();
     });
 
-    it('is safe to pass undefined', function (done) {
+    it('is safe to pass undefined', function (done) {
 
         var result = Hoek.transform(undefined, {});
         expect(result).to.deep.equal({});
 
-        done();
-    });
+        done();
+    });
 });
 
-describe('uniqueFilename()', function () {
+describe('uniqueFilename()', function () {
 
-    it('generates a random file path', function (done) {
+    it('generates a random file path', function (done) {
 
         var result = Hoek.uniqueFilename('./test/modules');
 
         expect(result).to.exist();
         expect(result).to.be.a.string();
         expect(result).to.contain('test/modules');
-        done();
+        done();
     });
 
-    it('is random enough to use in fast loops', function (done) {
+    it('is random enough to use in fast loops', function (done) {
 
         var results = [];
 
-        for (var i = 0; i < 10; ++i) {
-            results[i] = Hoek.uniqueFilename('./test/modules');
+        for (var i = 0; i < 10; ++i) {
+            results[i] = Hoek.uniqueFilename('./test/modules');
         }
 
-        var filter = results.filter(function (item, index, array) {
+        var filter = results.filter(function (item, index, array) {
 
-            return array.indexOf(item) === index;
+            return array.indexOf(item) === index;
         });
 
         expect(filter.length).to.equal(10);
         expect(results.length).to.equal(10);
-        done();
+        done();
 
     });
 
-    it('combines the random elements with a supplied character', function (done) {
+    it('combines the random elements with a supplied character', function (done) {
 
         var result = Hoek.uniqueFilename('./test', 'txt');
 
         expect(result).to.contain('test/');
         expect(result).to.contain('.txt');
 
-        done();
+        done();
     });
 
-    it('accepts extensions with a "." in it', function (done) {
+    it('accepts extensions with a "." in it', function (done) {
 
         var result = Hoek.uniqueFilename('./test', '.mp3');
 
         expect(result).to.contain('test/');
         expect(result).to.contain('.mp3');
 
-        done();
-    });
+        done();
+    });
 });
 
-describe('stringify()', function (done) {
+describe('stringify()', function (done) {
 
-    it('converts object to string', function (done) {
+    it('converts object to string', function (done) {
 
         var obj = { a: 1 };
         expect(Hoek.stringify(obj)).to.equal('{"a":1}');
-        done();
+        done();
     });
 
-    it('returns error in result string', function (done) {
+    it('returns error in result string', function (done) {
 
         var obj = { a: 1 };
         obj.b = obj;
         expect(Hoek.stringify(obj)).to.equal('[Cannot display object: Converting circular structure to JSON]');
-        done();
-    });
+        done();
+    });
 });
 
-describe('shallow()', function (done) {
+describe('shallow()', function (done) {
 
-    it('shallow copies an object', function (done) {
+    it('shallow copies an object', function (done) {
 
-        var obj = {
+        var obj = {
             a: 5,
-            b: {
-                c: 6
-            }
+            b: {
+                c: 6
+            }
         };
 
         var shallow = Hoek.shallow(obj);
         expect(shallow).to.not.equal(obj);
         expect(shallow).to.deep.equal(obj);
         expect(shallow.b).to.equal(obj.b);
-        done();
-    });
+        done();
+    });
 });