first post

Nodejs-Socketio-Mysql-Demo/node_modules/mysql/test/common.js

@@ -0,0 +1,23 @@
+var mysql = require('..');
+var path = require('path');
+
+var root = path.join(__dirname, '../');
+exports.dir = {
+  root: root,
+  lib: root + '/lib',
+  fixture: root + '/test/fixture',
+};
+
+exports.TEST_DB = 'node_mysql_test';
+exports.TEST_TABLE = 'posts';
+
+exports.createClient = function() {
+  try {
+    var config = require('./config');
+  } catch (e) {
+    console.log('Skipping. See test/config.template.js for more information.');
+    process.exit(0);
+  }
+
+  return mysql.createClient(config);
+};

Nodejs-Socketio-Mysql-Demo/node_modules/mysql/test/config.template.js

@@ -0,0 +1,8 @@
+// Copy this file to test/config.js and fill in your own credentials in order
+// to run the system test suite.
+module.exports = {
+  host: 'localhost',
+  port: 3306,
+  user: 'root',
+  password: 'root'
+};

Nodejs-Socketio-Mysql-Demo/node_modules/mysql/test/fixture/columnia.sql

@@ -0,0 +1,54 @@
+CREATE TABLE `columnia` (
+  `f0` bigint(20) unsigned NOT NULL DEFAULT '0',
+  `field0001` bigint(20) unsigned NOT NULL DEFAULT '0',
+  `field002` bigint(20) unsigned NOT NULL DEFAULT '0',
+  `field0000000003` bigint(20) unsigned DEFAULT NULL,
+  `field00004` bigint(20) unsigned NOT NULL DEFAULT '0',
+  `field000000000005` bigint(20) unsigned DEFAULT NULL,
+  `field0000000000006` bigint(20) unsigned NOT NULL,
+  `field000007` text NOT NULL,
+  `field0000000008` text NOT NULL,
+  `field009` int(10) NOT NULL DEFAULT '0',
+  `field00010` text NOT NULL,
+  `field000000000011` text NOT NULL,
+  `field00000012` text NOT NULL,
+  `field0000013` text NOT NULL,
+  `field00000000000014` text NOT NULL,
+  `field0000000015` text NOT NULL,
+  `field000016` text NOT NULL,
+  `field000000000017` text NOT NULL,
+  `field0000000000000018` text NOT NULL,
+  `field0000000000019` text NOT NULL,
+  `field0000000000020` text NOT NULL,
+  `field00000000000021` text NOT NULL,
+  `field00000000022` text NOT NULL,
+  `field000000000000000023` text NOT NULL,
+  `field000000000000024` text NOT NULL,
+  `field000000000000025` text NOT NULL,
+  `field0000000000000026` text NOT NULL,
+  `field0000000000027` text NOT NULL,
+  `field00000028` bigint(20) unsigned NOT NULL,
+  `field000000029` tinyint(1) NOT NULL,
+  `field000030` tinyint(1) NOT NULL DEFAULT '0',
+  `field31` text NOT NULL,
+  `field00000032` bigint(20) unsigned NOT NULL,
+  `fi33` int(11) NOT NULL DEFAULT '0',
+  `field00000034` bigint(20) unsigned DEFAULT NULL,
+  `field000035` text NOT NULL,
+  `field0036` int(11) NOT NULL DEFAULT '0',
+  `field0000000000000000000037` text NOT NULL,
+  `field0000000000000000000038` text NOT NULL,
+  `field0000000000000000000000000039` text NOT NULL,
+  `field0000000000000000040` text NOT NULL,
+  `field00000000000000000041` text NOT NULL,
+  `field00000000000000000000042` text NOT NULL,
+  `field00000000000000000043` text NOT NULL,
+  `field00000000000000000044` text NOT NULL,
+  `field00000000000000000000000045` text NOT NULL,
+  `field00000000000000046` text NOT NULL,
+  `field000000000000000047` text NOT NULL,
+  `field000000000000000000048` text NOT NULL,
+  `field49` text NOT NULL,
+  `field50` int(11) NOT NULL,
+  PRIMARY KEY (`f0`)
+) ENGINE=MyISAM DEFAULT CHARSET=latin1

Nodejs-Socketio-Mysql-Demo/node_modules/mysql/test/fixture/libmysql_password.c

@@ -0,0 +1,127 @@
+#include <stdio.h>
+#include <string.h>
+#include <math.h>
+
+#define SCRAMBLE_LENGTH_323 8
+
+typedef unsigned long ulong;
+typedef unsigned int uint;
+typedef unsigned char uchar;
+
+struct rand_struct {
+  unsigned long seed1,seed2,max_value;
+  double max_value_dbl;
+};
+
+void hash_password(ulong *result, const char *password, uint password_len)
+{
+  register ulong nr=1345345333L, add=7, nr2=0x12345671L;
+  ulong tmp;
+  const char *password_end= password + password_len;
+  for (; password < password_end; password++)
+  {
+    if (*password == ' ' || *password == '\t')
+      continue;                                 /* skip space in password */
+    tmp= (ulong) (uchar) *password;
+    nr^= (((nr & 63)+add)*tmp)+ (nr << 8);
+    nr2+=(nr2 << 8) ^ nr;
+    add+=tmp;
+  }
+  result[0]=nr & (((ulong) 1L << 31) -1L); /* Don't use sign bit (str2int) */;
+  result[1]=nr2 & (((ulong) 1L << 31) -1L);
+}
+
+void randominit(struct rand_struct *rand_st, ulong seed1, ulong seed2)
+{                                               /* For mysql 3.21.# */
+#ifdef HAVE_purify
+  bzero((char*) rand_st,sizeof(*rand_st));      /* Avoid UMC varnings */
+#endif
+  rand_st->max_value= 0x3FFFFFFFL;
+  rand_st->max_value_dbl=(double) rand_st->max_value;
+  rand_st->seed1=seed1%rand_st->max_value ;
+  rand_st->seed2=seed2%rand_st->max_value;
+}
+
+double my_rnd(struct rand_struct *rand_st)
+{
+  rand_st->seed1=(rand_st->seed1*3+rand_st->seed2) % rand_st->max_value;
+  rand_st->seed2=(rand_st->seed1+rand_st->seed2+33) % rand_st->max_value;
+  return (((double) rand_st->seed1)/rand_st->max_value_dbl);
+}
+
+void scramble_323(char *to, const char *message, const char *password)
+{
+  struct rand_struct rand_st;
+  ulong hash_pass[2], hash_message[2];
+
+  if (password && password[0])
+  {
+    char extra, *to_start=to;
+    const char *message_end= message + SCRAMBLE_LENGTH_323;
+    hash_password(hash_pass,password, (uint) strlen(password));
+    hash_password(hash_message, message, SCRAMBLE_LENGTH_323);
+    randominit(&rand_st,hash_pass[0] ^ hash_message[0],
+               hash_pass[1] ^ hash_message[1]);
+    for (; message < message_end; message++)
+      *to++= (char) (floor(my_rnd(&rand_st)*31)+64);
+    extra=(char) (floor(my_rnd(&rand_st)*31));
+    while (to_start != to)
+      *(to_start++)^=extra;
+  }
+  *to= 0;
+}
+
+int main() {
+  const char password1[] = "root";
+  const char password2[] = "long password test";
+  const char password3[] = "saf789yasfbsd89f";
+  ulong result[2];
+  char scrm[9]; // SCRAMBLE_LENGTH_323+1
+  struct rand_struct rand_st;
+  int i;
+
+  // test hash_password
+  hash_password((ulong*)result, password1, strlen(password1));
+  printf("hash_password(\"%s\") = %08x%08x\n", password1, result[0], result[1]);
+
+  hash_password((ulong*)result, password2, strlen(password2));
+  printf("hash_password(\"%s\") = %08x%08x\n", password2, result[0], result[1]);
+
+  hash_password((ulong*)result, password3, strlen(password3));
+  printf("hash_password(\"%s\") = %08x%08x\n", password3, result[0], result[1]);
+
+
+  // test randominit
+  randominit(&rand_st, 0, 0);
+  printf("randominit(0x00000000,0x00000000) = %08x, %08x\n", rand_st.seed1, rand_st.seed2);
+
+  randominit(&rand_st, 0xFFFF, 0xFFFF);
+  printf("randominit(0x0000FFFF,0x0000FFFF) = %08x, %08x\n", rand_st.seed1, rand_st.seed2);
+
+  randominit(&rand_st, 0x50000000, 0x50000000);
+  printf("randominit(0x50000000,0x50000000) = %08x, %08x\n", rand_st.seed1, rand_st.seed2);
+
+  randominit(&rand_st, 0xFFFFFFFF, 0xFFFFFFFF);
+  printf("randominit(0xFFFFFFFF,0xFFFFFFFF) = %08x, %08x\n", rand_st.seed1, rand_st.seed2);
+
+
+  // test my_rnd
+  randominit(&rand_st, 3252345, 7149734);
+  printf("randominit(3252345, 7149734) = %08x, %08x\n", rand_st.seed1, rand_st.seed2);
+  for (i=0; i<10; i++){
+	  printf("my_rnd() : %.16f\n", my_rnd(&rand_st));
+  }
+
+
+  // test scramble_323
+  scramble_323(scrm, "8bytesofstuff", "root");
+  printf("scramble323(8bytesofstuff, root): %02x %02x %02x %02x %02x %02x %02x %02x %02x\n",
+    scrm[0], scrm[1], scrm[2], scrm[3], scrm[4], scrm[5], scrm[6], scrm[7], scrm[8]);
+
+  scramble_323(scrm, "e8cf00cec9ec825af22", "saf789yasfbsd");
+  printf("scramble323(e8cf00cec9ec825af22, saf789yasfbsd): %02x %02x %02x %02x %02x %02x %02x %02x %02x\n",
+    scrm[0], scrm[1], scrm[2], scrm[3], scrm[4], scrm[5], scrm[6], scrm[7], scrm[8]);
+
+  return 23;
+}
+

