first commit

node_modules/streamws/test/BufferPool.test.js

@@ -0,0 +1,63 @@
+var BufferPool = require('../lib/BufferPool');
+require('should');
+
+describe('BufferPool', function() {  
+  describe('#ctor', function() {
+    it('allocates pool', function() {
+      var db = new BufferPool(1000);
+      db.size.should.eql(1000);
+    });
+  });
+  describe('#get', function() {
+    it('grows the pool if necessary', function() {
+      var db = new BufferPool(1000);
+      var buf = db.get(2000);
+      db.size.should.be.above(1000);
+      db.used.should.eql(2000);
+      buf.length.should.eql(2000);
+    });
+    it('grows the pool after the first call, if necessary', function() {
+      var db = new BufferPool(1000);
+      var buf = db.get(1000);
+      db.used.should.eql(1000);
+      db.size.should.eql(1000);
+      buf.length.should.eql(1000);
+      var buf2 = db.get(1000);
+      db.used.should.eql(2000);
+      db.size.should.be.above(1000);
+      buf2.length.should.eql(1000);
+    });
+    it('grows the pool according to the growStrategy if necessary', function() {
+      var db = new BufferPool(1000, function(db, length) {
+        return db.size + 2345;
+      });
+      var buf = db.get(2000);
+      db.size.should.eql(3345);
+      buf.length.should.eql(2000);
+    });
+    it('doesnt grow the pool if theres enough room available', function() {
+      var db = new BufferPool(1000);
+      var buf = db.get(1000);
+      db.size.should.eql(1000);
+      buf.length.should.eql(1000);      
+    });
+  });
+  describe('#reset', function() {
+    it('shinks the pool', function() {
+      var db = new BufferPool(1000);
+      var buf = db.get(2000);
+      db.reset(true);
+      db.size.should.eql(1000);
+    });
+    it('shrinks the pool according to the shrinkStrategy', function() {
+      var db = new BufferPool(1000, function(db, length) {
+        return db.used + length;
+      }, function(db) {
+        return 0;
+      });
+      var buf = db.get(2000);
+      db.reset(true);
+      db.size.should.eql(0);
+    });
+  });
+});

node_modules/streamws/test/Receiver.hixie.test.js

@@ -0,0 +1,132 @@
+var assert = require('assert')
+  , expect = require('expect.js')
+  , Receiver = require('../lib/Receiver.hixie');
+require('./hybi-common');
+
+describe('Receiver', function() {
+  it('can parse text message', function() {
+    var p = new Receiver();
+    var packet = '00 48 65 6c 6c 6f ff';
+
+    var gotData = false;
+    p.ontext = function(data) {
+      gotData = true;
+      assert.equal('Hello', data);
+    };
+
+    p.add(getBufferFromHexString(packet));
+    expect(gotData).to.equal(true);
+  });
+
+  it('can parse multiple text messages', function() {
+    var p = new Receiver();
+    var packet = '00 48 65 6c 6c 6f ff 00 48 65 6c 6c 6f ff';
+
+    var gotData = false;
+    var messages = [];
+    p.ontext = function(data) {
+      gotData = true;
+      messages.push(data);
+    };
+
+    p.add(getBufferFromHexString(packet));
+    expect(gotData).to.equal(true);
+    for (var i = 0; i < 2; ++i) {
+      expect(messages[i]).to.equal('Hello');
+    }
+  });
+
+  it('can parse empty message', function() {
+    var p = new Receiver();
+    var packet = '00 ff';
+
+    var gotData = false;
+    p.ontext = function(data) {
+      gotData = true;
+      assert.equal('', data);
+    };
+
+    p.add(getBufferFromHexString(packet));
+    expect(gotData).to.equal(true);
+  });
+
+  it('can parse text messages delivered over multiple frames', function() {
+    var p = new Receiver();
+    var packets = [
+      '00 48',
+      '65 6c 6c',
+      '6f ff 00 48',
+      '65',
+      '6c 6c 6f',
+      'ff'
+    ];
+
+    var gotData = false;
+    var messages = [];
+    p.ontext = function(data) {
+      gotData = true;
+      messages.push(data);
+    };
+
+    for (var i = 0; i < packets.length; ++i) {
+      p.add(getBufferFromHexString(packets[i]));
+    }
+    expect(gotData).to.equal(true);
+    for (var i = 0; i < 2; ++i) {
+      expect(messages[i]).to.equal('Hello');
+    }
+  });
+
+  it('emits an error if a payload doesnt start with 0x00', function() {
+    var p = new Receiver();
+    var packets = [
+      '00 6c ff',
+      '00 6c ff ff',
+      'ff 00 6c ff 00 6c ff',
+      '00',
+      '6c 6c 6f',
+      'ff'
+    ];
+
+    var gotData = false;
+    var gotError = false;
+    var messages = [];
+    p.ontext = function(data) {
+      gotData = true;
+      messages.push(data);
+    };
+    p.onerror = function(reason, code) {
+      gotError = code == true;
+    };
+
+    for (var i = 0; i < packets.length && !gotError; ++i) {
+      p.add(getBufferFromHexString(packets[i]));
+    }
+    expect(gotError).to.equal(true);
+    expect(messages[0]).to.equal('l');
+    expect(messages[1]).to.equal('l');
+    expect(messages.length).to.equal(2);
+  });
+
+  it('can parse close messages', function() {
+    var p = new Receiver();
+    var packets = [
+      'ff 00'
+    ];
+
+    var gotClose = false;
+    var gotError = false;
+    p.onclose = function() {
+      gotClose = true;
+    };
+    p.onerror = function(reason, code) {
+      gotError = code == true;
+    };
+
+    for (var i = 0; i < packets.length && !gotError; ++i) {
+      p.add(getBufferFromHexString(packets[i]));
+    }
+    expect(gotClose).to.equal(true);
+    expect(gotError).to.equal(false);
+  });
+});

