(function (QUnit,sinon) {
'use strict';

QUnit = 'default' in QUnit ? QUnit['default'] : QUnit;
sinon = 'default' in sinon ? sinon['default'] : sinon;

/*
 * pkcs7.pad
 * https://github.com/brightcove/pkcs7
 *
 * Copyright (c) 2014 Brightcove
 * Licensed under the apache2 license.
 */

var PADDING = void 0;

// pre-define the padding values
PADDING = [[16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16], [15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15], [14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14], [13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13], [12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12], [11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11], [10, 10, 10, 10, 10, 10, 10, 10, 10, 10], [9, 9, 9, 9, 9, 9, 9, 9, 9], [8, 8, 8, 8, 8, 8, 8, 8], [7, 7, 7, 7, 7, 7, 7], [6, 6, 6, 6, 6, 6], [5, 5, 5, 5, 5], [4, 4, 4, 4], [3, 3, 3], [2, 2], [1]];

/**
 * Returns the subarray of a Uint8Array without PKCS#7 padding.
 * @param padded {Uint8Array} unencrypted bytes that have been padded
 * @return {Uint8Array} the unpadded bytes
 * @see http://tools.ietf.org/html/rfc5652
 */
function unpad(padded) {
  return padded.subarray(0, padded.byteLength - padded[padded.byteLength - 1]);
}

var classCallCheck = function (instance, Constructor) {
  if (!(instance instanceof Constructor)) {
    throw new TypeError("Cannot call a class as a function");
  }
};

var createClass = function () {
  function defineProperties(target, props) {
    for (var i = 0; i < props.length; i++) {
      var descriptor = props[i];
      descriptor.enumerable = descriptor.enumerable || false;
      descriptor.configurable = true;
      if ("value" in descriptor) descriptor.writable = true;
      Object.defineProperty(target, descriptor.key, descriptor);
    }
  }

  return function (Constructor, protoProps, staticProps) {
    if (protoProps) defineProperties(Constructor.prototype, protoProps);
    if (staticProps) defineProperties(Constructor, staticProps);
    return Constructor;
  };
}();









var inherits = function (subClass, superClass) {
  if (typeof superClass !== "function" && superClass !== null) {
    throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
  }

  subClass.prototype = Object.create(superClass && superClass.prototype, {
    constructor: {
      value: subClass,
      enumerable: false,
      writable: true,
      configurable: true
    }
  });
  if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
};











var possibleConstructorReturn = function (self, call) {
  if (!self) {
    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
  }

  return call && (typeof call === "object" || typeof call === "function") ? call : self;
};

/**
 * @file aes.js
 *
 * This file contains an adaptation of the AES decryption algorithm
 * from the Standford Javascript Cryptography Library. That work is
 * covered by the following copyright and permissions notice:
 *
 * Copyright 2009-2010 Emily Stark, Mike Hamburg, Dan Boneh.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above
 *    copyright notice, this list of conditions and the following
 *    disclaimer in the documentation and/or other materials provided
 *    with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
 * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
 * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * The views and conclusions contained in the software and documentation
 * are those of the authors and should not be interpreted as representing
 * official policies, either expressed or implied, of the authors.
 */

/**
 * Expand the S-box tables.
 *
 * @private
 */
var precompute = function precompute() {
  var tables = [[[], [], [], [], []], [[], [], [], [], []]];
  var encTable = tables[0];
  var decTable = tables[1];
  var sbox = encTable[4];
  var sboxInv = decTable[4];
  var i = void 0;
  var x = void 0;
  var xInv = void 0;
  var d = [];
  var th = [];
  var x2 = void 0;
  var x4 = void 0;
  var x8 = void 0;
  var s = void 0;
  var tEnc = void 0;
  var tDec = void 0;

  // Compute double and third tables
  for (i = 0; i < 256; i++) {
    th[(d[i] = i << 1 ^ (i >> 7) * 283) ^ i] = i;
  }

  for (x = xInv = 0; !sbox[x]; x ^= x2 || 1, xInv = th[xInv] || 1) {
    // Compute sbox
    s = xInv ^ xInv << 1 ^ xInv << 2 ^ xInv << 3 ^ xInv << 4;
    s = s >> 8 ^ s & 255 ^ 99;
    sbox[x] = s;
    sboxInv[s] = x;

    // Compute MixColumns
    x8 = d[x4 = d[x2 = d[x]]];
    tDec = x8 * 0x1010101 ^ x4 * 0x10001 ^ x2 * 0x101 ^ x * 0x1010100;
    tEnc = d[s] * 0x101 ^ s * 0x1010100;

    for (i = 0; i < 4; i++) {
      encTable[i][x] = tEnc = tEnc << 24 ^ tEnc >>> 8;
      decTable[i][s] = tDec = tDec << 24 ^ tDec >>> 8;
    }
  }

  // Compactify. Considerable speedup on Firefox.
  for (i = 0; i < 5; i++) {
    encTable[i] = encTable[i].slice(0);
    decTable[i] = decTable[i].slice(0);
  }
  return tables;
};
var aesTables = null;

/**
 * Schedule out an AES key for both encryption and decryption. This
 * is a low-level class. Use a cipher mode to do bulk encryption.
 *
 * @class AES
 * @param key {Array} The key as an array of 4, 6 or 8 words.
 */

var AES = function () {
  function AES(key) {
    classCallCheck(this, AES);

    /**
     * The expanded S-box and inverse S-box tables. These will be computed
     * on the client so that we don't have to send them down the wire.
     *
     * There are two tables, _tables[0] is for encryption and
     * _tables[1] is for decryption.
     *
     * The first 4 sub-tables are the expanded S-box with MixColumns. The
     * last (_tables[01][4]) is the S-box itself.
     *
     * @private
     */
    // if we have yet to precompute the S-box tables
    // do so now
    if (!aesTables) {
      aesTables = precompute();
    }
    // then make a copy of that object for use
    this._tables = [[aesTables[0][0].slice(), aesTables[0][1].slice(), aesTables[0][2].slice(), aesTables[0][3].slice(), aesTables[0][4].slice()], [aesTables[1][0].slice(), aesTables[1][1].slice(), aesTables[1][2].slice(), aesTables[1][3].slice(), aesTables[1][4].slice()]];
    var i = void 0;
    var j = void 0;
    var tmp = void 0;
    var encKey = void 0;
    var decKey = void 0;
    var sbox = this._tables[0][4];
    var decTable = this._tables[1];
    var keyLen = key.length;
    var rcon = 1;

    if (keyLen !== 4 && keyLen !== 6 && keyLen !== 8) {
      throw new Error('Invalid aes key size');
    }

    encKey = key.slice(0);
    decKey = [];
    this._key = [encKey, decKey];

    // schedule encryption keys
    for (i = keyLen; i < 4 * keyLen + 28; i++) {
      tmp = encKey[i - 1];

      // apply sbox
      if (i % keyLen === 0 || keyLen === 8 && i % keyLen === 4) {
        tmp = sbox[tmp >>> 24] << 24 ^ sbox[tmp >> 16 & 255] << 16 ^ sbox[tmp >> 8 & 255] << 8 ^ sbox[tmp & 255];

        // shift rows and add rcon
        if (i % keyLen === 0) {
          tmp = tmp << 8 ^ tmp >>> 24 ^ rcon << 24;
          rcon = rcon << 1 ^ (rcon >> 7) * 283;
        }
      }

      encKey[i] = encKey[i - keyLen] ^ tmp;
    }

    // schedule decryption keys
    for (j = 0; i; j++, i--) {
      tmp = encKey[j & 3 ? i : i - 4];
      if (i <= 4 || j < 4) {
        decKey[j] = tmp;
      } else {
        decKey[j] = decTable[0][sbox[tmp >>> 24]] ^ decTable[1][sbox[tmp >> 16 & 255]] ^ decTable[2][sbox[tmp >> 8 & 255]] ^ decTable[3][sbox[tmp & 255]];
      }
    }
  }

  /**
   * Decrypt 16 bytes, specified as four 32-bit words.
   *
   * @param {Number} encrypted0 the first word to decrypt
   * @param {Number} encrypted1 the second word to decrypt
   * @param {Number} encrypted2 the third word to decrypt
   * @param {Number} encrypted3 the fourth word to decrypt
   * @param {Int32Array} out the array to write the decrypted words
   * into
   * @param {Number} offset the offset into the output array to start
   * writing results
   * @return {Array} The plaintext.
   */


  AES.prototype.decrypt = function decrypt(encrypted0, encrypted1, encrypted2, encrypted3, out, offset) {
    var key = this._key[1];
    // state variables a,b,c,d are loaded with pre-whitened data
    var a = encrypted0 ^ key[0];
    var b = encrypted3 ^ key[1];
    var c = encrypted2 ^ key[2];
    var d = encrypted1 ^ key[3];
    var a2 = void 0;
    var b2 = void 0;
    var c2 = void 0;

    // key.length === 2 ?
    var nInnerRounds = key.length / 4 - 2;
    var i = void 0;
    var kIndex = 4;
    var table = this._tables[1];

    // load up the tables
    var table0 = table[0];
    var table1 = table[1];
    var table2 = table[2];
    var table3 = table[3];
    var sbox = table[4];

    // Inner rounds. Cribbed from OpenSSL.
    for (i = 0; i < nInnerRounds; i++) {
      a2 = table0[a >>> 24] ^ table1[b >> 16 & 255] ^ table2[c >> 8 & 255] ^ table3[d & 255] ^ key[kIndex];
      b2 = table0[b >>> 24] ^ table1[c >> 16 & 255] ^ table2[d >> 8 & 255] ^ table3[a & 255] ^ key[kIndex + 1];
      c2 = table0[c >>> 24] ^ table1[d >> 16 & 255] ^ table2[a >> 8 & 255] ^ table3[b & 255] ^ key[kIndex + 2];
      d = table0[d >>> 24] ^ table1[a >> 16 & 255] ^ table2[b >> 8 & 255] ^ table3[c & 255] ^ key[kIndex + 3];
      kIndex += 4;
      a = a2;b = b2;c = c2;
    }

    // Last round.
    for (i = 0; i < 4; i++) {
      out[(3 & -i) + offset] = sbox[a >>> 24] << 24 ^ sbox[b >> 16 & 255] << 16 ^ sbox[c >> 8 & 255] << 8 ^ sbox[d & 255] ^ key[kIndex++];
      a2 = a;a = b;b = c;c = d;d = a2;
    }
  };

  return AES;
}();

/**
 * @file stream.js
 */
/**
 * A lightweight readable stream implemention that handles event dispatching.
 *
 * @class Stream
 */
var Stream = function () {
  function Stream() {
    classCallCheck(this, Stream);

    this.listeners = {};
  }

  /**
   * Add a listener for a specified event type.
   *
   * @param {String} type the event name
   * @param {Function} listener the callback to be invoked when an event of
   * the specified type occurs
   */


  Stream.prototype.on = function on(type, listener) {
    if (!this.listeners[type]) {
      this.listeners[type] = [];
    }
    this.listeners[type].push(listener);
  };

  /**
   * Remove a listener for a specified event type.
   *
   * @param {String} type the event name
   * @param {Function} listener  a function previously registered for this
   * type of event through `on`
   * @return {Boolean} if we could turn it off or not
   */


  Stream.prototype.off = function off(type, listener) {
    if (!this.listeners[type]) {
      return false;
    }

    var index = this.listeners[type].indexOf(listener);

    this.listeners[type].splice(index, 1);
    return index > -1;
  };

  /**
   * Trigger an event of the specified type on this stream. Any additional
   * arguments to this function are passed as parameters to event listeners.
   *
   * @param {String} type the event name
   */


  Stream.prototype.trigger = function trigger(type) {
    var callbacks = this.listeners[type];

    if (!callbacks) {
      return;
    }

    // Slicing the arguments on every invocation of this method
    // can add a significant amount of overhead. Avoid the
    // intermediate object creation for the common case of a
    // single callback argument
    if (arguments.length === 2) {
      var length = callbacks.length;

      for (var i = 0; i < length; ++i) {
        callbacks[i].call(this, arguments[1]);
      }
    } else {
      var args = Array.prototype.slice.call(arguments, 1);
      var _length = callbacks.length;

      for (var _i = 0; _i < _length; ++_i) {
        callbacks[_i].apply(this, args);
      }
    }
  };

  /**
   * Destroys the stream and cleans up.
   */


  Stream.prototype.dispose = function dispose() {
    this.listeners = {};
  };
  /**
   * Forwards all `data` events on this stream to the destination stream. The
   * destination stream should provide a method `push` to receive the data
   * events as they arrive.
   *
   * @param {Stream} destination the stream that will receive all `data` events
   * @see http://nodejs.org/api/stream.html#stream_readable_pipe_destination_options
   */


  Stream.prototype.pipe = function pipe(destination) {
    this.on('data', function (data) {
      destination.push(data);
    });
  };

  return Stream;
}();

/**
 * @file async-stream.js
 */
/**
 * A wrapper around the Stream class to use setTiemout
 * and run stream "jobs" Asynchronously
 *
 * @class AsyncStream
 * @extends Stream
 */

var AsyncStream = function (_Stream) {
  inherits(AsyncStream, _Stream);

  function AsyncStream() {
    classCallCheck(this, AsyncStream);

    var _this = possibleConstructorReturn(this, _Stream.call(this, Stream));

    _this.jobs = [];
    _this.delay = 1;
    _this.timeout_ = null;
    return _this;
  }

  /**
   * process an async job
   *
   * @private
   */


  AsyncStream.prototype.processJob_ = function processJob_() {
    this.jobs.shift()();
    if (this.jobs.length) {
      this.timeout_ = setTimeout(this.processJob_.bind(this), this.delay);
    } else {
      this.timeout_ = null;
    }
  };

  /**
   * push a job into the stream
   *
   * @param {Function} job the job to push into the stream
   */


  AsyncStream.prototype.push = function push(job) {
    this.jobs.push(job);
    if (!this.timeout_) {
      this.timeout_ = setTimeout(this.processJob_.bind(this), this.delay);
    }
  };

  return AsyncStream;
}(Stream);

/**
 * @file decrypter.js
 *
 * An asynchronous implementation of AES-128 CBC decryption with
 * PKCS#7 padding.
 */

/**
 * Convert network-order (big-endian) bytes into their little-endian
 * representation.
 */
var ntoh = function ntoh(word) {
  return word << 24 | (word & 0xff00) << 8 | (word & 0xff0000) >> 8 | word >>> 24;
};

/**
 * Decrypt bytes using AES-128 with CBC and PKCS#7 padding.
 *
 * @param {Uint8Array} encrypted the encrypted bytes
 * @param {Uint32Array} key the bytes of the decryption key
 * @param {Uint32Array} initVector the initialization vector (IV) to
 * use for the first round of CBC.
 * @return {Uint8Array} the decrypted bytes
 *
 * @see http://en.wikipedia.org/wiki/Advanced_Encryption_Standard
 * @see http://en.wikipedia.org/wiki/Block_cipher_mode_of_operation#Cipher_Block_Chaining_.28CBC.29
 * @see https://tools.ietf.org/html/rfc2315
 */
var decrypt = function decrypt(encrypted, key, initVector) {
  // word-level access to the encrypted bytes
  var encrypted32 = new Int32Array(encrypted.buffer, encrypted.byteOffset, encrypted.byteLength >> 2);

  var decipher = new AES(Array.prototype.slice.call(key));

  // byte and word-level access for the decrypted output
  var decrypted = new Uint8Array(encrypted.byteLength);
  var decrypted32 = new Int32Array(decrypted.buffer);

  // temporary variables for working with the IV, encrypted, and
  // decrypted data
  var init0 = void 0;
  var init1 = void 0;
  var init2 = void 0;
  var init3 = void 0;
  var encrypted0 = void 0;
  var encrypted1 = void 0;
  var encrypted2 = void 0;
  var encrypted3 = void 0;

  // iteration variable
  var wordIx = void 0;

  // pull out the words of the IV to ensure we don't modify the
  // passed-in reference and easier access
  init0 = initVector[0];
  init1 = initVector[1];
  init2 = initVector[2];
  init3 = initVector[3];

  // decrypt four word sequences, applying cipher-block chaining (CBC)
  // to each decrypted block
  for (wordIx = 0; wordIx < encrypted32.length; wordIx += 4) {
    // convert big-endian (network order) words into little-endian
    // (javascript order)
    encrypted0 = ntoh(encrypted32[wordIx]);
    encrypted1 = ntoh(encrypted32[wordIx + 1]);
    encrypted2 = ntoh(encrypted32[wordIx + 2]);
    encrypted3 = ntoh(encrypted32[wordIx + 3]);

    // decrypt the block
    decipher.decrypt(encrypted0, encrypted1, encrypted2, encrypted3, decrypted32, wordIx);

    // XOR with the IV, and restore network byte-order to obtain the
    // plaintext
    decrypted32[wordIx] = ntoh(decrypted32[wordIx] ^ init0);
    decrypted32[wordIx + 1] = ntoh(decrypted32[wordIx + 1] ^ init1);
    decrypted32[wordIx + 2] = ntoh(decrypted32[wordIx + 2] ^ init2);
    decrypted32[wordIx + 3] = ntoh(decrypted32[wordIx + 3] ^ init3);

    // setup the IV for the next round
    init0 = encrypted0;
    init1 = encrypted1;
    init2 = encrypted2;
    init3 = encrypted3;
  }

  return decrypted;
};

/**
 * The `Decrypter` class that manages decryption of AES
 * data through `AsyncStream` objects and the `decrypt`
 * function
 *
 * @param {Uint8Array} encrypted the encrypted bytes
 * @param {Uint32Array} key the bytes of the decryption key
 * @param {Uint32Array} initVector the initialization vector (IV) to
 * @param {Function} done the function to run when done
 * @class Decrypter
 */

var Decrypter = function () {
  function Decrypter(encrypted, key, initVector, done) {
    classCallCheck(this, Decrypter);

    var step = Decrypter.STEP;
    var encrypted32 = new Int32Array(encrypted.buffer);
    var decrypted = new Uint8Array(encrypted.byteLength);
    var i = 0;

    this.asyncStream_ = new AsyncStream();

    // split up the encryption job and do the individual chunks asynchronously
    this.asyncStream_.push(this.decryptChunk_(encrypted32.subarray(i, i + step), key, initVector, decrypted));
    for (i = step; i < encrypted32.length; i += step) {
      initVector = new Uint32Array([ntoh(encrypted32[i - 4]), ntoh(encrypted32[i - 3]), ntoh(encrypted32[i - 2]), ntoh(encrypted32[i - 1])]);
      this.asyncStream_.push(this.decryptChunk_(encrypted32.subarray(i, i + step), key, initVector, decrypted));
    }
    // invoke the done() callback when everything is finished
    this.asyncStream_.push(function () {
      // remove pkcs#7 padding from the decrypted bytes
      done(null, unpad(decrypted));
    });
  }

  /**
   * a getter for step the maximum number of bytes to process at one time
   *
   * @return {Number} the value of step 32000
   */


  /**
   * @private
   */
  Decrypter.prototype.decryptChunk_ = function decryptChunk_(encrypted, key, initVector, decrypted) {
    return function () {
      var bytes = decrypt(encrypted, key, initVector);

      decrypted.set(bytes, encrypted.byteOffset);
    };
  };

  createClass(Decrypter, null, [{
    key: 'STEP',
    get: function get$$1() {
      // 4 * 8000;
      return 32000;
    }
  }]);
  return Decrypter;
}();

/**
 * @file index.js
 *
 * Index module to easily import the primary components of AES-128
 * decryption. Like this:
 *
 * ```js
 * import {Decrypter, decrypt, AsyncStream} from 'aes-decrypter';
 * ```
 */

// see docs/hlse.md for instructions on how test data was generated
// see docs/hlse.md for instructions on how test data was generated
var stringFromBytes = function stringFromBytes(bytes) {
  var result = '';

  for (var i = 0; i < bytes.length; i++) {
    result += String.fromCharCode(bytes[i]);
  }
  return result;
};

QUnit.module('Decryption');
QUnit.test('decrypts a single AES-128 with PKCS7 block', function (assert) {
  var key = new Uint32Array([0, 0, 0, 0]);
  var initVector = key;
  // the string "howdy folks" encrypted
  var encrypted = new Uint8Array([0xce, 0x90, 0x97, 0xd0, 0x08, 0x46, 0x4d, 0x18, 0x4f, 0xae, 0x01, 0x1c, 0x82, 0xa8, 0xf0, 0x67]);

  assert.deepEqual('howdy folks', stringFromBytes(unpad(decrypt(encrypted, key, initVector))), 'decrypted with a byte array key');
});

QUnit.test('decrypts multiple AES-128 blocks with CBC', function (assert) {
  var key = new Uint32Array([0, 0, 0, 0]);
  var initVector = key;
  // the string "0123456789abcdef01234" encrypted
  var encrypted = new Uint8Array([0x14, 0xf5, 0xfe, 0x74, 0x69, 0x66, 0xf2, 0x92, 0x65, 0x1c, 0x22, 0x88, 0xbb, 0xff, 0x46, 0x09, 0x0b, 0xde, 0x5e, 0x71, 0x77, 0x87, 0xeb, 0x84, 0xa9, 0x54, 0xc2, 0x45, 0xe9, 0x4e, 0x29, 0xb3]);

  assert.deepEqual('0123456789abcdef01234', stringFromBytes(unpad(decrypt(encrypted, key, initVector))), 'decrypted multiple blocks');
});

QUnit.test('verify that the deepcopy works by doing two decrypts in the same test', function (assert) {
  var key = new Uint32Array([0, 0, 0, 0]);
  var initVector = key;
  // the string "howdy folks" encrypted
  var pkcs7Block = new Uint8Array([0xce, 0x90, 0x97, 0xd0, 0x08, 0x46, 0x4d, 0x18, 0x4f, 0xae, 0x01, 0x1c, 0x82, 0xa8, 0xf0, 0x67]);

  assert.deepEqual('howdy folks', stringFromBytes(unpad(decrypt(pkcs7Block, key, initVector))), 'decrypted with a byte array key');

  // the string "0123456789abcdef01234" encrypted
  var cbcBlocks = new Uint8Array([0x14, 0xf5, 0xfe, 0x74, 0x69, 0x66, 0xf2, 0x92, 0x65, 0x1c, 0x22, 0x88, 0xbb, 0xff, 0x46, 0x09, 0x0b, 0xde, 0x5e, 0x71, 0x77, 0x87, 0xeb, 0x84, 0xa9, 0x54, 0xc2, 0x45, 0xe9, 0x4e, 0x29, 0xb3]);

  assert.deepEqual('0123456789abcdef01234', stringFromBytes(unpad(decrypt(cbcBlocks, key, initVector))), 'decrypted multiple blocks');
});

QUnit.module('Incremental Processing', {
  beforeEach: function beforeEach() {
    this.clock = sinon.useFakeTimers();
  },
  afterEach: function afterEach() {
    this.clock.restore();
  }
});

QUnit.test('executes a callback after a timeout', function (assert) {
  var asyncStream = new AsyncStream();
  var calls = '';

  asyncStream.push(function () {
    calls += 'a';
  });

  this.clock.tick(asyncStream.delay);
  assert.equal(calls, 'a', 'invoked the callback once');
  this.clock.tick(asyncStream.delay);
  assert.equal(calls, 'a', 'only invoked the callback once');
});

QUnit.test('executes callback in series', function (assert) {
  var asyncStream = new AsyncStream();
  var calls = '';

  asyncStream.push(function () {
    calls += 'a';
  });
  asyncStream.push(function () {
    calls += 'b';
  });

  this.clock.tick(asyncStream.delay);
  assert.equal(calls, 'a', 'invoked the first callback');
  this.clock.tick(asyncStream.delay);
  assert.equal(calls, 'ab', 'invoked the second');
});

QUnit.module('Incremental Decryption', {
  beforeEach: function beforeEach() {
    this.clock = sinon.useFakeTimers();
  },
  afterEach: function afterEach() {
    this.clock.restore();
  }
});

QUnit.test('asynchronously decrypts a 4-word block', function (assert) {
  var key = new Uint32Array([0, 0, 0, 0]);
  var initVector = key;
  // the string "howdy folks" encrypted
  var encrypted = new Uint8Array([0xce, 0x90, 0x97, 0xd0, 0x08, 0x46, 0x4d, 0x18, 0x4f, 0xae, 0x01, 0x1c, 0x82, 0xa8, 0xf0, 0x67]);
  var decrypted = void 0;
  var decrypter = new Decrypter(encrypted, key, initVector, function (error, result) {
    if (error) {
      throw new Error(error);
    }
    decrypted = result;
  });

  assert.ok(!decrypted, 'asynchronously decrypts');
  this.clock.tick(decrypter.asyncStream_.delay * 2);

  assert.ok(decrypted, 'completed decryption');
  assert.deepEqual('howdy folks', stringFromBytes(decrypted), 'decrypts and unpads the result');
});

QUnit.test('breaks up input greater than the step value', function (assert) {
  var encrypted = new Int32Array(Decrypter.STEP + 4);
  var done = false;
  var decrypter = new Decrypter(encrypted, new Uint32Array(4), new Uint32Array(4), function () {
    done = true;
  });

  this.clock.tick(decrypter.asyncStream_.delay * 2);
  assert.ok(!done, 'not finished after two ticks');

  this.clock.tick(decrypter.asyncStream_.delay);
  assert.ok(done, 'finished after the last chunk is decrypted');
});

}(QUnit,sinon));