Nodejs-Socketio-Mysql-Demo/node_modules/mysql/test/integration/Client/commands/test-ping.js

@@ -0,0 +1,11 @@
+var common = require('../../../common');
+var assert = require('assert');
+
+var client = common.createClient();
+client.ping(function(err, result) {
+  if (err) throw err;
+
+  assert.strictEqual(result.affectedRows, 0);
+
+  client.end();
+});

Nodejs-Socketio-Mysql-Demo/node_modules/mysql/test/integration/Client/commands/test-statistics.js

@@ -0,0 +1,10 @@
+var common = require('../../../common');
+var assert = require('assert');
+
+var client = common.createClient();
+client.statistics(function(err, result) {
+  if (err) throw err;
+
+  assert.ok(result.extra.match(/time/i));
+  client.end();
+});

Nodejs-Socketio-Mysql-Demo/node_modules/mysql/test/integration/Client/commands/test-useDatabase.js

@@ -0,0 +1,13 @@
+var common = require('../../../common');
+var assert = require('assert');
+
+var client = common.createClient();
+client.useDatabase(common.TEST_DB, function(err, result) {
+  // The TEST_DB may not exist right now, so ignore errors related to that
+  if (err && err.number === mysql.ERROR_BAD_DB_ERROR) err = null;
+
+  if (err) throw err;
+
+  assert.strictEqual(result.affectedRows, 0);
+  client.end();
+});

Nodejs-Socketio-Mysql-Demo/node_modules/mysql/test/integration/Client/connection/test-automatic-connect.js

@@ -0,0 +1,11 @@
+var common = require('../../../common');
+var assert = require('assert');
+
+var client = common.createClient();
+client.query('SELECT 1', function(err, results) {
+  if (err) throw err;
+
+  assert.deepEqual(results, [{1: 1}]);
+
+  client.end();
+});

Nodejs-Socketio-Mysql-Demo/node_modules/mysql/test/integration/Client/connection/test-automatic-reconnect-on-timeout.js

@@ -0,0 +1,24 @@
+var common = require('../../../common');
+var assert = require('assert');
+
+var client = common.createClient();
+// Not sure if we need all 3 of these, but they do the trick
+client.query('SET interactive_timeout = 1');
+client.query('SET wait_timeout = 1');
+client.query('SET net_read_timeout = 1');
+
+var result;
+client._socket.on('end', function() {
+  assert.equal(client.connected, false);
+
+  client.query('SELECT 1', function(err, _result) {
+    if (err) throw err;
+
+    result = _result;
+    client.destroy();
+  });
+});
+
+process.on('exit', function() {
+  assert.deepEqual(result, [{'1': 1}]);
+});

Nodejs-Socketio-Mysql-Demo/node_modules/mysql/test/integration/Client/connection/test-bad-credentials.js.js

@@ -0,0 +1,24 @@
+var common = require('../../../common');
+var assert = require('assert');
+
+var client = common.createClient();
+client.password = 'thispassworddoesnotreallywork';
+
+var callbacks = [];
+client.query('SELECT 1', function(err) {
+  assert.ok(/access denied/i.test(err.message));
+
+  callbacks.push(1);
+});
+
+client.query('SELECT 2', function(err) {
+  assert.ok(/access denied/i.test(err.message));
+
+  callbacks.push(2);
+
+  client.destroy();
+});
+
+process.on('exit', function() {
+  assert.deepEqual(callbacks, [1, 2]);
+});

Nodejs-Socketio-Mysql-Demo/node_modules/mysql/test/integration/Client/connection/test-connection-errors-go-to-callback.js.js

@@ -0,0 +1,25 @@
+var common = require('../../../common');
+var assert = require('assert');
+
+var client = common.createClient();
+// Port number outside of range -> triggers connection error
+client.port = 999999999;
+
+var callbacks = [];
+client.query('SELECT 1', function(err) {
+  assert.ok(err);
+
+  callbacks.push(1);
+});
+
+client.query('SELECT 2', function(err) {
+  assert.ok(err);
+
+  callbacks.push(2);
+
+  client.destroy();
+});
+
+process.on('exit', function() {
+  assert.deepEqual(callbacks, [1, 2]);
+});

Nodejs-Socketio-Mysql-Demo/node_modules/mysql/test/integration/Client/connection/test-reconnect-closed-client.js.js

@@ -0,0 +1,27 @@
+var common = require('../../../common');
+var assert = require('assert');
+
+var client = common.createClient();
+var callbacks = [];
+client.query('SELECT 1', function(err, results) {
+  if (err) throw err;
+
+  callbacks.push(1);
+});
+
+client.end(function(err) {
+  if (err) throw err;
+
+  callbacks.push(2);
+});
+
+client.query('SELECT 1', function(err) {
+  if (err) throw err;
+
+  callbacks.push(3);
+  client.destroy();
+});
+
+process.on('exit', function() {
+  assert.deepEqual(callbacks, [1, 2, 3]);
+});