node_modules/streamws/test/Receiver.test.js

@@ -0,0 +1,255 @@
+var assert = require('assert')
+  , Receiver = require('../lib/Receiver');
+require('should');
+require('./hybi-common');
+
+describe('Receiver', function() {
+  it('can parse unmasked text message', function() {
+    var p = new Receiver();
+    var packet = '81 05 48 65 6c 6c 6f';
+
+    var gotData = false;
+    p.ontext = function(data) {
+      gotData = true;
+      assert.equal('Hello', data);
+    };
+
+    p.add(getBufferFromHexString(packet));
+    gotData.should.be.ok;
+  });
+  it('can parse close message', function() {
+    var p = new Receiver();
+    var packet = '88 00';
+
+    var gotClose = false;
+    p.onclose = function(data) {
+      gotClose = true;
+    };
+
+    p.add(getBufferFromHexString(packet));
+    gotClose.should.be.ok;
+  });
+  it('can parse masked text message', function() {
+    var p = new Receiver();
+    var packet = '81 93 34 83 a8 68 01 b9 92 52 4f a1 c6 09 59 e6 8a 52 16 e6 cb 00 5b a1 d5';
+
+    var gotData = false;
+    p.ontext = function(data) {
+      gotData = true;
+      assert.equal('5:::{"name":"echo"}', data);
+    };
+
+    p.add(getBufferFromHexString(packet));
+    gotData.should.be.ok;
+  });
+  it('can parse a masked text message longer than 125 bytes', function() {
+    var p = new Receiver();
+    var message = 'A';
+    for (var i = 0; i < 300; ++i) message += (i % 5).toString();
+    var packet = '81 FE ' + pack(4, message.length) + ' 34 83 a8 68 ' + getHexStringFromBuffer(mask(message, '34 83 a8 68'));
+
+    var gotData = false;
+    p.ontext = function(data) {
+      gotData = true;
+      assert.equal(message, data);
+    };
+
+    p.add(getBufferFromHexString(packet));
+    gotData.should.be.ok;
+  });
+  it('can parse a really long masked text message', function() {
+    var p = new Receiver();
+    var message = 'A';
+    for (var i = 0; i < 64*1024; ++i) message += (i % 5).toString();
+    var packet = '81 FF ' + pack(16, message.length) + ' 34 83 a8 68 ' + getHexStringFromBuffer(mask(message, '34 83 a8 68'));
+
+    var gotData = false;
+    p.ontext = function(data) {
+      gotData = true;
+      assert.equal(message, data);
+    };
+
+    p.add(getBufferFromHexString(packet));
+    gotData.should.be.ok;
+  });
+  it('can parse a fragmented masked text message of 300 bytes', function() {
+    var p = new Receiver();
+    var message = 'A';
+    for (var i = 0; i < 300; ++i) message += (i % 5).toString();
+    var msgpiece1 = message.substr(0, 150);
+    var msgpiece2 = message.substr(150);
+    var packet1 = '01 FE ' + pack(4, msgpiece1.length) + ' 34 83 a8 68 ' + getHexStringFromBuffer(mask(msgpiece1, '34 83 a8 68'));
+    var packet2 = '80 FE ' + pack(4, msgpiece2.length) + ' 34 83 a8 68 ' + getHexStringFromBuffer(mask(msgpiece2, '34 83 a8 68'));
+
+    var gotData = false;
+    p.ontext = function(data) {
+      gotData = true;
+      assert.equal(message, data);
+    };
+
+    p.add(getBufferFromHexString(packet1));
+    p.add(getBufferFromHexString(packet2));
+    gotData.should.be.ok;
+  });
+  it('can parse a ping message', function() {
+    var p = new Receiver();
+    var message = 'Hello';
+    var packet = '89 ' + getHybiLengthAsHexString(message.length, true) + ' 34 83 a8 68 ' + getHexStringFromBuffer(mask(message, '34 83 a8 68'));
+
+    var gotPing = false;
+    p.onping = function(data) {
+      gotPing = true;
+      assert.equal(message, data);
+    };
+
+    p.add(getBufferFromHexString(packet));
+    gotPing.should.be.ok;
+  });
+  it('can parse a ping with no data', function() {
+    var p = new Receiver();
+    var packet = '89 00';
+
+    var gotPing = false;
+    p.onping = function(data) {
+      gotPing = true;
+    };
+
+    p.add(getBufferFromHexString(packet));
+    gotPing.should.be.ok;
+  });
+  it('can parse a fragmented masked text message of 300 bytes with a ping in the middle', function() {
+    var p = new Receiver();
+    var message = 'A';
+    for (var i = 0; i < 300; ++i) message += (i % 5).toString();
+
+    var msgpiece1 = message.substr(0, 150);
+    var packet1 = '01 FE ' + pack(4, msgpiece1.length) + ' 34 83 a8 68 ' + getHexStringFromBuffer(mask(msgpiece1, '34 83 a8 68'));
+
+    var pingMessage = 'Hello';
+    var pingPacket = '89 ' + getHybiLengthAsHexString(pingMessage.length, true) + ' 34 83 a8 68 ' + getHexStringFromBuffer(mask(pingMessage, '34 83 a8 68'));
+
+    var msgpiece2 = message.substr(150);
+    var packet2 = '80 FE ' + pack(4, msgpiece2.length) + ' 34 83 a8 68 ' + getHexStringFromBuffer(mask(msgpiece2, '34 83 a8 68'));
+
+    var gotData = false;
+    p.ontext = function(data) {
+      gotData = true;
+      assert.equal(message, data);
+    };
+    var gotPing = false;
+    p.onping = function(data) {
+      gotPing = true;
+      assert.equal(pingMessage, data);
+    };
+
+    p.add(getBufferFromHexString(packet1));
+    p.add(getBufferFromHexString(pingPacket));
+    p.add(getBufferFromHexString(packet2));
+    gotData.should.be.ok;
+    gotPing.should.be.ok;
+  });
+  it('can parse a fragmented masked text message of 300 bytes with a ping in the middle, which is delievered over sevaral tcp packets', function() {
+    var p = new Receiver();
+    var message = 'A';
+    for (var i = 0; i < 300; ++i) message += (i % 5).toString();
+
+    var msgpiece1 = message.substr(0, 150);
+    var packet1 = '01 FE ' + pack(4, msgpiece1.length) + ' 34 83 a8 68 ' + getHexStringFromBuffer(mask(msgpiece1, '34 83 a8 68'));
+
+    var pingMessage = 'Hello';
+    var pingPacket = '89 ' + getHybiLengthAsHexString(pingMessage.length, true) + ' 34 83 a8 68 ' + getHexStringFromBuffer(mask(pingMessage, '34 83 a8 68'));
+
+    var msgpiece2 = message.substr(150);
+    var packet2 = '80 FE ' + pack(4, msgpiece2.length) + ' 34 83 a8 68 ' + getHexStringFromBuffer(mask(msgpiece2, '34 83 a8 68'));
+
+    var gotData = false;
+    p.ontext = function(data) {
+      gotData = true;
+      assert.equal(message, data);
+    };
+    var gotPing = false;
+    p.onping = function(data) {
+      gotPing = true;
+      assert.equal(pingMessage, data);
+    };
+
+    var buffers = [];
+    buffers = buffers.concat(splitBuffer(getBufferFromHexString(packet1)));
+    buffers = buffers.concat(splitBuffer(getBufferFromHexString(pingPacket)));
+    buffers = buffers.concat(splitBuffer(getBufferFromHexString(packet2)));
+    for (var i = 0; i < buffers.length; ++i) {
+      p.add(buffers[i]);
+    }
+    gotData.should.be.ok;
+    gotPing.should.be.ok;
+  });
+  it('can parse a 100 byte long masked binary message', function() {
+    var p = new Receiver();
+    var length = 100;
+    var message = new Buffer(length);
+    for (var i = 0; i < length; ++i) message[i] = i % 256;
+    var originalMessage = getHexStringFromBuffer(message);
+    var packet = '82 ' + getHybiLengthAsHexString(length, true) + ' 34 83 a8 68 ' + getHexStringFromBuffer(mask(message, '34 83 a8 68'));
+
+    var gotData = false;
+    p.onbinary = function(data) {
+      gotData = true;
+      assert.equal(originalMessage, getHexStringFromBuffer(data));
+    };
+
+    p.add(getBufferFromHexString(packet));
+    gotData.should.be.ok;
+  });
+  it('can parse a 256 byte long masked binary message', function() {
+    var p = new Receiver();
+    var length = 256;
+    var message = new Buffer(length);
+    for (var i = 0; i < length; ++i) message[i] = i % 256;
+    var originalMessage = getHexStringFromBuffer(message);
+    var packet = '82 ' + getHybiLengthAsHexString(length, true) + ' 34 83 a8 68 ' + getHexStringFromBuffer(mask(message, '34 83 a8 68'));
+
+    var gotData = false;
+    p.onbinary = function(data) {
+      gotData = true;
+      assert.equal(originalMessage, getHexStringFromBuffer(data));
+    };
+
+    p.add(getBufferFromHexString(packet));
+    gotData.should.be.ok;
+  });
+  it('can parse a 200kb long masked binary message', function() {
+    var p = new Receiver();
+    var length = 200 * 1024;
+    var message = new Buffer(length);
+    for (var i = 0; i < length; ++i) message[i] = i % 256;
+    var originalMessage = getHexStringFromBuffer(message);
+    var packet = '82 ' + getHybiLengthAsHexString(length, true) + ' 34 83 a8 68 ' + getHexStringFromBuffer(mask(message, '34 83 a8 68'));
+
+    var gotData = false;
+    p.onbinary = function(data) {
+      gotData = true;
+      assert.equal(originalMessage, getHexStringFromBuffer(data));
+    };
+
+    p.add(getBufferFromHexString(packet));
+    gotData.should.be.ok;
+  });
+  it('can parse a 200kb long unmasked binary message', function() {
+    var p = new Receiver();
+    var length = 200 * 1024;
+    var message = new Buffer(length);
+    for (var i = 0; i < length; ++i) message[i] = i % 256;
+    var originalMessage = getHexStringFromBuffer(message);
+    var packet = '82 ' + getHybiLengthAsHexString(length, false) + ' ' + getHexStringFromBuffer(message);
+
+    var gotData = false;
+    p.onbinary = function(data) {
+      gotData = true;
+      assert.equal(originalMessage, getHexStringFromBuffer(data));
+    };
+
+    p.add(getBufferFromHexString(packet));
+    gotData.should.be.ok;
+  });
+});
+

