migrating repo to Bodyrep org

2026-03-14 17:05:56 +00:00 · 2013-01-19 11:23:43 -05:00
parent 31b7303f43
commit 4ea082330b
891 changed files with 142706 additions and 0 deletions
--- a/node_modules/qs/test/browser/expect.js
+++ b/node_modules/qs/test/browser/expect.js
--- a/node_modules/qs/test/browser/index.html
+++ b/node_modules/qs/test/browser/index.html
@@ -0,0 +1,18 @@
+<html>
+  <head>
+    <title>Mocha</title>
+    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+    <link rel="stylesheet" href="mocha.css" />
+    <script src="jquery.js" type="text/javascript"></script>
+    <script src="expect.js"></script>
+    <script src="mocha.js"></script>
+    <script>mocha.setup('bdd')</script>
+    <script src="qs.js"></script>
+    <script src="../parse.js"></script>
+    <script src="../stringify.js"></script>
+    <script>onload = mocha.run;</script>
+  </head>
+  <body>
+    <div id="mocha"></div>
+  </body>
+</html>
--- a/node_modules/qs/test/browser/jquery.js
+++ b/node_modules/qs/test/browser/jquery.js
--- a/node_modules/qs/test/browser/mocha.css
+++ b/node_modules/qs/test/browser/mocha.css
@@ -0,0 +1,163 @@
+
+body {
+  font: 20px/1.5 "Helvetica Neue", Helvetica, Arial, sans-serif;
+  padding: 60px 50px;
+}
+
+#mocha h1, h2 {
+  margin: 0;
+}
+
+#mocha h1 {
+  margin-top: 15px;
+  font-size: 1em;
+  font-weight: 200;
+}
+
+#mocha .suite .suite h1 {
+  margin-top: 0;
+  font-size: .8em;
+}
+
+#mocha h2 {
+  font-size: 12px;
+  font-weight: normal;
+  cursor: pointer;
+}
+
+#mocha .suite {
+  margin-left: 15px;
+}
+
+#mocha .test {
+  margin-left: 15px;
+}
+
+#mocha .test:hover h2::after {
+  position: relative;
+  top: 0;
+  right: -10px;
+  content: '(view source)';
+  font-size: 12px;
+  font-family: arial;
+  color: #888;
+}
+
+#mocha .test.pending:hover h2::after {
+  content: '(pending)';
+  font-family: arial;
+}
+
+#mocha .test.pass.medium .duration {
+  background: #C09853;
+}
+
+#mocha .test.pass.slow .duration {
+  background: #B94A48;
+}
+
+#mocha .test.pass::before {
+  content: '✓';
+  font-size: 12px;
+  display: block;
+  float: left;
+  margin-right: 5px;
+}
+
+#mocha .test.pass .duration {
+  font-size: 9px;
+  margin-left: 5px;
+  padding: 2px 5px;
+  color: white;
+  -webkit-box-shadow: inset 0 1px 1px rgba(0,0,0,.2);
+  -moz-box-shadow: inset 0 1px 1px rgba(0,0,0,.2);
+  box-shadow: inset 0 1px 1px rgba(0,0,0,.2);
+  -webkit-border-radius: 5px;
+  -moz-border-radius: 5px;
+  -ms-border-radius: 5px;
+  -o-border-radius: 5px;
+  border-radius: 5px;
+}
+
+#mocha .test.pass.fast .duration {
+  display: none;
+}
+
+#mocha .test.pending {
+  color: #0b97c4;
+}
+
+#mocha .test.pending::before {
+  content: '◦';
+  color: #0b97c4;
+}
+
+#mocha .test.fail {
+  color: #c00;
+}
+
+#mocha .test.fail pre {
+  color: black;
+}
+
+#mocha .test.fail::before {
+  content: '✖';
+  font-size: 12px;
+  display: block;
+  float: left;
+  margin-right: 5px;
+  color: #c00;
+}
+
+#mocha .test pre.error {
+  color: #c00;
+}
+
+#mocha .test pre {
+  display: inline-block;
+  font: 12px/1.5 monaco, monospace;
+  margin: 5px;
+  padding: 15px;
+  border: 1px solid #eee;
+  border-bottom-color: #ddd;
+  -webkit-border-radius: 3px;
+  -webkit-box-shadow: 0 1px 3px #eee;
+}
+
+#error {
+  color: #c00;
+  font-size: 1.5  em;
+  font-weight: 100;
+  letter-spacing: 1px;
+}
+
+#stats {
+  position: fixed;
+  top: 15px;
+  right: 10px;
+  font-size: 12px;
+  margin: 0;
+  color: #888;
+}
+
+#stats .progress {
+  float: right;
+  padding-top: 0;
+}
+
+#stats em {
+  color: black;
+}
+
+#stats li {
+  display: inline-block;
+  margin: 0 5px;
+  list-style: none;
+  padding-top: 11px;
+}
+
+code .comment { color: #ddd }
+code .init { color: #2F6FAD }
+code .string { color: #5890AD }
+code .keyword { color: #8A6343 }
+code .number { color: #2F6FAD }
--- a/node_modules/qs/test/browser/mocha.js
+++ b/node_modules/qs/test/browser/mocha.js
--- a/node_modules/qs/test/browser/qs.css
+++ b/node_modules/qs/test/browser/qs.css
--- a/node_modules/qs/test/browser/qs.js
+++ b/node_modules/qs/test/browser/qs.js
@@ -0,0 +1,351 @@
+
+/**
+ * Require the given path.
+ *
+ * @param {String} path
+ * @return {Object} exports
+ * @api public
+ */
+
+function require(p, parent){
+  var path = require.resolve(p)
+    , mod = require.modules[path];
+  if (!mod) throw new Error('failed to require "' + p + '" in ' + parent);
+  if (!mod.exports) {
+    mod.exports = {};
+    mod.client = true;
+    mod.call(mod.exports, mod, mod.exports, require.relative(path));
+  }
+  return mod.exports;
+}
+
+/**
+ * Registered modules.
+ */
+
+require.modules = {};
+
+/**
+ * Resolve `path`.
+ *
+ * @param {String} path
+ * @return {Object} module
+ * @api public
+ */
+
+require.resolve = function(path){
+  var orig = path
+    , reg = path + '.js'
+    , index = path + '/index.js';
+  return require.modules[reg] && reg
+    || require.modules[index] && index
+    || orig;
+};
+
+/**
+ * Register module at `path` with callback `fn`.
+ *
+ * @param {String} path
+ * @param {Function} fn
+ * @api public
+ */
+
+require.register = function(path, fn){
+  require.modules[path] = fn;
+};
+
+/**
+ * Defines and executes anonymous module immediately, while preserving relative
+ * paths.
+ *
+ * @param {String} path
+ * @param {Function} require ref
+ * @api public
+ */
+
+require.exec = function (path, fn) {
+  fn.call(window, require.relative(path));
+};
+
+/**
+ * Return a require function relative to the `parent` path.
+ *
+ * @param {String} parent
+ * @return {Function}
+ * @api private
+ */
+
+require.relative = function(parent) {
+  return function(p){
+    if ('.' != p[0]) return require(p);
+    
+    var path = parent.split('/')
+      , segs = p.split('/');
+    path.pop();
+    
+    for (var i = 0; i < segs.length; i++) {
+      var seg = segs[i];
+      if ('..' == seg) path.pop();
+      else if ('.' != seg) path.push(seg);
+    }
+
+    return require(path.join('/'), parent);
+  };
+};
+// component qs: querystring
+require.register("querystring", function(module, exports, require){
+;(function(){
+
+/**
+ * Object#toString() ref for stringify().
+ */
+
+var toString = Object.prototype.toString;
+
+/**
+ * Cache non-integer test regexp.
+ */
+
+var isint = /^[0-9]+$/;
+
+function promote(parent, key) {
+  if (parent[key].length == 0) return parent[key] = {};
+  var t = {};
+  for (var i in parent[key]) t[i] = parent[key][i];
+  parent[key] = t;
+  return t;
+}
+
+function parse(parts, parent, key, val) {
+  var part = parts.shift();
+  // end
+  if (!part) {
+    if (Array.isArray(parent[key])) {
+      parent[key].push(val);
+    } else if ('object' == typeof parent[key]) {
+      parent[key] = val;
+    } else if ('undefined' == typeof parent[key]) {
+      parent[key] = val;
+    } else {
+      parent[key] = [parent[key], val];
+    }
+    // array
+  } else {
+    var obj = parent[key] = parent[key] || [];
+    if (']' == part) {
+      if (Array.isArray(obj)) {
+        if ('' != val) obj.push(val);
+      } else if ('object' == typeof obj) {
+        obj[Object.keys(obj).length] = val;
+      } else {
+        obj = parent[key] = [parent[key], val];
+      }
+      // prop
+    } else if (~part.indexOf(']')) {
+      part = part.substr(0, part.length - 1);
+      if (!isint.test(part) && Array.isArray(obj)) obj = promote(parent, key);
+      parse(parts, obj, part, val);
+      // key
+    } else {
+      if (!isint.test(part) && Array.isArray(obj)) obj = promote(parent, key);
+      parse(parts, obj, part, val);
+    }
+  }
+}
+
+/**
+ * Merge parent key/val pair.
+ */
+
+function merge(parent, key, val){
+  if (~key.indexOf(']')) {
+    var parts = key.split('[')
+      , len = parts.length
+      , last = len - 1;
+    parse(parts, parent, 'base', val);
+    // optimize
+  } else {
+    if (!isint.test(key) && Array.isArray(parent.base)) {
+      var t = {};
+      for (var k in parent.base) t[k] = parent.base[k];
+      parent.base = t;
+    }
+    set(parent.base, key, val);
+  }
+
+  return parent;
+}
+
+/**
+ * Parse the given obj.
+ */
+
+function parseObject(obj){
+  var ret = { base: {} };
+  Object.keys(obj).forEach(function(name){
+    merge(ret, name, obj[name]);
+  });
+  return ret.base;
+}
+
+/**
+ * Parse the given str.
+ */
+
+function parseString(str){
+  return String(str)
+    .split('&')
+    .reduce(function(ret, pair){
+      try{
+        pair = decodeURIComponent(pair.replace(/\+/g, ' '));
+      } catch(e) {
+        // ignore
+      }
+
+      var eql = pair.indexOf('=')
+        , brace = lastBraceInKey(pair)
+        , key = pair.substr(0, brace || eql)
+        , val = pair.substr(brace || eql, pair.length)
+        , val = val.substr(val.indexOf('=') + 1, val.length);
+
+      // ?foo
+      if ('' == key) key = pair, val = '';
+
+      return merge(ret, key, val);
+    }, { base: {} }).base;
+}
+
+/**
+ * Parse the given query `str` or `obj`, returning an object.
+ *
+ * @param {String} str | {Object} obj
+ * @return {Object}
+ * @api public
+ */
+
+exports.parse = function(str){
+  if (null == str || '' == str) return {};
+  return 'object' == typeof str
+    ? parseObject(str)
+    : parseString(str);
+};
+
+/**
+ * Turn the given `obj` into a query string
+ *
+ * @param {Object} obj
+ * @return {String}
+ * @api public
+ */
+
+var stringify = exports.stringify = function(obj, prefix) {
+  if (Array.isArray(obj)) {
+    return stringifyArray(obj, prefix);
+  } else if ('[object Object]' == toString.call(obj)) {
+    return stringifyObject(obj, prefix);
+  } else if ('string' == typeof obj) {
+    return stringifyString(obj, prefix);
+  } else {
+    return prefix + '=' + obj;
+  }
+};
+
+/**
+ * Stringify the given `str`.
+ *
+ * @param {String} str
+ * @param {String} prefix
+ * @return {String}
+ * @api private
+ */
+
+function stringifyString(str, prefix) {
+  if (!prefix) throw new TypeError('stringify expects an object');
+  return prefix + '=' + encodeURIComponent(str);
+}
+
+/**
+ * Stringify the given `arr`.
+ *
+ * @param {Array} arr
+ * @param {String} prefix
+ * @return {String}
+ * @api private
+ */
+
+function stringifyArray(arr, prefix) {
+  var ret = [];
+  if (!prefix) throw new TypeError('stringify expects an object');
+  for (var i = 0; i < arr.length; i++) {
+    ret.push(stringify(arr[i], prefix + '['+i+']'));
+  }
+  return ret.join('&');
+}
+
+/**
+ * Stringify the given `obj`.
+ *
+ * @param {Object} obj
+ * @param {String} prefix
+ * @return {String}
+ * @api private
+ */
+
+function stringifyObject(obj, prefix) {
+  var ret = []
+    , keys = Object.keys(obj)
+    , key;
+
+  for (var i = 0, len = keys.length; i < len; ++i) {
+    key = keys[i];
+    ret.push(stringify(obj[key], prefix
+      ? prefix + '[' + encodeURIComponent(key) + ']'
+      : encodeURIComponent(key)));
+  }
+
+  return ret.join('&');
+}
+
+/**
+ * Set `obj`'s `key` to `val` respecting
+ * the weird and wonderful syntax of a qs,
+ * where "foo=bar&foo=baz" becomes an array.
+ *
+ * @param {Object} obj
+ * @param {String} key
+ * @param {String} val
+ * @api private
+ */
+
+function set(obj, key, val) {
+  var v = obj[key];
+  if (undefined === v) {
+    obj[key] = val;
+  } else if (Array.isArray(v)) {
+    v.push(val);
+  } else {
+    obj[key] = [v, val];
+  }
+}
+
+/**
+ * Locate last brace in `str` within the key.
+ *
+ * @param {String} str
+ * @return {Number}
+ * @api private
+ */
+
+function lastBraceInKey(str) {
+  var len = str.length
+    , brace
+    , c;
+  for (var i = 0; i < len; ++i) {
+    c = str[i];
+    if (']' == c) brace = false;
+    if ('[' == c) brace = true;
+    if ('=' == c && !brace) return i;
+  }
+}
+})();
+});
--- a/node_modules/qs/test/parse.js
+++ b/node_modules/qs/test/parse.js
@@ -0,0 +1,147 @@
+
+if (require.register) {
+  var qs = require('querystring');
+} else {
+  var qs = require('../')
+    , expect = require('expect.js');
+}
+
+describe('qs.parse()', function(){
+  it('should support the basics', function(){
+    expect(qs.parse('0=foo')).to.eql({ '0': 'foo' });
+
+    expect(qs.parse('foo=c++'))
+      .to.eql({ foo: 'c  ' });
+
+    expect(qs.parse('a[>=]=23'))
+      .to.eql({ a: { '>=': '23' }});
+
+    expect(qs.parse('a[<=>]==23'))
+      .to.eql({ a: { '<=>': '=23' }});
+
+    expect(qs.parse('a[==]=23'))
+      .to.eql({ a: { '==': '23' }});
+
+    expect(qs.parse('foo'))
+      .to.eql({ foo: '' });
+
+    expect(qs.parse('foo=bar'))
+      .to.eql({ foo: 'bar' });
+
+    expect(qs.parse(' foo = bar = baz '))
+      .to.eql({ ' foo ': ' bar = baz ' });
+
+    expect(qs.parse('foo=bar=baz'))
+      .to.eql({ foo: 'bar=baz' });
+
+    expect(qs.parse('foo=bar&bar=baz'))
+      .to.eql({ foo: 'bar', bar: 'baz' });
+
+    expect(qs.parse('foo=bar&baz'))
+      .to.eql({ foo: 'bar', baz: '' });
+
+    expect(qs.parse('cht=p3&chd=t:60,40&chs=250x100&chl=Hello|World'))
+      .to.eql({
+          cht: 'p3'
+        , chd: 't:60,40'
+        , chs: '250x100'
+        , chl: 'Hello|World'
+      });
+  })
+
+  it('should support encoded = signs', function(){
+    expect(qs.parse('he%3Dllo=th%3Dere'))
+      .to.eql({ 'he=llo': 'th=ere' });
+  })
+
+  it('should support nesting', function(){
+    expect(qs.parse('ops[>=]=25'))
+      .to.eql({ ops: { '>=': '25' }});
+
+    expect(qs.parse('user[name]=tj'))
+      .to.eql({ user: { name: 'tj' }});
+
+    expect(qs.parse('user[name][first]=tj&user[name][last]=holowaychuk'))
+      .to.eql({ user: { name: { first: 'tj', last: 'holowaychuk' }}});
+  })
+
+  it('should support array notation', function(){
+    expect(qs.parse('images[]'))
+      .to.eql({ images: [] });
+
+    expect(qs.parse('user[]=tj'))
+      .to.eql({ user: ['tj'] });
+
+    expect(qs.parse('user[]=tj&user[]=tobi&user[]=jane'))
+      .to.eql({ user: ['tj', 'tobi', 'jane'] });
+
+    expect(qs.parse('user[names][]=tj&user[names][]=tyler'))
+      .to.eql({ user: { names: ['tj', 'tyler'] }});
+
+    expect(qs.parse('user[names][]=tj&user[names][]=tyler&user[email]=tj@vision-media.ca'))
+      .to.eql({ user: { names: ['tj', 'tyler'], email: 'tj@vision-media.ca' }});
+
+    expect(qs.parse('items=a&items=b'))
+      .to.eql({ items: ['a', 'b'] });
+
+    expect(qs.parse('user[names]=tj&user[names]=holowaychuk&user[names]=TJ'))
+      .to.eql({ user: { names: ['tj', 'holowaychuk', 'TJ'] }});
+
+    expect(qs.parse('user[name][first]=tj&user[name][first]=TJ'))
+      .to.eql({ user: { name: { first: ['tj', 'TJ'] }}});
+
+    var o = qs.parse('existing[fcbaebfecc][name][last]=tj')
+    expect(o).to.eql({ existing: { 'fcbaebfecc': { name: { last: 'tj' }}}})
+    expect(Array.isArray(o.existing)).to.equal(false);
+  })
+
+  it('should support arrays with indexes', function(){
+    expect(qs.parse('foo[0]=bar&foo[1]=baz')).to.eql({ foo: ['bar', 'baz'] });
+    expect(qs.parse('foo[1]=bar&foo[0]=baz')).to.eql({ foo: ['baz', 'bar'] });
+    expect(qs.parse('foo[base64]=RAWR')).to.eql({ foo: { base64: 'RAWR' }});
+    expect(qs.parse('foo[64base]=RAWR')).to.eql({ foo: { '64base': 'RAWR' }});
+  })
+
+  it('should expand to an array when dupliate keys are present', function(){
+    expect(qs.parse('items=bar&items=baz&items=raz'))
+      .to.eql({ items: ['bar', 'baz', 'raz'] });
+  })
+
+  it('should support right-hand side brackets', function(){
+    expect(qs.parse('pets=["tobi"]'))
+      .to.eql({ pets: '["tobi"]' });
+
+    expect(qs.parse('operators=[">=", "<="]'))
+      .to.eql({ operators: '[">=", "<="]' });
+
+    expect(qs.parse('op[>=]=[1,2,3]'))
+      .to.eql({ op: { '>=': '[1,2,3]' }});
+
+    expect(qs.parse('op[>=]=[1,2,3]&op[=]=[[[[1]]]]'))
+          .to.eql({ op: { '>=': '[1,2,3]', '=': '[[[[1]]]]' }});
+  })
+
+  it('should support empty values', function(){
+    expect(qs.parse('')).to.eql({});
+    expect(qs.parse(undefined)).to.eql({});
+    expect(qs.parse(null)).to.eql({});
+  })
+
+  it('should transform arrays to objects', function(){
+    expect(qs.parse('foo[0]=bar&foo[bad]=baz')).to.eql({ foo: { 0: "bar", bad: "baz" }});
+    expect(qs.parse('foo[bad]=baz&foo[0]=bar')).to.eql({ foo: { 0: "bar", bad: "baz" }});
+  })
+
+  it('should support malformed uri chars', function(){
+    expect(qs.parse('{%:%}')).to.eql({ '{%:%}': '' });
+    expect(qs.parse('foo=%:%}')).to.eql({ 'foo': '%:%}' });
+  })
+
+  it('should support semi-parsed strings', function(){
+    expect(qs.parse({ 'user[name]': 'tobi' }))
+      .to.eql({ user: { name: 'tobi' }});
+
+    expect(qs.parse({ 'user[name]': 'tobi', 'user[email][main]': 'tobi@lb.com' }))
+      .to.eql({ user: { name: 'tobi', email: { main: 'tobi@lb.com' } }});
+  })
+})
--- a/node_modules/qs/test/stringify.js
+++ b/node_modules/qs/test/stringify.js
@@ -0,0 +1,79 @@
+
+if (require.register) {
+  var qs = require('querystring');
+} else {
+  var qs = require('../')
+    , expect = require('expect.js');
+}
+
+var date = new Date(0);
+
+var str_identities = {
+  'basics': [
+    { str: 'foo=bar', obj: {'foo' : 'bar'}},
+    { str: 'foo=%22bar%22', obj: {'foo' : '\"bar\"'}},
+    { str: 'foo=', obj: {'foo': ''}},
+    { str: 'foo=1&bar=2', obj: {'foo' : '1', 'bar' : '2'}},
+    { str: 'my%20weird%20field=q1!2%22\'w%245%267%2Fz8)%3F', obj: {'my weird field': "q1!2\"'w$5&7/z8)?"}},
+    { str: 'foo%3Dbaz=bar', obj: {'foo=baz': 'bar'}},
+    { str: 'foo=bar&bar=baz', obj: {foo: 'bar', bar: 'baz'}}
+  ],
+  'escaping': [
+    { str: 'foo=foo%20bar', obj: {foo: 'foo bar'}},
+    { str: 'cht=p3&chd=t%3A60%2C40&chs=250x100&chl=Hello%7CWorld', obj: {
+        cht: 'p3'
+      , chd: 't:60,40'
+      , chs: '250x100'
+      , chl: 'Hello|World'
+    }}
+  ],
+  'nested': [
+    { str: 'foo[0]=bar&foo[1]=quux', obj: {'foo' : ['bar', 'quux']}},
+    { str: 'foo[0]=bar', obj: {foo: ['bar']}},
+    { str: 'foo[0]=1&foo[1]=2', obj: {'foo' : ['1', '2']}},
+    { str: 'foo=bar&baz[0]=1&baz[1]=2&baz[2]=3', obj: {'foo' : 'bar', 'baz' : ['1', '2', '3']}},
+    { str: 'foo[0]=bar&baz[0]=1&baz[1]=2&baz[2]=3', obj: {'foo' : ['bar'], 'baz' : ['1', '2', '3']}},
+    { str: 'x[y][z]=1', obj: {'x' : {'y' : {'z' : '1'}}}},
+    { str: 'x[y][z][0]=1', obj: {'x' : {'y' : {'z' : ['1']}}}},
+    { str: 'x[y][z]=2', obj: {'x' : {'y' : {'z' : '2'}}}},
+    { str: 'x[y][z][0]=1&x[y][z][1]=2', obj: {'x' : {'y' : {'z' : ['1', '2']}}}},
+    { str: 'x[y][0][z]=1', obj: {'x' : {'y' : [{'z' : '1'}]}}},
+    { str: 'x[y][0][z][0]=1', obj: {'x' : {'y' : [{'z' : ['1']}]}}},
+    { str: 'x[y][0][z]=1&x[y][0][w]=2', obj: {'x' : {'y' : [{'z' : '1', 'w' : '2'}]}}},
+    { str: 'x[y][0][v][w]=1', obj: {'x' : {'y' : [{'v' : {'w' : '1'}}]}}},
+    { str: 'x[y][0][z]=1&x[y][0][v][w]=2', obj: {'x' : {'y' : [{'z' : '1', 'v' : {'w' : '2'}}]}}},
+    { str: 'x[y][0][z]=1&x[y][1][z]=2', obj: {'x' : {'y' : [{'z' : '1'}, {'z' : '2'}]}}},
+    { str: 'x[y][0][z]=1&x[y][0][w]=a&x[y][1][z]=2&x[y][1][w]=3', obj: {'x' : {'y' : [{'z' : '1', 'w' : 'a'}, {'z' : '2', 'w' : '3'}]}}},
+    { str: 'user[name][first]=tj&user[name][last]=holowaychuk', obj: { user: { name: { first: 'tj', last: 'holowaychuk' }}}}
+  ],
+  'errors': [
+    { obj: 'foo=bar',     message: 'stringify expects an object' },
+    { obj: ['foo', 'bar'], message: 'stringify expects an object' }
+  ],
+  'numbers': [
+    { str: 'limit[0]=1&limit[1]=2&limit[2]=3', obj: { limit: [1, 2, '3'] }},
+    { str: 'limit=1', obj: { limit: 1 }}
+  ],
+  'others': [
+    { str: 'at=' + encodeURIComponent(date), obj: { at: date } }
+  ]
+};
+
+function test(type) {
+  return function(){
+    var str, obj;
+    for (var i = 0; i < str_identities[type].length; i++) {
+      str = str_identities[type][i].str;
+      obj = str_identities[type][i].obj;
+      expect(qs.stringify(obj)).to.eql(str);
+    }
+  }
+}
+
+describe('qs.stringify()', function(){
+  it('should support the basics', test('basics'))
+  it('should support escapes', test('escaping'))
+  it('should support nesting', test('nested'))
+  it('should support numbers', test('numbers'))
+  it('should support others', test('others'))
+})