Nodejs-Socketio-Mysql-Demo/node_modules/mysql/test/integration/Query/errors/test-should-delegate-to-client-if-needed.js

@@ -0,0 +1,17 @@
+var common = require('../../../common');
+var assert = require('assert');
+var INVALID_QUERY = 'first invalid #*&% query';
+
+var client = common.createClient();
+var err;
+
+client.query(INVALID_QUERY);
+client .on('error', function(_err) {
+  err = _err;
+  client.destroy();
+});
+
+process.on('exit', function() {
+  assert.ok(err);
+  assert.strictEqual(err.sql, INVALID_QUERY);
+});

Nodejs-Socketio-Mysql-Demo/node_modules/mysql/test/integration/Query/errors/test-should-emit-error-event.js

@@ -0,0 +1,18 @@
+var common = require('../../../common');
+var assert = require('assert');
+var INVALID_QUERY = 'first invalid #*&% query';
+
+var client = common.createClient();
+var err;
+
+client
+  .query(INVALID_QUERY)
+  .on('error', function(_err) {
+    err = _err;
+    client.destroy();
+  });
+
+process.on('exit', function() {
+  assert.ok(err);
+  assert.strictEqual(err.sql, INVALID_QUERY);
+});

Nodejs-Socketio-Mysql-Demo/node_modules/mysql/test/integration/Query/errors/test-should-not-leave-client-in-broken-state.js

@@ -0,0 +1,37 @@
+var common = require('../../../common');
+var assert = require('assert');
+var INVALID_QUERY = 'first invalid #*&% query';
+
+var client    = common.createClient();
+var callbacks = [];
+
+client.query(INVALID_QUERY, function(err) {
+  assert.strictEqual(err.sql, INVALID_QUERY);
+  callbacks.push(1);
+});
+
+client.query('SHOW STATUS', function(err, rows, fields) {
+  if (err) throw err;
+
+  assert.equal(rows.length >= 50, true);
+  assert.equal(Object.keys(fields).length, 2);
+
+  callbacks.push(2);
+});
+
+client.query(INVALID_QUERY, function(err) {
+  assert.strictEqual(err.sql, INVALID_QUERY);
+
+  callbacks.push(3);
+});
+
+client.query(INVALID_QUERY, function(err) {
+  assert.strictEqual(err.sql, INVALID_QUERY);
+
+  client.destroy();
+  callbacks.push(4);
+});
+
+process.on('exit', function() {
+  assert.deepEqual(callbacks, [1, 2, 3, 4]);
+});

Nodejs-Socketio-Mysql-Demo/node_modules/mysql/test/integration/Query/errors/test-should-raise-callback.js

@@ -0,0 +1,16 @@
+var common = require('../../../common');
+var assert = require('assert');
+var INVALID_QUERY = 'first invalid #*&% query';
+
+var client = common.createClient();
+
+var err;
+client.query(INVALID_QUERY, function(_err) {
+  err = _err;
+  client.destroy();
+});
+
+process.on('exit', function() {
+  assert.ok(err);
+  assert.strictEqual(err.sql, INVALID_QUERY);
+});

Nodejs-Socketio-Mysql-Demo/node_modules/mysql/test/integration/Query/misc/test-column-ordering.js

@@ -0,0 +1,36 @@
+var common  = require('../../../common');
+var assert  = require('assert');
+var fs      = require('fs');
+var mysql   = require(common.dir.root);
+var REPEATS = 500;
+
+var client = common.createClient();
+client.query('CREATE DATABASE ' + common.TEST_DB, function(err) {
+  if (err && err.number != mysql.ERROR_DB_CREATE_EXISTS) throw err;
+});
+client.query('USE ' + common.TEST_DB);
+
+client.query('DROP TABLE IF EXISTS columnia');
+var fixture = fs.readFileSync(common.dir.fixture + '/columnia.sql', 'utf8');
+client.query(fixture);
+
+var finished = 0;
+var self = this;
+for (var i = 0; i < REPEATS; i++) {
+  (function(i) {
+    var query = client.query("SHOW COLUMNS FROM columnia");
+
+    query.on('row', function(row) {
+      if (!row.Type) throw new Error('Column order mixed up after '+i+' queries.');
+    });
+
+    query.on('end', function() {
+      finished++;
+      if (finished === REPEATS) client.destroy();
+    });
+  })(i);
+}
+
+process.on('exit', function() {
+  assert.equal(finished, REPEATS);
+});

Nodejs-Socketio-Mysql-Demo/node_modules/mysql/test/integration/Query/results/test-empty-string.js

@@ -0,0 +1,14 @@
+var common = require('../../../common');
+var assert = require('assert');
+
+var client = common.createClient();
+var results;
+client.query('SELECT "" as field_a', function(err, _results) {
+  if (err) throw err;
+  results = _results;
+  client.destroy();
+});
+
+process.on('exit', function() {
+  assert.strictEqual(results[0].field_a, "");
+});

Nodejs-Socketio-Mysql-Demo/node_modules/mysql/test/integration/Query/results/test-long-fields.js

@@ -0,0 +1,43 @@
+var common = require('../../../common');
+var assert = require('assert');
+
+var client    = common.createClient();
+var field_a   = makeString(250);
+var field_b   = makeString(251);
+var field_c   = makeString(512);
+var field_d   = makeString(65537);
+var callbacks = 0;
+
+// We execute this test twice to be sure the parser is in a good state after
+// each run.
+test();
+test(true);
+
+function test(last) {
+  var sql    = 'SELECT ? as field_a, ? as field_b, ? as field_c, ? as field_d';
+  var params = [field_a, field_b, field_c, field_d];
+
+  var query = client.query(sql, params, function(err, results) {
+    if (err) throw err;
+
+    assert.equal(results[0].field_a, field_a);
+    assert.equal(results[0].field_b, field_b);
+    assert.equal(results[0].field_c, field_c);
+    assert.equal(results[0].field_d, field_d);
+
+    callbacks++;
+    if (last) client.destroy();
+  });
+}
+
+function makeString(length) {
+  var str = '';
+  for (var i = 0; i < length; i++) {
+    str += 'x';
+  }
+  return str;
+
+}
+process.on('exit', function() {
+  assert.equal(callbacks, 2);
+});

Nodejs-Socketio-Mysql-Demo/node_modules/mysql/test/integration/Query/results/test-null-value.js

@@ -0,0 +1,15 @@
+var common = require('../../../common');
+var assert = require('assert');
+
+var client = common.createClient();
+var results;
+client.query('SELECT NULL as field_a, NULL as field_b', function(err, _results) {
+  if (err) throw err;
+  results = _results;
+  client.destroy();
+});
+
+process.on('exit', function() {
+  assert.strictEqual(results[0].field_a, null);
+  assert.strictEqual(results[0].field_b, null);
+});

Nodejs-Socketio-Mysql-Demo/node_modules/mysql/test/integration/Query/results/test-real-world-usage.js