node_modules/streamws/test/Sender.hixie.test.js

@@ -0,0 +1,116 @@
+var assert = require('assert')
+  , Sender = require('../lib/Sender.hixie');
+require('should');
+require('./hybi-common');
+
+describe('Sender', function() {
+  describe('#send', function() {
+    it('frames and sends a text message', function(done) {
+      var message = 'Hello world';
+      var received;
+      var socket = {
+        write: function(data, encoding, cb) {
+          received = data;
+          process.nextTick(cb);
+        }
+      };
+      var sender = new Sender(socket, {});
+      sender.send(message, {}, function() {
+        received.toString('utf8').should.eql('\u0000' + message + '\ufffd');
+        done();
+      });
+    });
+
+    it('frames and sends an empty message', function(done) {
+      var socket = {
+        write: function(data, encoding, cb) {
+          done();
+        }
+      };
+      var sender = new Sender(socket, {});
+      sender.send('', {}, function() {});
+    });
+
+    it('frames and sends a buffer', function(done) {
+      var received;
+      var socket = {
+        write: function(data, encoding, cb) {
+          received = data;
+          process.nextTick(cb);
+        }
+      };
+      var sender = new Sender(socket, {});
+      sender.send(new Buffer('foobar'), {}, function() {
+        received.toString('utf8').should.eql('\u0000foobar\ufffd');
+        done();
+      });
+    });
+
+    it('throws an exception for binary data', function(done) {
+      var socket = {
+        write: function(data, encoding, cb) {
+          process.nextTick(cb);
+        }
+      };
+      var sender = new Sender(socket, {});
+      sender.on('error', function() {
+        done();
+      });
+      sender.send(new Buffer(100), {binary: true}, function() {});
+    });
+
+    it('can fauxe stream data', function(done) {
+      var received = [];
+      var socket = {
+        write: function(data, encoding, cb) {
+          received.push(data);
+          process.nextTick(cb);
+        }
+      };
+      var sender = new Sender(socket, {});
+      sender.send(new Buffer('foobar'), { fin: false }, function() {});
+      sender.send('bazbar', { fin: false }, function() {});
+      sender.send(new Buffer('end'), { fin: true }, function() {
+        received[0].toString('utf8').should.eql('\u0000foobar');
+        received[1].toString('utf8').should.eql('bazbar');
+        received[2].toString('utf8').should.eql('end\ufffd');
+        done();
+      });
+    });
+  });
+
+  describe('#close', function() {
+    it('sends a hixie close frame', function(done) {
+      var received;
+      var socket = {
+        write: function(data, encoding, cb) {
+          received = data;
+          process.nextTick(cb);
+        }
+      };
+      var sender = new Sender(socket, {});
+      sender.close(null, null, null, function() {
+        received.toString('utf8').should.eql('\ufffd\u0000');
+        done();
+      });
+    });
+
+    it('sends a message end marker if fauxe streaming has started, before hixie close frame', function(done) {
+      var received = [];
+      var socket = {
+        write: function(data, encoding, cb) {
+          received.push(data);
+          if (cb) process.nextTick(cb);
+        }
+      };
+      var sender = new Sender(socket, {});
+      sender.send(new Buffer('foobar'), { fin: false }, function() {});
+      sender.close(null, null, null, function() {
+        received[0].toString('utf8').should.eql('\u0000foobar');
+        received[1].toString('utf8').should.eql('\ufffd');
+        received[2].toString('utf8').should.eql('\ufffd\u0000');
+        done();
+      });
+    });
+  });
+});

