first post

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');
+  },
+});