@@ -0,0 +1,51 @@
+var common = require('../../../common');
+var assert = require('assert');
+var mysql  = require(common.dir.root);
+
+var client = common.createClient();
+client.query('CREATE DATABASE '+common.TEST_DB, function createDbCb(err) {
+  if (err && err.number != mysql.ERROR_DB_CREATE_EXISTS) done(err);
+});
+
+client.query('USE '+common.TEST_DB);
+
+client.query(
+  'CREATE TEMPORARY TABLE ' + common.TEST_TABLE+
+  '(id INT(11) AUTO_INCREMENT, title VARCHAR(255), text TEXT, created DATETIME, PRIMARY KEY (id));'
+);
+
+client.query(
+  'INSERT INTO ' + common.TEST_TABLE + ' '+
+  'SET title = ?, text = ?, created = ?',
+  ['super cool', 'this is a nice long text', '2010-08-16 10:00:23']
+);
+
+var query = client.query(
+  'INSERT INTO '+common.TEST_TABLE+' '+
+  'SET title = ?, text = ?, created = ?',
+  ['another entry', 'because 2 entries make a better test', null]
+);
+
+var endCalled = false;
+query.on('end', function insertOkCb(packet) {
+  endCalled = true;
+});
+
+var lastQueryReached = false;
+var query = client.query('SELECT * FROM '+common.TEST_TABLE, function selectCb(err, results, fields) {
+  assert.ok(endCalled);
+
+  lastQueryReached = true;
+
+  assert.equal(results.length, 2);
+  assert.equal(results[1].title, 'another entry');
+  assert.ok(typeof results[1].id == 'number');
+  assert.ok(results[0].created instanceof Date);
+  assert.strictEqual(results[1].created, null);
+
+  client.destroy();
+});
+
+process.on('exit', function() {
+  assert.ok(lastQueryReached);
+});

Nodejs-Socketio-Mysql-Demo/node_modules/mysql/test/integration/Query/results/test-virtual-fields.js

@@ -0,0 +1,16 @@
+var common = require('../../../common');
+var assert = require('assert');
+
+var client = common.createClient();
+var results;
+client.query('SELECT 1 as field_a, 2 as field_b', function(err, _results) {
+  if (err) throw err;
+
+  results = _results;
+  client.destroy();
+});
+
+process.on('exit', function() {
+  assert.equal(results[0].field_a, 1);
+  assert.equal(results[0].field_b, 2);
+});

Nodejs-Socketio-Mysql-Demo/node_modules/mysql/test/run.js

@@ -0,0 +1 @@
+require('urun')(__dirname)

Nodejs-Socketio-Mysql-Demo/node_modules/mysql/test/unit/legacy/common.js

@@ -0,0 +1,25 @@
+var newCommon = require('../../common');
+exports.dir = newCommon.dir;
+
+var path = require('path');
+var util = require('util');
+
+global.TEST_DB = 'node_mysql_test';
+global.TEST_TABLE = 'posts';
+global.TEST_FIXTURES = path.join(__dirname, '../fixture');
+
+global.Gently = require('gently');
+global.assert = require('assert');
+global.p = function(val) {
+  util.error(util.inspect(val));
+};
+
+global.GENTLY = new Gently();
+global.HIJACKED = GENTLY.hijacked;
+
+// Stupid new feature in node that complains about gently attaching too many
+// listeners to process 'exit'. This is a workaround until I can think of a
+// better way to deal with this.
+if (process.setMaxListeners) {
+  process.setMaxListeners(Infinity);
+}

Nodejs-Socketio-Mysql-Demo/node_modules/mysql/test/unit/legacy/test-auth.js

@@ -0,0 +1,118 @@
+var common = require('./common');
+var auth = require(common.dir.lib + '/auth');
+
+function test(test) {
+  gently = new Gently();
+  test();
+  gently.verify(test.name);
+}
+
+test(function sha1() {
+  assert.deepEqual(
+    auth.sha1('root'),
+    new Buffer([
+      220, 118, 233, 240, 192,
+      0, 110, 143, 145, 158,
+      12, 81, 92, 102, 219,
+      186, 57, 130, 247, 133
+    ]).toString('binary')
+  );
+});
+
+test(function xor() {
+  var a = new Buffer([170, 220]),        // 10101010 11011100
+      b = new Buffer([220, 170]),        // 11011100 10101010
+      expected = new Buffer([118, 118]); // 01110110 01110110
+
+  assert.deepEqual(auth.xor(a.toString('binary'), b.toString('binary')), expected);
+});
+
+test(function token() {
+  var SCRAMBLE = new Buffer([0, 1, 2, 3, 4, 5]);
+
+  (function testRegular() {
+    var PASS = 'root',
+        STAGE_1 = auth.sha1(PASS),
+        TOKEN = auth.xor(
+          auth.sha1(new Buffer(SCRAMBLE + auth.sha1(STAGE_1), 'binary')),
+          STAGE_1
+         );
+
+    assert.deepEqual(auth.token('root', SCRAMBLE), TOKEN);
+  })();
+
+  (function testNoPassword() {
+    assert.deepEqual(auth.token(null, SCRAMBLE), new Buffer(0));
+  })();
+});
+
+test(function hashPassword() {
+  function verify(password, bytes){
+    var expected = new Buffer(bytes);
+    var actual = auth.hashPassword(password);
+
+    assert.deepEqual(actual, expected);
+  }
+
+  verify('root', [0x67, 0x45, 0x7E, 0x22, 0x6a, 0x1a, 0x15, 0xbd]);
+  verify('long password test', [0x6c, 0x24, 0x68, 0x41, 0x2c, 0xa6, 0x86, 0x56]);
+  verify('saf789yasfbsd89f', [0x6c, 0x9b, 0x2f, 0x07, 0x17, 0xeb, 0x95, 0xc6]);
+});
+
+
+test(function randomInit() {
+  function verify(in1, in2, out1, out2){
+    var r = auth.randomInit(in1, in2);
+    assert.equal(out1, r.seed1);
+    assert.equal(out2, r.seed2);
+  }
+
+  verify(0x00000000, 0x00000000, 0x00000000, 0x00000000);
+  verify(0x0000FFFF, 0x0000FFFF, 0x0000ffff, 0x0000ffff);
+  verify(0x50000000, 0x50000000, 0x10000001, 0x10000001);
+  verify(0xFFFFFFFF, 0xFFFFFFFF, 0x00000003, 0x00000003);
+  verify(3252345, 7149734, 0x0031a079, 0x006d18a6);
+});
+
+test(function myRnd() {
+  function verifySequence(seed1, seed2, expected){
+    var r = auth.randomInit(seed1, seed2);
+    for (var i = 0; i < expected.length; i++){
+      var n = auth.myRnd(r);
+
+      // we will test to 14 digits, since
+      // we only ever use this function mutliplied
+      // by small numbers anyway
+
+      var a = ':'+n;
+      var b = ':'+expected[i];
+
+      assert.equal(a.substr(1, 16), b.substr(1, 16));
+    }
+  }
+
+  verifySequence(3252345, 7149734, [
+    0.0157456556481734,
+    0.0696413620092360,
+    0.3009698738353047,
+    0.2959253138824602,
+    0.5767169786400320,
+    0.9958089822864243,
+    0.2488940062456708,
+    0.2570431151027261,
+    0.5385335875102631,
+    0.9215386229767824,
+  ]);
+});
+
+test(function scramble323() {
+  function verify(message, password, bytes){
+    var expected = new Buffer(bytes);
+    var actual = auth.scramble323(new Buffer(message), password);
+
+    assert.deepEqual(actual, expected);
+  }
+
+  verify('8bytesofstuff', 'root', [0x5a, 0x4d, 0x46, 0x47, 0x43, 0x53, 0x58, 0x5f]);
+  verify('e8cf00cec9ec825af22', 'saf789yasfbsd', [0x4d, 0x54, 0x5b, 0x47, 0x5f, 0x52, 0x4d, 0x45]);
+});