node_modules/streamws/test/Sender.test.js

@@ -0,0 +1,24 @@
+var Sender = require('../lib/Sender');
+require('should');
+
+describe('Sender', function() {
+  describe('#frameAndSend', function() {
+    it('does not modify a masked binary buffer', function() {
+      var sender = new Sender({ write: function() {} });
+      var buf = new Buffer([1, 2, 3, 4, 5]);
+      sender.frameAndSend(2, buf, true, true);
+      buf[0].should.eql(1);
+      buf[1].should.eql(2);
+      buf[2].should.eql(3);
+      buf[3].should.eql(4);
+      buf[4].should.eql(5);
+    });
+
+    it('does not modify a masked text buffer', function() {
+      var sender = new Sender({ write: function() {} });
+      var text = 'hi there';
+      sender.frameAndSend(1, text, true, true);
+      text.should.eql('hi there');
+    });
+  });
+});

node_modules/streamws/test/Validation.test.js

@@ -0,0 +1,23 @@
+var Validation = require('../lib/Validation').Validation;
+require('should');
+
+describe('Validation', function() {
+  describe('isValidUTF8', function() {
+    it('should return true for a valid utf8 string', function() {
+      var validBuffer = new Buffer('Lorem ipsum dolor sit amet, consectetur adipiscing elit. Quisque gravida mattis rhoncus. Donec iaculis, metus quis varius accumsan, erat mauris condimentum diam, et egestas erat enim ut ligula. Praesent sollicitudin tellus eget dolor euismod euismod. Nullam ac augue nec neque varius luctus. Curabitur elit mi, consequat ultricies adipiscing mollis, scelerisque in erat. Phasellus facilisis fermentum ullamcorper. Nulla et sem eu arcu pharetra pellentesque. Praesent consectetur tempor justo, vel iaculis dui ullamcorper sit amet. Integer tristique viverra ullamcorper. Vivamus laoreet, nulla eget suscipit eleifend, lacus lectus feugiat libero, non fermentum erat nisi at risus. Lorem ipsum dolor sit amet, consectetur adipiscing elit. Ut pulvinar dignissim tellus, eu dignissim lorem vulputate quis. Morbi ut pulvinar augue.');
+      Validation.isValidUTF8(validBuffer).should.be.ok;
+    });
+    it('should return false for an erroneous string', function() {
+      var invalidBuffer = new Buffer([0xce, 0xba, 0xe1, 0xbd, 0xb9, 0xcf, 0x83, 0xce, 0xbc, 0xce, 0xb5, 0xed, 0xa0, 0x80, 0x65, 0x64, 0x69, 0x74, 0x65, 0x64]);
+      Validation.isValidUTF8(invalidBuffer).should.not.be.ok;
+    });
+    it('should return true for valid cases from the autobahn test suite', function() {
+      Validation.isValidUTF8(new Buffer('\xf0\x90\x80\x80')).should.be.ok;
+      Validation.isValidUTF8(new Buffer([0xf0, 0x90, 0x80, 0x80])).should.be.ok;
+    });
+    it('should return false for erroneous autobahn strings', function() {
+      Validation.isValidUTF8(new Buffer([0xce, 0xba, 0xe1, 0xbd])).should.not.be.ok;
+    });
+  });
+});
+

