diff --git a/test/levels-test.js b/test/levels-test.js
index 567da0c..2637d39 100644
--- a/test/levels-test.js
+++ b/test/levels-test.js
@@ -1,210 +1,398 @@
+"use strict";
 var vows = require('vows')
 , assert = require('assert')
 , levels = require('../lib/levels');
 
 function assertThat(level) {
-    function assertForEach(assertion, test, otherLevels) {
-        otherLevels.forEach(function(other) {
-            assertion.call(assert, test.call(level, other));
-        });
-    }
+  function assertForEach(assertion, test, otherLevels) {
+    otherLevels.forEach(function(other) {
+      assertion.call(assert, test.call(level, other));
+    });
+  }
 
-    return {
-        isLessThanOrEqualTo: function(levels) {
-            assertForEach(assert.isTrue, level.isLessThanOrEqualTo, levels);
-        },
-        isNotLessThanOrEqualTo: function(levels) {
-            assertForEach(assert.isFalse, level.isLessThanOrEqualTo, levels);
-        },
-        isGreaterThanOrEqualTo: function(levels) {
-            assertForEach(assert.isTrue, level.isGreaterThanOrEqualTo, levels);
-        },
-        isNotGreaterThanOrEqualTo: function(levels) {
-            assertForEach(assert.isFalse, level.isGreaterThanOrEqualTo, levels);
-        },
-        isEqualTo: function(levels) {
-            assertForEach(assert.isTrue, level.isEqualTo, levels);
-        },
-        isNotEqualTo: function(levels) {
-            assertForEach(assert.isFalse, level.isEqualTo, levels);
-        }
-    };
+  return {
+    isLessThanOrEqualTo: function(levels) {
+      assertForEach(assert.isTrue, level.isLessThanOrEqualTo, levels);
+    },
+    isNotLessThanOrEqualTo: function(levels) {
+      assertForEach(assert.isFalse, level.isLessThanOrEqualTo, levels);
+    },
+    isGreaterThanOrEqualTo: function(levels) {
+      assertForEach(assert.isTrue, level.isGreaterThanOrEqualTo, levels);
+    },
+    isNotGreaterThanOrEqualTo: function(levels) {
+      assertForEach(assert.isFalse, level.isGreaterThanOrEqualTo, levels);
+    },
+    isEqualTo: function(levels) {
+      assertForEach(assert.isTrue, level.isEqualTo, levels);
+    },
+    isNotEqualTo: function(levels) {
+      assertForEach(assert.isFalse, level.isEqualTo, levels);
+    }
+  };
 }
 
 vows.describe('levels').addBatch({
-    'values': {
-        topic: levels,
-        'should define some levels': function(levels) {
-            assert.isNotNull(levels.ALL);
-            assert.isNotNull(levels.TRACE);
-            assert.isNotNull(levels.DEBUG);
-            assert.isNotNull(levels.INFO);
-            assert.isNotNull(levels.WARN);
-            assert.isNotNull(levels.ERROR);
-            assert.isNotNull(levels.FATAL);
-            assert.isNotNull(levels.OFF);
-        },
-        'ALL': {
-            topic: levels.ALL,
-            'should be less than the other levels': function(all) {
-                assertThat(all).isLessThanOrEqualTo([levels.ALL, levels.TRACE, levels.DEBUG, levels.INFO, levels.WARN, levels.ERROR, levels.FATAL, levels.OFF]);
-            },
-            'should be greater than no levels': function(all) {
-                assertThat(all).isNotGreaterThanOrEqualTo([levels.TRACE, levels.DEBUG, levels.INFO, levels.WARN, levels.ERROR, levels.FATAL, levels.OFF]);
-            },
-            'should only be equal to ALL': function(all) {
-                assertThat(all).isEqualTo([levels.toLevel("ALL")]);
-                assertThat(all).isNotEqualTo([levels.TRACE, levels.DEBUG, levels.INFO, levels.WARN, levels.ERROR, levels.FATAL, levels.OFF]);
-            }
-        },
-        'TRACE': {
-            topic: levels.TRACE,
-            'should be less than DEBUG': function(trace) {
-                assertThat(trace).isLessThanOrEqualTo([levels.DEBUG, levels.INFO, levels.WARN, levels.ERROR, levels.FATAL, levels.OFF]);
-                assertThat(trace).isNotLessThanOrEqualTo([levels.ALL]);
-            },
-            'should be greater than ALL': function(trace) {
-                assertThat(trace).isGreaterThanOrEqualTo([levels.ALL, levels.TRACE]);
-                assertThat(trace).isNotGreaterThanOrEqualTo([levels.DEBUG, levels.INFO, levels.WARN, levels.ERROR, levels.FATAL, levels.OFF]);
-            },
-            'should only be equal to TRACE': function(trace) {
-                assertThat(trace).isEqualTo([levels.toLevel("TRACE")]);
-                assertThat(trace).isNotEqualTo([levels.ALL, levels.DEBUG, levels.INFO, levels.WARN, levels.ERROR, levels.FATAL, levels.OFF]);
-            }
-        },
-        'DEBUG': {
-            topic: levels.DEBUG,
-            'should be less than INFO': function(debug) {
-                assertThat(debug).isLessThanOrEqualTo([levels.INFO, levels.WARN, levels.ERROR, levels.FATAL, levels.OFF]);
-                assertThat(debug).isNotLessThanOrEqualTo([levels.ALL, levels.TRACE]);
-            },
-            'should be greater than TRACE': function(debug) {
-                assertThat(debug).isGreaterThanOrEqualTo([levels.ALL, levels.TRACE]);
-                assertThat(debug).isNotGreaterThanOrEqualTo([levels.INFO, levels.WARN, levels.ERROR, levels.FATAL, levels.OFF]);
-            },
-            'should only be equal to DEBUG': function(trace) {
-                assertThat(trace).isEqualTo([levels.toLevel("DEBUG")]);
-                assertThat(trace).isNotEqualTo([levels.ALL, levels.TRACE, levels.INFO, levels.WARN, levels.ERROR, levels.FATAL, levels.OFF]);
-            }
-        },
-        'INFO': {
-            topic: levels.INFO,
-            'should be less than WARN': function(info) {
-                assertThat(info).isLessThanOrEqualTo([levels.WARN, levels.ERROR, levels.FATAL, levels.OFF]);
-                assertThat(info).isNotLessThanOrEqualTo([levels.ALL, levels.TRACE, levels.DEBUG]);
-            },
-            'should be greater than DEBUG': function(info) {
-                assertThat(info).isGreaterThanOrEqualTo([levels.ALL, levels.TRACE, levels.DEBUG]);
-                assertThat(info).isNotGreaterThanOrEqualTo([levels.WARN, levels.ERROR, levels.FATAL, levels.OFF]);
-            },
-            'should only be equal to INFO': function(trace) {
-                assertThat(trace).isEqualTo([levels.toLevel("INFO")]);
-                assertThat(trace).isNotEqualTo([levels.ALL, levels.TRACE, levels.DEBUG, levels.WARN, levels.ERROR, levels.FATAL, levels.OFF]);
-            }
-        },
-        'WARN': {
-            topic: levels.WARN,
-            'should be less than ERROR': function(warn) {
-                assertThat(warn).isLessThanOrEqualTo([levels.ERROR, levels.FATAL, levels.OFF]);
-                assertThat(warn).isNotLessThanOrEqualTo([levels.ALL, levels.TRACE, levels.DEBUG, levels.INFO]);
-            },
-            'should be greater than INFO': function(warn) {
-                assertThat(warn).isGreaterThanOrEqualTo([levels.ALL, levels.TRACE, levels.DEBUG, levels.INFO]);
-                assertThat(warn).isNotGreaterThanOrEqualTo([levels.ERROR, levels.FATAL, levels.OFF]);
-            },
-            'should only be equal to WARN': function(trace) {
-                assertThat(trace).isEqualTo([levels.toLevel("WARN")]);
-                assertThat(trace).isNotEqualTo([levels.ALL, levels.TRACE, levels.DEBUG, levels.INFO, levels.ERROR, levels.FATAL, levels.OFF]);
-            }
-        },
-        'ERROR': {
-            topic: levels.ERROR,
-            'should be less than FATAL': function(error) {
-                assertThat(error).isLessThanOrEqualTo([levels.FATAL, levels.OFF]);
-                assertThat(error).isNotLessThanOrEqualTo([levels.ALL, levels.TRACE, levels.DEBUG, levels.INFO, levels.WARN]);
-            },
-            'should be greater than WARN': function(error) {
-                assertThat(error).isGreaterThanOrEqualTo([levels.ALL, levels.TRACE, levels.DEBUG, levels.INFO, levels.WARN]);
-                assertThat(error).isNotGreaterThanOrEqualTo([levels.FATAL, levels.OFF]);
-            },
-            'should only be equal to ERROR': function(trace) {
-                assertThat(trace).isEqualTo([levels.toLevel("ERROR")]);
-                assertThat(trace).isNotEqualTo([levels.ALL, levels.TRACE, levels.DEBUG, levels.INFO, levels.WARN, levels.FATAL, levels.OFF]);
-            }
-        },
-        'FATAL': {
-            topic: levels.FATAL,
-            'should be less than OFF': function(fatal) {
-                assertThat(fatal).isLessThanOrEqualTo([levels.OFF]);
-                assertThat(fatal).isNotLessThanOrEqualTo([levels.ALL, levels.TRACE, levels.DEBUG, levels.INFO, levels.WARN, levels.ERROR]);
-            },
-            'should be greater than ERROR': function(fatal) {
-                assertThat(fatal).isGreaterThanOrEqualTo([levels.ALL, levels.TRACE, levels.DEBUG, levels.INFO, levels.WARN, levels.ERROR]);
-                assertThat(fatal).isNotGreaterThanOrEqualTo([levels.OFF]);
-            },
-            'should only be equal to FATAL': function(fatal) {
-                assertThat(fatal).isEqualTo([levels.toLevel("FATAL")]);
-                assertThat(fatal).isNotEqualTo([levels.ALL, levels.TRACE, levels.DEBUG, levels.INFO, levels.WARN, levels.ERROR, levels.OFF]);
-            }
-        },
-        'OFF': {
-            topic: levels.OFF,
-            'should not be less than anything': function(off) {
-                assertThat(off).isNotLessThanOrEqualTo([levels.ALL, levels.TRACE, levels.DEBUG, levels.INFO, levels.WARN, levels.ERROR, levels.FATAL]);
-            },
-            'should be greater than everything': function(off) {
-                assertThat(off).isGreaterThanOrEqualTo([levels.ALL, levels.TRACE, levels.DEBUG, levels.INFO, levels.WARN, levels.ERROR, levels.FATAL]);
-            },
-            'should only be equal to OFF': function(off) {
-                assertThat(off).isEqualTo([levels.toLevel("OFF")]);
-                assertThat(off).isNotEqualTo([levels.ALL, levels.TRACE, levels.DEBUG, levels.INFO, levels.WARN, levels.ERROR, levels.FATAL]);
-            }
-        }
-    },
-    'isGreaterThanOrEqualTo': {
-        topic: levels.INFO,
-        'should handle string arguments': function(info) {
-            assertThat(info).isGreaterThanOrEqualTo(["all", "trace", "debug"]);
-            assertThat(info).isNotGreaterThanOrEqualTo(['warn', 'ERROR', 'Fatal', 'off']);
-        }
-    },
-    'isLessThanOrEqualTo': {
-        topic: levels.INFO,
-        'should handle string arguments': function(info) {
-            assertThat(info).isNotLessThanOrEqualTo(["all", "trace", "debug"]);
-            assertThat(info).isLessThanOrEqualTo(['warn', 'ERROR', 'Fatal', 'off']);
-        }
-    },
-    'toLevel': {
-        'with lowercase argument': {
-            topic: levels.toLevel("debug"),
-            'should take the string and return the corresponding level': function(level) {
-                assert.equal(level, levels.DEBUG);
-            }
-        },
-        'with uppercase argument': {
-            topic: levels.toLevel("DEBUG"),
-            'should take the string and return the corresponding level': function(level) {
-                assert.equal(level, levels.DEBUG);
-            }
-        },
-        'with varying case': {
-            topic: levels.toLevel("DeBuG"),
-            'should take the string and return the corresponding level': function(level) {
-                assert.equal(level, levels.DEBUG);
-            }
-        },
-        'with unrecognised argument': {
-            topic: levels.toLevel("cheese"),
-            'should return undefined': function(level) {
-                assert.isUndefined(level);
-            }
-        },
-        'with unrecognised argument and default value': {
-            topic: levels.toLevel("cheese", levels.DEBUG),
-            'should return default value': function(level) {
-                assert.equal(level, levels.DEBUG);
-            }
-        }
+  'values': {
+    topic: levels,
+    'should define some levels': function(levels) {
+      assert.isNotNull(levels.ALL);
+      assert.isNotNull(levels.TRACE);
+      assert.isNotNull(levels.DEBUG);
+      assert.isNotNull(levels.INFO);
+      assert.isNotNull(levels.WARN);
+      assert.isNotNull(levels.ERROR);
+      assert.isNotNull(levels.FATAL);
+      assert.isNotNull(levels.OFF);
+    },
+    'ALL': {
+      topic: levels.ALL,
+      'should be less than the other levels': function(all) {
+        assertThat(all).isLessThanOrEqualTo(
+          [ 
+            levels.ALL, 
+            levels.TRACE, 
+            levels.DEBUG, 
+            levels.INFO, 
+            levels.WARN, 
+            levels.ERROR, 
+            levels.FATAL, 
+            levels.OFF
+          ]
+        );
+      },
+      'should be greater than no levels': function(all) {
+        assertThat(all).isNotGreaterThanOrEqualTo(
+          [
+            levels.TRACE, 
+            levels.DEBUG, 
+            levels.INFO, 
+            levels.WARN, 
+            levels.ERROR, 
+            levels.FATAL, 
+            levels.OFF
+          ]
+        );
+      },
+      'should only be equal to ALL': function(all) {
+        assertThat(all).isEqualTo([levels.toLevel("ALL")]);
+        assertThat(all).isNotEqualTo(
+          [
+            levels.TRACE, 
+            levels.DEBUG, 
+            levels.INFO, 
+            levels.WARN, 
+            levels.ERROR, 
+            levels.FATAL, 
+            levels.OFF
+          ]
+        );
+      }
+    },
+    'TRACE': {
+      topic: levels.TRACE,
+      'should be less than DEBUG': function(trace) {
+        assertThat(trace).isLessThanOrEqualTo(
+          [
+            levels.DEBUG, 
+            levels.INFO, 
+            levels.WARN, 
+            levels.ERROR, 
+            levels.FATAL, 
+            levels.OFF
+          ]
+        );
+        assertThat(trace).isNotLessThanOrEqualTo([levels.ALL]);
+      },
+      'should be greater than ALL': function(trace) {
+        assertThat(trace).isGreaterThanOrEqualTo([levels.ALL, levels.TRACE]);
+        assertThat(trace).isNotGreaterThanOrEqualTo(
+          [
+            levels.DEBUG, 
+            levels.INFO, 
+            levels.WARN, 
+            levels.ERROR, 
+            levels.FATAL, 
+            levels.OFF
+          ]
+        );
+      },
+      'should only be equal to TRACE': function(trace) {
+        assertThat(trace).isEqualTo([levels.toLevel("TRACE")]);
+        assertThat(trace).isNotEqualTo(
+          [
+            levels.ALL, 
+            levels.DEBUG, 
+            levels.INFO, 
+            levels.WARN, 
+            levels.ERROR, 
+            levels.FATAL, 
+            levels.OFF
+          ]
+        );
+      }
+    },
+    'DEBUG': {
+      topic: levels.DEBUG,
+      'should be less than INFO': function(debug) {
+        assertThat(debug).isLessThanOrEqualTo(
+          [
+            levels.INFO, 
+            levels.WARN, 
+            levels.ERROR, 
+            levels.FATAL, 
+            levels.OFF
+          ]
+        );
+        assertThat(debug).isNotLessThanOrEqualTo([levels.ALL, levels.TRACE]);
+      },
+      'should be greater than TRACE': function(debug) {
+        assertThat(debug).isGreaterThanOrEqualTo([levels.ALL, levels.TRACE]);
+        assertThat(debug).isNotGreaterThanOrEqualTo(
+          [
+            levels.INFO, 
+            levels.WARN, 
+            levels.ERROR, 
+            levels.FATAL, 
+            levels.OFF
+          ]
+        );
+      },
+      'should only be equal to DEBUG': function(trace) {
+        assertThat(trace).isEqualTo([levels.toLevel("DEBUG")]);
+        assertThat(trace).isNotEqualTo(
+          [
+            levels.ALL, 
+            levels.TRACE, 
+            levels.INFO, 
+            levels.WARN, 
+            levels.ERROR, 
+            levels.FATAL, 
+            levels.OFF
+          ]
+        );
+      }
+    },
+    'INFO': {
+      topic: levels.INFO,
+      'should be less than WARN': function(info) {
+        assertThat(info).isLessThanOrEqualTo([
+          levels.WARN, 
+          levels.ERROR, 
+          levels.FATAL, 
+          levels.OFF
+        ]);
+        assertThat(info).isNotLessThanOrEqualTo([levels.ALL, levels.TRACE, levels.DEBUG]);
+      },
+      'should be greater than DEBUG': function(info) {
+        assertThat(info).isGreaterThanOrEqualTo([levels.ALL, levels.TRACE, levels.DEBUG]);
+        assertThat(info).isNotGreaterThanOrEqualTo([
+          levels.WARN, 
+          levels.ERROR, 
+          levels.FATAL, 
+          levels.OFF
+        ]);
+      },
+      'should only be equal to INFO': function(trace) {
+        assertThat(trace).isEqualTo([levels.toLevel("INFO")]);
+        assertThat(trace).isNotEqualTo([
+          levels.ALL, 
+          levels.TRACE, 
+          levels.DEBUG, 
+          levels.WARN, 
+          levels.ERROR, 
+          levels.FATAL, 
+          levels.OFF
+        ]);
+      }
+    },
+    'WARN': {
+      topic: levels.WARN,
+      'should be less than ERROR': function(warn) {
+        assertThat(warn).isLessThanOrEqualTo([levels.ERROR, levels.FATAL, levels.OFF]);
+        assertThat(warn).isNotLessThanOrEqualTo([
+          levels.ALL, 
+          levels.TRACE, 
+          levels.DEBUG, 
+          levels.INFO
+        ]);
+      },
+      'should be greater than INFO': function(warn) {
+        assertThat(warn).isGreaterThanOrEqualTo([
+          levels.ALL, 
+          levels.TRACE, 
+          levels.DEBUG, 
+          levels.INFO
+        ]);
+        assertThat(warn).isNotGreaterThanOrEqualTo([levels.ERROR, levels.FATAL, levels.OFF]);
+      },
+      'should only be equal to WARN': function(trace) {
+        assertThat(trace).isEqualTo([levels.toLevel("WARN")]);
+        assertThat(trace).isNotEqualTo([
+          levels.ALL, 
+          levels.TRACE, 
+          levels.DEBUG, 
+          levels.INFO, 
+          levels.ERROR, 
+          levels.FATAL, 
+          levels.OFF
+        ]);
+      }
+    },
+    'ERROR': {
+      topic: levels.ERROR,
+      'should be less than FATAL': function(error) {
+        assertThat(error).isLessThanOrEqualTo([levels.FATAL, levels.OFF]);
+        assertThat(error).isNotLessThanOrEqualTo([
+          levels.ALL, 
+          levels.TRACE, 
+          levels.DEBUG, 
+          levels.INFO, 
+          levels.WARN
+        ]);
+      },
+      'should be greater than WARN': function(error) {
+        assertThat(error).isGreaterThanOrEqualTo([
+          levels.ALL, 
+          levels.TRACE, 
+          levels.DEBUG, 
+          levels.INFO, 
+          levels.WARN
+        ]);
+        assertThat(error).isNotGreaterThanOrEqualTo([levels.FATAL, levels.OFF]);
+      },
+      'should only be equal to ERROR': function(trace) {
+        assertThat(trace).isEqualTo([levels.toLevel("ERROR")]);
+        assertThat(trace).isNotEqualTo([
+          levels.ALL, 
+          levels.TRACE, 
+          levels.DEBUG, 
+          levels.INFO, 
+          levels.WARN, 
+          levels.FATAL, 
+          levels.OFF
+        ]);
+      }
+    },
+    'FATAL': {
+      topic: levels.FATAL,
+      'should be less than OFF': function(fatal) {
+        assertThat(fatal).isLessThanOrEqualTo([levels.OFF]);
+        assertThat(fatal).isNotLessThanOrEqualTo([
+          levels.ALL, 
+          levels.TRACE, 
+          levels.DEBUG, 
+          levels.INFO, 
+          levels.WARN, 
+          levels.ERROR
+        ]);
+      },
+      'should be greater than ERROR': function(fatal) {
+        assertThat(fatal).isGreaterThanOrEqualTo([
+          levels.ALL, 
+          levels.TRACE, 
+          levels.DEBUG, 
+          levels.INFO, 
+          levels.WARN, 
+          levels.ERROR
+        ]);
+        assertThat(fatal).isNotGreaterThanOrEqualTo([levels.OFF]);
+      },
+      'should only be equal to FATAL': function(fatal) {
+        assertThat(fatal).isEqualTo([levels.toLevel("FATAL")]);
+        assertThat(fatal).isNotEqualTo([
+          levels.ALL, 
+          levels.TRACE, 
+          levels.DEBUG, 
+          levels.INFO, 
+          levels.WARN, 
+          levels.ERROR, 
+          levels.OFF
+        ]);
+      }
+    },
+    'OFF': {
+      topic: levels.OFF,
+      'should not be less than anything': function(off) {
+        assertThat(off).isNotLessThanOrEqualTo([
+          levels.ALL, 
+          levels.TRACE, 
+          levels.DEBUG, 
+          levels.INFO, 
+          levels.WARN, 
+          levels.ERROR, 
+          levels.FATAL
+        ]);
+      },
+      'should be greater than everything': function(off) {
+        assertThat(off).isGreaterThanOrEqualTo([
+          levels.ALL, 
+          levels.TRACE, 
+          levels.DEBUG, 
+          levels.INFO, 
+          levels.WARN, 
+          levels.ERROR, 
+          levels.FATAL
+        ]);
+      },
+      'should only be equal to OFF': function(off) {
+        assertThat(off).isEqualTo([levels.toLevel("OFF")]);
+        assertThat(off).isNotEqualTo([
+          levels.ALL, 
+          levels.TRACE, 
+          levels.DEBUG, 
+          levels.INFO, 
+          levels.WARN, 
+          levels.ERROR, 
+          levels.FATAL
+        ]);
+      }
+    }
+  },
+  'isGreaterThanOrEqualTo': {
+    topic: levels.INFO,
+    'should handle string arguments': function(info) {
+      assertThat(info).isGreaterThanOrEqualTo(["all", "trace", "debug"]);
+      assertThat(info).isNotGreaterThanOrEqualTo(['warn', 'ERROR', 'Fatal', 'off']);
+    }
+  },
+  'isLessThanOrEqualTo': {
+    topic: levels.INFO,
+    'should handle string arguments': function(info) {
+      assertThat(info).isNotLessThanOrEqualTo(["all", "trace", "debug"]);
+      assertThat(info).isLessThanOrEqualTo(['warn', 'ERROR', 'Fatal', 'off']);
+    }
+  },
+  'toLevel': {
+    'with lowercase argument': {
+      topic: levels.toLevel("debug"),
+      'should take the string and return the corresponding level': function(level) {
+        assert.equal(level, levels.DEBUG);
+      }
+    },
+    'with uppercase argument': {
+      topic: levels.toLevel("DEBUG"),
+      'should take the string and return the corresponding level': function(level) {
+        assert.equal(level, levels.DEBUG);
+      }
+    },
+    'with varying case': {
+      topic: levels.toLevel("DeBuG"),
+      'should take the string and return the corresponding level': function(level) {
+        assert.equal(level, levels.DEBUG);
+      }
+    },
+    'with unrecognised argument': {
+      topic: levels.toLevel("cheese"),
+      'should return undefined': function(level) {
+        assert.isUndefined(level);
+      }
+    },
+    'with unrecognised argument and default value': {
+      topic: levels.toLevel("cheese", levels.DEBUG),
+      'should return default value': function(level) {
+        assert.equal(level, levels.DEBUG);
+      }
     }
+  }
 }).export(module);