Nodejs-Socketio-Mysql-Demo/node_modules/mysql/test/unit/legacy/test-client.js

@@ -0,0 +1,95 @@
+var common = require('./common');
+var Parser = require(common.dir.lib + '/parser');
+var constants = require(common.dir.lib + '/constants');
+var Client = require(common.dir.lib + '/client');
+
+function test(test) {
+  client = new Client();
+  gently = new Gently();
+  test();
+  gently.verify(test.name);
+};
+
+test(function write() {
+  var PACKET = {buffer: []},
+      CONNECTION = client._socket = {};
+
+  gently.expect(CONNECTION, 'write', function(buffer) {
+    assert.strictEqual(buffer, PACKET.buffer);
+  });
+
+  client.write(PACKET);
+});
+
+test(function format() {
+  var sql = client.format('? + ? = ?', [1, 2, 'great']);
+  assert.equal(sql, '1 + 2 = \'great\'');
+
+  assert.throws(function() {
+    var sql = client.format('? + ? = ?', [1, 2]);
+  });
+
+  assert.throws(function() {
+    var sql = client.format('? + ? = ?', [1, 2, 3, 4]);
+  });
+});
+
+test(function escape() {
+  assert.equal(client.escape(undefined), 'NULL');
+  assert.equal(client.escape(null), 'NULL');
+  assert.equal(client.escape(false), 'false');
+  assert.equal(client.escape(true), 'true');
+  assert.equal(client.escape(5), '5');
+  assert.equal(client.escape({foo:'bar'}), "'[object Object]'");
+  assert.equal(client.escape([1,2,3]), "'1','2','3'");
+  assert.equal(client.escape(new Date(Date.UTC(2011,6,6,6,6,6,6))), "'2011-07-06T06:06:06.006Z'");
+
+  assert.equal(client.escape('Super'), "'Super'");
+  assert.equal(client.escape('Sup\0er'), "'Sup\\0er'");
+  assert.equal(client.escape('Sup\ber'), "'Sup\\ber'");
+  assert.equal(client.escape('Sup\ner'), "'Sup\\ner'");
+  assert.equal(client.escape('Sup\rer'), "'Sup\\rer'");
+  assert.equal(client.escape('Sup\ter'), "'Sup\\ter'");
+  assert.equal(client.escape('Sup\\er'), "'Sup\\\\er'");
+  assert.equal(client.escape('Sup\u001aer'), "'Sup\\Zer'");
+  assert.equal(client.escape('Sup\'er'), "'Sup\\'er'");
+  assert.equal(client.escape('Sup"er'), "'Sup\\\"er'");
+});
+
+test(function _packetToUserObject() {
+  (function testOkPacket() {
+    var PACKET = {
+      type: Parser.OK_PACKET,
+      length: 65,
+      received: 65,
+      number: 92,
+      foo: 'bar'
+    };
+
+    var ok = Client._packetToUserObject(PACKET);
+
+    assert.notStrictEqual(PACKET, ok);
+    assert.ok(!(ok instanceof Error));
+    assert.equal(ok.foo, PACKET.foo);
+    assert.equal(ok.type, undefined);
+    assert.equal(ok.length, undefined);
+    assert.equal(ok.received, undefined);
+  })();
+
+  (function testErrorPacket() {
+    var PACKET = {
+      type: Parser.ERROR_PACKET,
+      foo: 'bar',
+      errorMessage: 'oh no',
+      errorNumber: 1007
+    };
+
+    var err = Client._packetToUserObject(PACKET);
+
+    assert.ok(err instanceof Error);
+    assert.equal(err.message, 'oh no');
+    assert.equal(err.errorMessage, undefined);
+    assert.equal(err.number, 1007);
+    assert.equal(err.errorNumber, undefined);
+  })();
+});

Nodejs-Socketio-Mysql-Demo/node_modules/mysql/test/unit/legacy/test-outgoing-packet.js

@@ -0,0 +1,134 @@
+var common = require('./common');
+var OutgoingPacket = require(common.dir.lib + '/outgoing_packet'),
+    Buffer = require('buffer').Buffer;
+
+function test(test) {
+  gently = new Gently();
+  test();
+  gently.verify(test.name);
+}
+
+test(function constructor() {
+  var packet = new OutgoingPacket(10, 5);
+  assert.equal(packet.buffer.length, 14);
+  assert.deepEqual(
+    packet.buffer.slice(0, 3),
+    new Buffer([10, 0, 0])
+  );
+  assert.equal(packet.buffer[3], 5);
+  assert.equal(packet.index, 4);
+});
+
+test(function writeNumber() {
+  var packet = new OutgoingPacket(4);
+  packet.writeNumber(4, 257);
+  assert.deepEqual(
+    packet.buffer.slice(4, 8),
+    new Buffer([1, 1, 0, 0])
+  );
+});
+
+test(function writeFiller() {
+  var packet = new OutgoingPacket(5);
+  packet.writeFiller(5);
+  assert.equal(packet.index, 9);
+  assert.deepEqual(
+    packet.buffer.slice(4, 9),
+    new Buffer([0, 0, 0, 0, 0])
+  );
+});
+
+test(function write() {
+  (function testBuffer() {
+    var packet = new OutgoingPacket(3),
+        BUFFER = new Buffer([1, 2, 3]);
+
+    packet.write(BUFFER);
+    assert.equal(packet.index, 7);
+    assert.deepEqual(packet.buffer.slice(4, 7), BUFFER);
+  })();
+
+  (function testString() {
+    var packet = new OutgoingPacket(3),
+        STRING = 'abc';
+
+    packet.write(STRING);
+    assert.equal(packet.index, 7);
+    assert.equal(packet.buffer.slice(4, 7).toString(), STRING);
+  })();
+});
+
+test(function writeNullTerminated() {
+  var packet = new OutgoingPacket(4),
+      BUFFER = new Buffer([17, 23, 42]);
+
+  packet.buffer[7] = 100; // set last byte to non-0
+
+  gently.expect(packet, 'write', function(buffer) {
+    assert.strictEqual(buffer, BUFFER);
+    this.index += buffer.length;
+  });
+
+  packet.writeNullTerminated(BUFFER);
+  assert.equal(packet.buffer[7], 0);
+  assert.equal(packet.index, 8);
+});
+
+test(function writeLengthCoded() {
+  (function test1ByteNumber() {
+    var packet = new OutgoingPacket(1);
+    packet.writeLengthCoded(250);
+    assert.equal(packet.buffer[4], 250);
+    assert.equal(packet.index, 5);
+  })();
+
+  (function test2ByteNumber() {
+    var packet = new OutgoingPacket(6);
+    packet.writeLengthCoded(251);
+    assert.equal(packet.buffer[4], 252);
+    assert.equal(packet.buffer[5], 251);
+    assert.equal(packet.buffer[6], 0);
+    assert.equal(packet.index, 7);
+
+    packet.writeLengthCoded(257);
+    assert.equal(packet.buffer[7], 252);
+    assert.equal(packet.buffer[8], 1);
+    assert.equal(packet.buffer[9], 1);
+    assert.equal(packet.index, 10);
+  })();
+
+  (function test3ByteNumber() {
+    var packet = new OutgoingPacket(4);
+    packet.writeLengthCoded(Math.pow(256, 0) * 5 + Math.pow(256, 1) * 6 + Math.pow(256, 2) * 7);
+    assert.equal(packet.buffer[4], 253);
+    assert.equal(packet.buffer[5], 5);
+    assert.equal(packet.buffer[6], 6);
+    assert.equal(packet.buffer[7], 7);
+    assert.equal(packet.index, 8);
+  })();
+
+  (function testNull() {
+    var packet = new OutgoingPacket(1);
+    packet.writeLengthCoded(null);
+    assert.equal(packet.buffer[4], 251);
+    assert.equal(packet.index, 5);
+  })();
+
+  (function testBuffer() {
+    var packet = new OutgoingPacket(4),
+        BUFFER = new Buffer([17, 23, 42]);
+
+    packet.writeLengthCoded(BUFFER);
+    assert.equal(packet.buffer[4], 3);
+    assert.deepEqual(packet.buffer.slice(5, 8), BUFFER);
+  })();
+
+  (function testString() {
+    var packet = new OutgoingPacket(6),
+        STRING = 'über';
+
+    packet.writeLengthCoded(STRING);
+    assert.equal(packet.buffer[4], 5);
+    assert.equal(packet.buffer.slice(5, 10).toString(), STRING);
+  })();
+});