node_modules/streamws/test/WebSocket.integration.js

@@ -0,0 +1,42 @@
+var assert = require('assert')
+  , WebSocket = require('../')
+  , server = require('./testserver');
+
+var port = 20000;
+
+function getArrayBuffer(buf) {
+  var l = buf.length;
+  var arrayBuf = new ArrayBuffer(l);
+  for (var i = 0; i < l; ++i) {
+    arrayBuf[i] = buf[i];
+  }
+  return arrayBuf;
+}
+
+function areArraysEqual(x, y) {
+  if (x.length != y.length) return false;
+  for (var i = 0, l = x.length; i < l; ++i) {
+    if (x[i] !== y[i]) return false;
+  }
+  return true;
+}
+
+describe('WebSocket', function() {
+  it('communicates successfully with echo service', function(done) {
+    var ws = new WebSocket('ws://echo.websocket.org', {protocolVersion: 8, origin: 'http://websocket.org'});
+    var str = Date.now().toString();
+    var dataReceived = false;
+    ws.on('open', function() {
+      ws.send(str, {mask: true});
+    });
+    ws.on('close', function() {
+      assert.equal(true, dataReceived);
+      done();
+    });
+    ws.on('message', function(data, flags) {
+      assert.equal(str, data);
+      ws.terminate();
+      dataReceived = true;
+    });
+  });
+});

node_modules/streamws/test/autobahn-server.js

@@ -0,0 +1,29 @@
+var WebSocketServer = require('../').Server;
+
+process.on('uncaughtException', function(err) {
+  console.log('Caught exception: ', err, err.stack);
+});
+
+process.on('SIGINT', function () {
+  try {
+    console.log('Updating reports and shutting down');
+    var ws = new WebSocket('ws://localhost:9001/updateReports?agent=ws');
+    ws.on('close', function() {
+      process.exit();
+    });
+  }
+  catch(e) {
+    process.exit();
+  }
+});
+
+var wss = new WebSocketServer({port: 8181});
+wss.on('connection', function(ws) {
+  console.log('new connection');
+  ws.on('message', function(data, flags) {
+    ws.send(flags.buffer, {binary: flags.binary === true});
+  });
+  ws.on('error', function() {
+    console.log('error', arguments);
+  });
+});

node_modules/streamws/test/autobahn.js

@@ -0,0 +1,52 @@
+var WebSocket = require('../');
+var currentTest = 1;
+var lastTest = -1;
+var testCount = null;
+
+process.on('uncaughtException', function(err) {
+  console.log('Caught exception: ', err, err.stack);
+});
+
+process.on('SIGINT', function () {
+  try {
+    console.log('Updating reports and shutting down');
+    var ws = new WebSocket('ws://localhost:9001/updateReports?agent=ws');
+    ws.on('close', function() {
+      process.exit();
+    });
+  }
+  catch(e) {
+    process.exit();
+  }
+});
+
+function nextTest() {
+  if (currentTest > testCount || (lastTest != -1 && currentTest > lastTest)) {
+    console.log('Updating reports and shutting down');
+    var ws = new WebSocket('ws://localhost:9001/updateReports?agent=ws');
+    ws.on('close', function() {
+      process.exit();
+    });
+    return;
+  };
+  console.log('Running test case ' + currentTest + '/' + testCount);
+  var ws = new WebSocket('ws://localhost:9001/runCase?case=' + currentTest + '&agent=ws');
+  ws.on('message', function(data, flags) {
+    ws.send(flags.buffer, {binary: flags.binary === true, mask: true});
+  });
+  ws.on('close', function(data) {
+    currentTest += 1;
+    process.nextTick(nextTest);
+  });
+  ws.on('error', function(e) {});
+}
+
+var ws = new WebSocket('ws://localhost:9001/getCaseCount');
+ws.on('message', function(data, flags) {
+  testCount = parseInt(data);
+});
+ws.on('close', function() {
+  if (testCount > 0) {
+    nextTest();
+  }
+});

node_modules/streamws/test/fixtures/certificate.pem

@@ -0,0 +1,13 @@
+-----BEGIN CERTIFICATE-----
+MIICATCCAWoCCQDPufXH86n2QzANBgkqhkiG9w0BAQUFADBFMQswCQYDVQQGEwJu
+bzETMBEGA1UECAwKU29tZS1TdGF0ZTEhMB8GA1UECgwYSW50ZXJuZXQgV2lkZ2l0
+cyBQdHkgTHRkMB4XDTEyMDEwMTE0NDQwMFoXDTIwMDMxOTE0NDQwMFowRTELMAkG
+A1UEBhMCbm8xEzARBgNVBAgMClNvbWUtU3RhdGUxITAfBgNVBAoMGEludGVybmV0
+IFdpZGdpdHMgUHR5IEx0ZDCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEAtrQ7
++r//2iV/B6F+4boH0XqFn7alcV9lpjvAmwRXNKnxAoa0f97AjYPGNLKrjpkNXXhB
+JROIdbRbZnCNeC5fzX1a+JCo7KStzBXuGSZr27TtFmcV4H+9gIRIcNHtZmJLnxbJ
+sIhkGR8yVYdmJZe4eT5ldk1zoB1adgPF1hZhCBMCAwEAATANBgkqhkiG9w0BAQUF
+AAOBgQCeWBEHYJ4mCB5McwSSUox0T+/mJ4W48L/ZUE4LtRhHasU9hiW92xZkTa7E
+QLcoJKQiWfiLX2ysAro0NX4+V8iqLziMqvswnPzz5nezaOLE/9U/QvH3l8qqNkXu
+rNbsW1h/IO6FV8avWFYVFoutUwOaZ809k7iMh2F2JMgXQ5EymQ==
+-----END CERTIFICATE-----

node_modules/streamws/test/fixtures/key.pem

@@ -0,0 +1,15 @@
+-----BEGIN RSA PRIVATE KEY-----
+MIICXAIBAAKBgQC2tDv6v//aJX8HoX7hugfReoWftqVxX2WmO8CbBFc0qfEChrR/
+3sCNg8Y0squOmQ1deEElE4h1tFtmcI14Ll/NfVr4kKjspK3MFe4ZJmvbtO0WZxXg
+f72AhEhw0e1mYkufFsmwiGQZHzJVh2Yll7h5PmV2TXOgHVp2A8XWFmEIEwIDAQAB
+AoGAAlVY8sHi/aE+9xT77twWX3mGHV0SzdjfDnly40fx6S1Gc7bOtVdd9DC7pk6l
+3ENeJVR02IlgU8iC5lMHq4JEHPE272jtPrLlrpWLTGmHEqoVFv9AITPqUDLhB9Kk
+Hjl7h8NYBKbr2JHKICr3DIPKOT+RnXVb1PD4EORbJ3ooYmkCQQDfknUnVxPgxUGs
+ouABw1WJIOVgcCY/IFt4Ihf6VWTsxBgzTJKxn3HtgvE0oqTH7V480XoH0QxHhjLq
+DrgobWU9AkEA0TRJ8/ouXGnFEPAXjWr9GdPQRZ1Use2MrFjneH2+Sxc0CmYtwwqL
+Kr5kS6mqJrxprJeluSjBd+3/ElxURrEXjwJAUvmlN1OPEhXDmRHd92mKnlkyKEeX
+OkiFCiIFKih1S5Y/sRJTQ0781nyJjtJqO7UyC3pnQu1oFEePL+UEniRztQJAMfav
+AtnpYKDSM+1jcp7uu9BemYGtzKDTTAYfoiNF42EzSJiGrWJDQn4eLgPjY0T0aAf/
+yGz3Z9ErbhMm/Ysl+QJBAL4kBxRT8gM4ByJw4sdOvSeCCANFq8fhbgm8pGWlCPb5
+JGmX3/GHFM8x2tbWMGpyZP1DLtiNEFz7eCGktWK5rqE=
+-----END RSA PRIVATE KEY-----

node_modules/streamws/test/fixtures/request.pem

@@ -0,0 +1,11 @@
+-----BEGIN CERTIFICATE REQUEST-----
+MIIBhDCB7gIBADBFMQswCQYDVQQGEwJubzETMBEGA1UECAwKU29tZS1TdGF0ZTEh
+MB8GA1UECgwYSW50ZXJuZXQgV2lkZ2l0cyBQdHkgTHRkMIGfMA0GCSqGSIb3DQEB
+AQUAA4GNADCBiQKBgQC2tDv6v//aJX8HoX7hugfReoWftqVxX2WmO8CbBFc0qfEC
+hrR/3sCNg8Y0squOmQ1deEElE4h1tFtmcI14Ll/NfVr4kKjspK3MFe4ZJmvbtO0W
+ZxXgf72AhEhw0e1mYkufFsmwiGQZHzJVh2Yll7h5PmV2TXOgHVp2A8XWFmEIEwID
+AQABoAAwDQYJKoZIhvcNAQEFBQADgYEAjsUXEARgfxZNkMjuUcudgU2w4JXS0gGI
+JQ0U1LmU0vMDSKwqndMlvCbKzEgPbJnGJDI8D4MeINCJHa5Ceyb8c+jaJYUcCabl
+lQW5Psn3+eWp8ncKlIycDRj1Qk615XuXtV0fhkrgQM2ZCm9LaQ1O1Gd/CzLihLjF
+W0MmgMKMMRk=
+-----END CERTIFICATE REQUEST-----

node_modules/streamws/test/fixtures/textfile