Nodejs-Socketio-Mysql-Demo/node_modules/mysql/test/unit/legacy/test-parser.js

@@ -0,0 +1,387 @@
+var common = require('./common');
+var EventEmitter = require('events').EventEmitter,
+    Parser = require(common.dir.lib + '/parser'),
+    parser,
+    gently;
+
+function test(test) {
+  parser = new Parser();
+  gently = new Gently();
+  test();
+  gently.verify(test.name);
+}
+
+test(function constructor() {
+  assert.strictEqual(parser.state, Parser.PACKET_LENGTH);
+  assert.strictEqual(parser.packet, null);
+  assert.strictEqual(parser.greeted, false);
+  assert.strictEqual(parser.authenticated, false);
+  assert.strictEqual(parser.receivingFieldPackets, false);
+  assert.strictEqual(parser.receivingRowPackets, false);
+  assert.strictEqual(parser._lengthCodedLength, null);
+  assert.strictEqual(parser._lengthCodedStringLength, null);
+  assert.ok(parser instanceof EventEmitter);
+});
+
+test(function write() {
+  var packet;
+  (function testPacketLength() {
+    var LENGTH = 56;
+    parser.write(new Buffer([LENGTH]));
+
+    assert.equal(parser.state, Parser.PACKET_LENGTH);
+
+    packet = parser.packet;
+
+    assert.ok(packet instanceof EventEmitter);
+    assert.strictEqual(packet.number, 0);
+    assert.strictEqual(packet.length, LENGTH);
+
+    parser.write(new Buffer([0]));
+    parser.write(new Buffer([0]));
+    assert.strictEqual(
+      packet.length,
+      Math.pow(256, 0) * LENGTH + Math.pow(256, 1) * 0 + Math.pow(256, 2) * 0
+    );
+  })();
+
+  (function testPacketNumber() {
+    parser.write(new Buffer([42]));
+    assert.strictEqual(packet.number, 42);
+    assert.equal(parser.state, Parser.GREETING_PROTOCOL_VERSION);
+  })();
+
+  (function testGreetingErrorPacket() {
+    parser.write(new Buffer([0xff]));
+    assert.equal(packet.type, Parser.ERROR_PACKET);
+    assert.equal(parser.state, Parser.ERROR_NUMBER);
+
+    parser.write(new Buffer([5, 2]));
+    assert.equal(packet.errorNumber, Math.pow(256, 0) * 5 + Math.pow(256, 1) * 2);
+
+    parser.write(new Buffer('Hello World'));
+    assert.equal(packet.errorMessage, 'Hello World');
+
+    // Reset back to previous state
+    packet.type = Parser.GREETING_PACKET;
+    packet.received = 0;
+    parser.state = Parser.GREETING_PROTOCOL_VERSION;
+  })();
+
+  (function testGreetingPacket() {
+    parser.write(new Buffer([15]));
+    assert.equal(packet.type, Parser.GREETING_PACKET);
+    assert.equal(packet.protocolVersion, 15);
+    assert.equal(parser.state, Parser.GREETING_SERVER_VERSION);
+
+    var VERSION = 'MySql 5.1';
+    parser.write(new Buffer(VERSION+'\0', 'binary'));
+    assert.equal(packet.serverVersion, VERSION);
+    assert.equal(parser.state, Parser.GREETING_THREAD_ID);
+
+    parser.write(new Buffer([0, 0, 0, 1]));
+    assert.equal(packet.threadId, Math.pow(256, 3));
+
+    parser.write(new Buffer([1]));
+    assert.equal(packet.scrambleBuffer[0], 1);
+    assert.equal(packet.scrambleBuffer.length, 8 + 12);
+    assert.equal(parser.state, Parser.GREETING_SCRAMBLE_BUFF_1);
+
+    parser.write(new Buffer([2, 3, 4, 5, 6, 7, 8]));
+    assert.deepEqual(
+      packet.scrambleBuffer.slice(0, 8),
+      new Buffer([1, 2, 3, 4, 5, 6, 7, 8])
+    );
+    assert.equal(parser.state, Parser.GREETING_FILLER_1);
+
+    parser.write(new Buffer([0]));
+    assert.equal(parser.state, Parser.GREETING_SERVER_CAPABILITIES);
+
+    parser.write(new Buffer([0, 1]));
+    assert.equal(packet.serverCapabilities, Math.pow(256, 1));
+
+    parser.write(new Buffer([17]));
+    assert.equal(packet.serverLanguage, 17);
+    assert.equal(parser.state, Parser.GREETING_SERVER_STATUS);
+
+    parser.write(new Buffer([0, 1]));
+    assert.equal(packet.serverStatus, Math.pow(256, 1));
+
+    parser.write(new Buffer([0]));
+    assert.equal(parser.state, Parser.GREETING_FILLER_2);
+    parser.write(new Buffer(12));
+    assert.equal(parser.state, Parser.GREETING_SCRAMBLE_BUFF_2);
+
+    parser.write(new Buffer([9]));
+    assert.equal(packet.scrambleBuffer[8], 9);
+    assert.equal(parser.state, Parser.GREETING_SCRAMBLE_BUFF_2);
+
+    gently.expect(parser, 'emit', function(event, val) {
+      assert.equal(event, 'packet');
+      assert.ok(!('index' in val));
+      assert.strictEqual(val, packet);
+      assert.equal(parser.state, Parser.PACKET_LENGTH);
+      assert.equal(parser.greeted, true);
+    });
+
+    parser.write(new Buffer([10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 0]));
+    assert.deepEqual(
+      packet.scrambleBuffer.slice(9, 20),
+      new Buffer([10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20])
+    );
+    assert.strictEqual(parser.packet, null);
+  })();
+
+  (function testUseOldPasswordProtocolPacket() {
+    parser.write(new Buffer([1, 0, 0, 1]));
+
+    gently.expect(parser, 'emit', function(event, val) {
+      assert.equal(event, 'packet');
+      assert.equal(val.type, Parser.USE_OLD_PASSWORD_PROTOCOL_PACKET);
+    });
+
+    parser.write(new Buffer([254]));
+  })();
+
+
+  (function testErrorPacket() {
+    parser.write(new Buffer([12, 0, 0, 1]));
+    assert.equal(parser.state, Parser.FIELD_COUNT);
+    var packet = parser.packet;
+
+    parser.write(new Buffer([0xff]));
+    assert.equal(packet.type, Parser.ERROR_PACKET);
+    assert.equal(parser.state, Parser.ERROR_NUMBER);
+
+    parser.write(new Buffer([5, 2]));
+    assert.equal(packet.errorNumber, Math.pow(256, 0) * 5 + Math.pow(256, 1) * 2);
+
+    parser.write(new Buffer('#'));
+    assert.equal(packet.sqlStateMarker, '#');
+    assert.equal(parser.state, Parser.ERROR_SQL_STATE);
+
+    parser.write(new Buffer('abcde'));
+    assert.equal(packet.sqlState, 'abcde');
+
+    parser.write(new Buffer('er'));
+    assert.equal(parser.state, Parser.ERROR_MESSAGE);
+    assert.equal(packet.errorMessage, 'er');
+
+    gently.expect(parser, 'emit', function(event, val) {
+      assert.equal(event, 'packet');
+      assert.equal(packet.errorMessage, 'err');
+    });
+
+    parser.write(new Buffer('r'));
+  })();
+
+  (function testOkPacket() {
+    parser.write(new Buffer([15, 0, 0, 1]));
+    var packet = parser.packet;
+
+    parser.write(new Buffer([0x00]));
+    assert.equal(packet.type, Parser.OK_PACKET);
+    assert.equal(parser.authenticated, true);
+    assert.equal(parser.state, Parser.AFFECTED_ROWS);
+
+    parser.write(new Buffer([252, 17, 23]));
+    assert.equal(packet.affectedRows, Math.pow(256, 0) * 17 + Math.pow(256, 1) * 23);
+
+    parser.write(new Buffer([240]));
+    assert.equal(packet.insertId, 240);
+
+    parser.write(new Buffer([42, 113]));
+    assert.equal(packet.serverStatus, Math.pow(256, 0) * 42 + Math.pow(256, 1) * 113);
+
+    parser.write(new Buffer([32, 153]));
+    assert.equal(packet.warningCount, Math.pow(256, 0) * 32 + Math.pow(256, 1) * 153);
+
+    assert.strictEqual(packet.message, '');
+
+    gently.expect(parser, 'emit', function(event, val) {
+      assert.equal(event, 'packet');
+      assert.equal(packet.message, 'abcdef');
+    });
+
+    parser.write(new Buffer('abcdef'));
+  })();
+
+  (function testResultHeaderPacket() {
+    parser.write(new Buffer([1, 0, 0, 1]));
+    var packet = parser.packet;
+
+    gently.expect(parser, 'emit', function(event, val) {
+      assert.equal(event, 'packet');
+      assert.equal(val.type, Parser.RESULT_SET_HEADER_PACKET);
+      assert.equal(val.fieldCount, 5);
+    });
+
+    parser.write(new Buffer([5]));
+  })();
+
+  (function testResultHeaderPacketWithExtra() {
+    parser.receivingFieldPackets = false;
+
+    parser.write(new Buffer([5, 0, 0, 1]));
+    var packet = parser.packet;
+
+    parser.write(new Buffer([23]));
+    assert.equal(parser.state, Parser.EXTRA_LENGTH);
+    assert.equal(packet.fieldCount, 23);
+
+    parser.write(new Buffer([3]));
+
+    gently.expect(parser, 'emit', function(event, val) {
+      assert.equal(event, 'packet');
+      assert.equal(val.type, Parser.RESULT_SET_HEADER_PACKET);
+      assert.equal(val.extra, 'abc');
+    });
+
+    parser.write(new Buffer('abc'));
+  })();
+
+  (function testFieldPacket() {
+    parser.write(new Buffer([43, 0, 0, 1]));
+    var packet = parser.packet;
+
+    assert.equal(parser.state, Parser.FIELD_CATALOG_LENGTH);
+    parser.write(new Buffer([3]));
+    assert.equal(packet.type, Parser.FIELD_PACKET);
+    parser.write(new Buffer('abc'));
+    assert.equal(packet.catalog, 'abc');
+
+    assert.equal(parser.state, Parser.FIELD_DB_LENGTH);
+    parser.write(new Buffer([5]));
+    parser.write(new Buffer('hello'));
+    assert.equal(packet.db, 'hello');
+
+    assert.equal(parser.state, Parser.FIELD_TABLE_LENGTH);
+    parser.write(new Buffer([2]));
+    parser.write(new Buffer('ab'));
+    assert.equal(packet.table, 'ab');
+
+    assert.equal(parser.state, Parser.FIELD_ORIGINAL_TABLE_LENGTH);
+    parser.write(new Buffer([4]));
+    parser.write(new Buffer('1234'));
+    assert.equal(packet.originalTable, '1234');
+
+    assert.equal(parser.state, Parser.FIELD_NAME_LENGTH);
+    parser.write(new Buffer([1]));
+    parser.write(new Buffer('o'));
+    assert.equal(packet.name, 'o');
+
+    assert.equal(parser.state, Parser.FIELD_ORIGINAL_NAME_LENGTH);
+    parser.write(new Buffer([9]));
+    parser.write(new Buffer('wonderful'));
+    assert.equal(packet.originalName, 'wonderful');
+
+    assert.equal(parser.state, Parser.FIELD_FILLER_1);
+    parser.write(new Buffer([0]));
+
+    assert.equal(parser.state, Parser.FIELD_CHARSET_NR);
+    parser.write(new Buffer([42, 113]));
+    assert.equal(packet.charsetNumber, Math.pow(256, 0) * 42 + Math.pow(256, 1) * 113);
+
+    assert.equal(parser.state, Parser.FIELD_LENGTH);
+    parser.write(new Buffer([42, 113, 50, 30]));
+    assert.equal(packet.fieldLength, 42 + (256 * 113) + (256 * 256) * 50 + (256 * 256 * 256 * 30));
+
+    assert.equal(parser.state, Parser.FIELD_TYPE);
+    parser.write(new Buffer([58]));
+    assert.equal(packet.fieldType, 58);
+
+    assert.equal(parser.state, Parser.FIELD_FLAGS);
+    parser.write(new Buffer([42, 113]));
+    assert.equal(packet.flags, Math.pow(256, 0) * 42 + Math.pow(256, 1) * 113);
+
+    assert.equal(parser.state, Parser.FIELD_DECIMALS);
+    parser.write(new Buffer([58]));
+    assert.equal(packet.decimals, 58);
+
+    gently.expect(parser, 'emit', function(event, val) {
+      assert.equal(event, 'packet');
+    });
+
+    assert.equal(parser.state, Parser.FIELD_FILLER_2);
+    parser.write(new Buffer([0, 0]));
+  })();
+
+  (function testEofPacket() {
+    parser.write(new Buffer([5, 0, 0, 1]));
+    var packet = parser.packet;
+
+    parser.write(new Buffer([0xfe]));
+    assert.equal(packet.type, Parser.EOF_PACKET);
+
+    assert.equal(parser.state, Parser.EOF_WARNING_COUNT);
+    parser.write(new Buffer([42, 113]));
+    assert.equal(packet.warningCount, Math.pow(256, 0) * 42 + Math.pow(256, 1) * 113);
+
+    gently.expect(parser, 'emit', function(event, val) {
+      assert.equal(event, 'packet');
+      assert.equal(parser.receivingFieldPackets, false);
+      assert.equal(parser.receivingRowPackets, true);
+    });
+
+    assert.equal(parser.state, Parser.EOF_SERVER_STATUS);
+    parser.write(new Buffer([42, 113]));
+    assert.equal(packet.serverStatus, Math.pow(256, 0) * 42 + Math.pow(256, 1) * 113);
+  })();
+
+  (function testRowPacket() {
+    parser.write(new Buffer([23, 0, 0, 1]));
+    var packet = parser.packet;
+
+    gently.expect(parser, 'emit', function(event, val) {
+      assert.equal(event, 'packet');
+    });
+
+    parser.write(new Buffer([16]));
+    assert.equal(parser.state, Parser.COLUMN_VALUE_STRING);
+    assert.equal(packet.type, Parser.ROW_DATA_PACKET);
+    assert.equal(packet.columnLength, 16);
+
+    gently.expect(packet, 'emit', function(event, val, remaining) {
+      assert.equal(event, 'data');
+      assert.equal(val.toString(), 'hi, ');
+      assert.equal(remaining, 12);
+    });
+
+    parser.write(new Buffer('hi, '));
+
+    gently.expect(packet, 'emit', function(event, val, remaining) {
+      assert.equal(event, 'data');
+      assert.equal(val.toString(), 'how');
+      assert.equal(remaining, 9);
+    });
+
+    parser.write(new Buffer('how'));
+
+    gently.expect(packet, 'emit', function(event, val, remaining) {
+      assert.equal(event, 'data');
+      assert.equal(val.toString(), ' are you?');
+      assert.equal(remaining, 0);
+    });
+
+    gently.expect(packet, 'emit', function(event, val, remaining) {
+      assert.equal(event, 'data');
+      assert.equal(val.toString(), 'Fine!');
+      assert.equal(remaining, 0);
+      assert.equal(packet.index, 0);
+    });
+
+    parser.write(new Buffer(' are you?\u0005Fine!'));
+
+    assert.equal(parser.packet, null);
+    assert.equal(parser.state, Parser.PACKET_LENGTH);
+  })();
+
+  (function testEofPacketAfterRowPacket() {
+    parser.write(new Buffer([5, 0, 0, 1]));
+    var packet = parser.packet;
+
+    parser.write(new Buffer([0xfe]));
+    assert.equal(packet.type, Parser.EOF_PACKET);
+    assert.equal(parser.receivingRowPackets, false);
+  })();
+});