@@ -0,0 +1,9 @@
+Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nullam egestas, massa at aliquam luctus, sapien erat viverra elit, nec pulvinar turpis eros sagittis urna. Pellentesque imperdiet tempor varius. Pellentesque blandit, ipsum in imperdiet venenatis, mi elit faucibus odio, id condimentum ante enim sed lectus. Aliquam et odio non odio pellentesque pulvinar. Vestibulum a erat dolor. Integer pretium risus sit amet nisl volutpat nec venenatis magna egestas. Ut bibendum felis eu tellus laoreet eleifend. Nam pulvinar auctor tortor, eu iaculis leo vestibulum quis. In euismod risus ac purus vehicula et fermentum ligula consectetur. Vivamus condimentum tempus lacinia.
+
+Curabitur sodales condimentum urna id dictum. Sed quis justo sit amet quam ultrices tincidunt vel laoreet nulla. Nullam quis ipsum sed nisi mollis bibendum at sit amet nisi. Donec laoreet consequat velit sit amet mollis. Nam sed sapien a massa iaculis dapibus. Sed dui nunc, ultricies et pellentesque ullamcorper, aliquet vitae ligula. Integer eu velit in neque iaculis venenatis. Ut rhoncus cursus est, ac dignissim leo vehicula a. Nulla ullamcorper vulputate mauris id blandit. Lorem ipsum dolor sit amet, consectetur adipiscing elit. Quisque eleifend, nisi a tempor sollicitudin, odio massa pretium urna, quis congue sapien elit at tortor. Curabitur ipsum orci, vehicula non commodo molestie, laoreet id enim. Pellentesque convallis ultrices congue. Pellentesque nec iaculis lorem. In sagittis pharetra ipsum eget sodales.
+
+Fusce id nulla odio. Nunc nibh justo, placerat vel tincidunt sed, ornare et enim. Nulla vel urna vel ante commodo bibendum in vitae metus. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Duis erat nunc, semper eget sagittis sit amet, ullamcorper eget lacus. Donec hendrerit ipsum vitae eros vestibulum eu gravida neque tincidunt. Ut molestie lacinia nulla. Donec mattis odio at magna egestas at pellentesque eros accumsan. Praesent interdum sem sit amet nibh commodo dignissim. Duis laoreet, enim ultricies fringilla suscipit, enim libero cursus nulla, sollicitudin adipiscing erat velit ut dui. Nulla eleifend mauris at velit fringilla a molestie lorem venenatis.
+
+Donec sit amet scelerisque metus. Cras ac felis a nulla venenatis vulputate. Duis porttitor eros ac neque rhoncus eget aliquet neque egestas. Quisque sed nunc est, vitae dapibus quam. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia Curae; In vehicula, est vitae posuere ultricies, diam purus pretium sapien, nec rhoncus dolor nisl eget arcu. Aliquam et nisi vitae risus tincidunt auctor. In vehicula, erat a cursus adipiscing, lorem orci congue est, nec ultricies elit dui in nunc. Class aptent taciti sociosqu ad litora torquent per conubia nostra, per inceptos himenaeos. Lorem ipsum dolor sit amet, consectetur adipiscing elit.
+
+Duis congue tempus elit sit amet auctor. Duis dignissim, risus ut sollicitudin ultricies, dolor ligula gravida odio, nec congue orci purus ut ligula. Fusce pretium dictum lectus at volutpat. Sed non auctor mauris. Etiam placerat vestibulum massa id blandit. Quisque consequat lacus ut nulla euismod facilisis. Sed aliquet ipsum nec mi imperdiet viverra. Pellentesque ullamcorper, lectus nec varius gravida, odio justo cursus risus, eu sagittis metus arcu quis felis. Phasellus consectetur vehicula libero, at condimentum orci euismod vel. Nunc purus tortor, suscipit nec fringilla nec, vulputate et nibh. Nam porta vehicula neque. Praesent porttitor, sapien eu auctor euismod, arcu quam elementum urna, sed hendrerit magna augue sed quam.

node_modules/streamws/test/hybi-common.js

@@ -0,0 +1,99 @@
+/**
+ * Returns a Buffer from a "ff 00 ff"-type hex string.
+ */
+
+getBufferFromHexString = function(byteStr) {
+  var bytes = byteStr.split(' ');
+  var buf = new Buffer(bytes.length);
+  for (var i = 0; i < bytes.length; ++i) {
+    buf[i] = parseInt(bytes[i], 16);
+  }
+  return buf;
+}
+
+/**
+ * Returns a hex string from a Buffer.
+ */
+
+getHexStringFromBuffer = function(data) {
+  var s = '';
+  for (var i = 0; i < data.length; ++i) {
+    s += padl(data[i].toString(16), 2, '0') + ' ';
+  }
+  return s.trim();
+}
+
+/**
+ * Splits a buffer in two parts.
+ */
+
+splitBuffer = function(buffer) {
+  var b1 = new Buffer(Math.ceil(buffer.length / 2));
+  buffer.copy(b1, 0, 0, b1.length);
+  var b2 = new Buffer(Math.floor(buffer.length / 2));
+  buffer.copy(b2, 0, b1.length, b1.length + b2.length);
+  return [b1, b2];
+}
+
+/**
+ * Performs hybi07+ type masking on a hex string or buffer.
+ */
+
+mask = function(buf, maskString) {
+  if (typeof buf == 'string') buf = new Buffer(buf);
+  var mask = getBufferFromHexString(maskString || '34 83 a8 68');
+  for (var i = 0; i < buf.length; ++i) {
+    buf[i] ^= mask[i % 4];    
+  }
+  return buf;
+}
+
+/**
+ * Returns a hex string representing the length of a message
+ */
+ 
+getHybiLengthAsHexString = function(len, masked) {  
+  if (len < 126) {
+    var buf = new Buffer(1);
+    buf[0] = (masked ? 0x80 : 0) | len;
+  }
+  else if (len < 65536) {
+    var buf = new Buffer(3);
+    buf[0] = (masked ? 0x80 : 0) | 126;
+    getBufferFromHexString(pack(4, len)).copy(buf, 1);
+  }
+  else {
+    var buf = new Buffer(9);
+    buf[0] = (masked ? 0x80 : 0) | 127;
+    getBufferFromHexString(pack(16, len)).copy(buf, 1);
+  }
+  return getHexStringFromBuffer(buf);
+}
+
+/**
+ * Unpacks a Buffer into a number.
+ */
+
+unpack = function(buffer) {
+  var n = 0;
+  for (var i = 0; i < buffer.length; ++i) {
+    n = (i == 0) ? buffer[i] : (n * 256) + buffer[i];
+  }
+  return n;
+}
+
+/**
+ * Returns a hex string, representing a specific byte count 'length', from a number.
+ */
+
+pack = function(length, number) {
+  return padl(number.toString(16), length, '0').replace(/([0-9a-f][0-9a-f])/gi, '$1 ').trim();
+}
+
+/**
+ * Left pads the string 's' to a total length of 'n' with char 'c'.
+ */
+
+padl = function(s, n, c) { 
+  return new Array(1 + n - s.length).join(c) + s;
+}

node_modules/streamws/test/testserver.js

@@ -0,0 +1,168 @@
+var http = require('http')
+  , util = require('util')
+  , crypto = require('crypto')
+  , events = require('events')
+  , Sender = require('../lib/Sender')
+  , Receiver = require('../lib/Receiver');
+
+module.exports = {
+  handlers: {
+    valid: validServer,
+    invalidKey: invalidRequestHandler,
+    closeAfterConnect: closeAfterConnectHandler
+  },
+  createServer: function(port, handler, cb) {
+    if (handler && !cb) {
+      cb = handler;
+      handler = null;
+    }
+    var webServer = http.createServer(function (req, res) {
+      res.writeHead(200, {'Content-Type': 'text/plain'});
+      res.end('okay');
+    });
+    var srv = new Server(webServer);
+    webServer.on('upgrade', function(req, socket) {
+      webServer._socket = socket;
+      (handler || validServer)(srv, req, socket);
+    });
+    webServer.listen(port, '127.0.0.1', function() { cb(srv); });
+  }
+};
+
+/**
+ * Test strategies
+ */
+
+function validServer(server, req, socket) {
+  if (typeof req.headers.upgrade === 'undefined' ||
+    req.headers.upgrade.toLowerCase() !== 'websocket') {
+    throw new Error('invalid headers');
+    return;
+  }
+
+  if (!req.headers['sec-websocket-key']) {
+    socket.end();
+    throw new Error('websocket key is missing');
+  }
+
+  // calc key
+  var key = req.headers['sec-websocket-key'];
+  var shasum = crypto.createHash('sha1');
+  shasum.update(key + "258EAFA5-E914-47DA-95CA-C5AB0DC85B11");
+  key = shasum.digest('base64');
+
+  var headers = [
+      'HTTP/1.1 101 Switching Protocols'
+    , 'Upgrade: websocket'
+    , 'Connection: Upgrade'
+    , 'Sec-WebSocket-Accept: ' + key
+  ];
+
+  socket.write(headers.concat('', '').join('\r\n'));
+  socket.setTimeout(0);
+  socket.setNoDelay(true);
+
+  var sender = new Sender(socket);
+  var receiver = new Receiver();
+  receiver.ontext = function (message, flags) {
+    server.emit('message', message, flags);
+    sender.send(message);
+  };
+  receiver.onbinary = function (message, flags) {
+    flags = flags || {};
+    flags.binary = true;
+    server.emit('message', message, flags);
+    sender.send(message, {binary: true});
+  };
+  receiver.onping = function (message, flags) {
+    flags = flags || {};
+    server.emit('ping', message, flags);
+  };
+  receiver.onpong = function (message, flags) {
+    flags = flags || {};
+    server.emit('pong', message, flags);
+  };
+  receiver.onclose = function (code, message, flags) {
+    flags = flags || {};
+    server.emit('close', code, message, flags);
+  };
+  socket.on('data', function (data) {
+    receiver.add(data);
+  });
+  socket.on('end', function() {
+    socket.end();
+  });
+}
+
+function invalidRequestHandler(server, req, socket) {
+  if (typeof req.headers.upgrade === 'undefined' ||
+    req.headers.upgrade.toLowerCase() !== 'websocket') {
+    throw new Error('invalid headers');
+    return;
+  }
+
+  if (!req.headers['sec-websocket-key']) {
+    socket.end();
+    throw new Error('websocket key is missing');
+  }
+
+  // calc key
+  var key = req.headers['sec-websocket-key'];
+  var shasum = crypto.createHash('sha1');
+  shasum.update(key + "bogus");
+  key = shasum.digest('base64');
+
+  var headers = [
+      'HTTP/1.1 101 Switching Protocols'
+    , 'Upgrade: websocket'
+    , 'Connection: Upgrade'
+    , 'Sec-WebSocket-Accept: ' + key
+  ];
+
+  socket.write(headers.concat('', '').join('\r\n'));
+  socket.end();
+}
+
+function closeAfterConnectHandler(server, req, socket) {
+  if (typeof req.headers.upgrade === 'undefined' ||
+    req.headers.upgrade.toLowerCase() !== 'websocket') {
+    throw new Error('invalid headers');
+    return;
+  }
+
+  if (!req.headers['sec-websocket-key']) {
+    socket.end();
+    throw new Error('websocket key is missing');
+  }
+
+  // calc key
+  var key = req.headers['sec-websocket-key'];
+  var shasum = crypto.createHash('sha1');
+  shasum.update(key + "258EAFA5-E914-47DA-95CA-C5AB0DC85B11");
+  key = shasum.digest('base64');
+
+  var headers = [
+      'HTTP/1.1 101 Switching Protocols'
+    , 'Upgrade: websocket'
+    , 'Connection: Upgrade'
+    , 'Sec-WebSocket-Accept: ' + key
+  ];
+
+  socket.write(headers.concat('', '').join('\r\n'));
+  socket.end();
+}
+
+/**
+ * Server object, which will do the actual emitting
+ */
+
+function Server(webServer) {
+  this.webServer = webServer;
+}
+
+util.inherits(Server, events.EventEmitter);
+
+Server.prototype.close = function() {
+  this.webServer.close();
+  if (this._socket) this._socket.end();
+}