Nodejs-Socketio-Mysql-Demo/node_modules/mysql/test/unit/legacy/test-query.js

@@ -0,0 +1,68 @@
+var common = require('./common');
+var Query = require(common.dir.lib + '/query');
+var EventEmitter = require('events').EventEmitter;
+var Parser = require(common.dir.lib + '/parser');
+var query;
+var gently;
+
+function test(test) {
+  query = new Query();
+  gently = new Gently();
+  test();
+  gently.verify(test.name);
+}
+
+test(function constructor() {
+  assert.ok(query instanceof EventEmitter);
+  assert.strictEqual(query.typeCast, true);
+  assert.strictEqual(query.sql, null);
+  assert.equal(new Query({foo: 'bar'}).foo, 'bar');
+});
+
+test(function _handlePacket() {
+  function typeCast(type, strValue) {
+    query._fields = [{name: 'my_field', fieldType: type}];
+
+    var PACKET = new EventEmitter(), r;
+    PACKET.type = Parser.ROW_DATA_PACKET;
+
+    gently.expect(PACKET, 'on', function (event, fn) {
+      assert.equal(event, 'data');
+
+      gently.expect(query, 'emit', function (event, row) {
+        assert.equal(event, 'row');
+        r = row.my_field;
+      });
+
+      var val = (strValue === null)
+        ? null
+        : new Buffer(strValue);
+
+      fn(val, 0);
+    });
+
+    query._handlePacket(PACKET);
+    return r;
+  }
+
+  assert.deepEqual(typeCast(Query.FIELD_TYPE_TIMESTAMP, '2010-10-05 06:23:42 UTC'), new Date('2010-10-05 06:23:42Z'));
+
+  assert.deepEqual(typeCast(Query.FIELD_TYPE_TIMESTAMP, '2010-10-05 UTC'), new Date('2010-10-05Z'));
+  assert.deepEqual(typeCast(Query.FIELD_TYPE_DATE, '2010-10-05 UTC'), new Date('2010-10-05Z'));
+  assert.deepEqual(typeCast(Query.FIELD_TYPE_DATETIME, '2010-10-05 UTC'), new Date('2010-10-05Z'));
+  assert.deepEqual(typeCast(Query.FIELD_TYPE_NEWDATE, '2010-10-05 UTC'), new Date('2010-10-05Z'));
+
+  assert.strictEqual(typeCast(Query.FIELD_TYPE_TINY, '08'), 8);
+  assert.strictEqual(typeCast(Query.FIELD_TYPE_SHORT, '08'), 8);
+  assert.strictEqual(typeCast(Query.FIELD_TYPE_LONG, '08'), 8);
+  assert.strictEqual(typeCast(Query.FIELD_TYPE_LONGLONG, '08'), 8);
+  assert.strictEqual(typeCast(Query.FIELD_TYPE_INT24, '08'), 8);
+  assert.strictEqual(typeCast(Query.FIELD_TYPE_YEAR, '08'), 8);
+
+  assert.strictEqual(typeCast(Query.FIELD_TYPE_DECIMAL, '2.8'), '2.8');
+  assert.strictEqual(typeCast(Query.FIELD_TYPE_FLOAT, '2.8'), 2.8);
+  assert.strictEqual(typeCast(Query.FIELD_TYPE_DOUBLE, '2.8'), 2.8);
+  assert.strictEqual(typeCast(Query.FIELD_TYPE_NEWDECIMAL, '2.8'), '2.8');
+
+  assert.strictEqual(typeCast(Query.FIELD_TYPE_DATE, null), null);
+});

Nodejs-Socketio-Mysql-Demo/node_modules/mysql/test/unit/test-client.js

@@ -0,0 +1,33 @@
+var common = require('../common');
+var assert = require('assert');
+var test   = require('utest');
+var Client = require(common.dir.lib + '/client');
+
+var client;
+test('Client', {
+  before: function() {
+    client = new Client();
+  },
+
+  '#format() does not manipulate params parameter': function() {
+    var sql = '?';
+    var params = [1];
+
+    client.format(sql, params);
+    assert.equal(params.length, 1);
+  },
+
+  '#format() does not quote floats': function() {
+    var params = [1.23];
+
+    var sql = client.format('?', params);
+    assert.strictEqual(sql, '1.23');
+  },
+
+  'Timeout reconnect works with empty queue': function() {
+    // A non-error packet
+    var packet = {};
+    // This must not throw an error
+    client._handlePacket(packet);
+  },
+});

Nodejs-Socketio-Mysql-Demo/node_modules/mysql/test/unit/test-mysql.js

@@ -0,0 +1,10 @@
+var common = require('../common');
+var assert = require('assert');
+var test   = require('utest');
+var mysql  = require(common.dir.root);
+
+test('mysql module', {
+  'Package JSON is exported': function() {
+    assert.strictEqual(mysql.PACKAGE.name, 'mysql');
+  },
+});