src/third_party/closure_library/closure/goog/crypt/blobhasher_test.js - incubator-pagespeed-debian - Git at Google

 // Copyright 2011 The Closure Library Authors. All Rights Reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //      http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS-IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.

 goog.provide('goog.crypt.BlobHasherTest');
 goog.setTestOnly('goog.crypt.BlobHasherTest');

 goog.require('goog.crypt');
 goog.require('goog.crypt.BlobHasher');
 goog.require('goog.crypt.Md5');
 goog.require('goog.events');
 goog.require('goog.testing.PropertyReplacer');
 goog.require('goog.testing.jsunit');

 // A browser-independent mock of goog.fs.sliceBlob. The actual implementation
 // calls the underlying slice method differently based on browser version.
 // This mock does not support negative opt_end.
 var fsSliceBlobMock = function(blob, start, opt_end) {
   if (!goog.isNumber(opt_end)) {
     opt_end = blob.size;
   }
   return blob.slice(start, opt_end);
 };

 // Mock out the Blob using a string.
 BlobMock = function(string) {
   this.data = string;
   this.size = this.data.length;
 };

 BlobMock.prototype.slice = function(start, end) {
   return new BlobMock(this.data.substr(start, end - start));
 };


 // Mock out the FileReader to have control over the flow.
 FileReaderMock = function() {
   this.array_ = [];
   this.result = null;
   this.readyState = this.EMPTY;

   this.onload = null;
   this.onabort = null;
   this.onerror = null;
 };

 FileReaderMock.prototype.EMPTY = 0;
 FileReaderMock.prototype.LOADING = 1;
 FileReaderMock.prototype.DONE = 2;

 FileReaderMock.prototype.mockLoad = function() {
   this.readyState = this.DONE;
   this.result = this.array_;
   if (this.onload) {
     this.onload.call();
   }
 };

 FileReaderMock.prototype.abort = function() {
   this.readyState = this.DONE;
   if (this.onabort) {
     this.onabort.call();
   }
 };

 FileReaderMock.prototype.mockError = function() {
   this.readyState = this.DONE;
   if (this.onerror) {
     this.onerror.call();
   }
 };

 FileReaderMock.prototype.readAsArrayBuffer = function(blobMock) {
   this.readyState = this.LOADING;
   this.array_ = [];
   for (var i = 0; i < blobMock.size; ++i) {
     this.array_[i] = blobMock.data.charCodeAt(i);
   }
 };

 FileReaderMock.prototype.isLoading = function() {
   return this.readyState == this.LOADING;
 };

 var stubs = new goog.testing.PropertyReplacer();
 function setUp() {
   stubs.set(goog.global, 'FileReader', FileReaderMock);
   stubs.set(goog.fs, 'sliceBlob', fsSliceBlobMock);
 }

 function tearDown() {
   stubs.reset();
 }


 /**
  * Makes the blobHasher read chunks from the blob and hash it. The number of
  * reads shall not exceed a pre-determined number (typically blob size / chunk
  * size) for computing hash. This function fails fast (after maxReads is
  * reached), assuming that the hasher failed to generate hashes. This prevents
  * the test suite from going into infinite loop.
  * @param {!goog.crypt.BlobHasher} blobHasher Hasher in action.
  * @param {number} maxReads Max number of read attempts.
  */
 function readFromBlob(blobHasher, maxReads) {
   var counter = 0;
   while (blobHasher.fileReader_ && blobHasher.fileReader_.isLoading() &&
          counter <= maxReads) {
     blobHasher.fileReader_.mockLoad();
     counter++;
   }
   assertTrue(counter <= maxReads);
   return counter;
 }

 function testBasicOperations() {
   if (!window.Blob) {
     return;
   }

   // Test hashing with one chunk.
   var hashFn = new goog.crypt.Md5();
   var blobHasher = new goog.crypt.BlobHasher(hashFn);
   var blob = new BlobMock('The quick brown fox jumps over the lazy dog');
   blobHasher.hash(blob);
   readFromBlob(blobHasher, 1);
   assertEquals('9e107d9d372bb6826bd81d3542a419d6',
                goog.crypt.byteArrayToHex(blobHasher.getHash()));

   // Test hashing with multiple chunks.
   blobHasher = new goog.crypt.BlobHasher(hashFn, 7);
   blobHasher.hash(blob);
   readFromBlob(blobHasher, Math.ceil(blob.size / 7));
   assertEquals('9e107d9d372bb6826bd81d3542a419d6',
                goog.crypt.byteArrayToHex(blobHasher.getHash()));

   // Test hashing with no chunks.
   blob = new BlobMock('');
   blobHasher.hash(blob);
   readFromBlob(blobHasher, 1);
   assertEquals('d41d8cd98f00b204e9800998ecf8427e',
                goog.crypt.byteArrayToHex(blobHasher.getHash()));

 }

 function testNormalFlow() {
   if (!window.Blob) {
     return;
   }

   // Test the flow with one chunk.
   var hashFn = new goog.crypt.Md5();
   var blobHasher = new goog.crypt.BlobHasher(hashFn, 13);
   var blob = new BlobMock('short');
   var startedEvents = 0;
   var progressEvents = 0;
   var completeEvents = 0;
   goog.events.listen(blobHasher, goog.crypt.BlobHasher.EventType.STARTED,
                      function() { ++startedEvents; });
   goog.events.listen(blobHasher, goog.crypt.BlobHasher.EventType.PROGRESS,
                      function() { ++progressEvents; });
   goog.events.listen(blobHasher, goog.crypt.BlobHasher.EventType.COMPLETE,
                      function() { ++completeEvents; });
   blobHasher.hash(blob);
   assertEquals(1, startedEvents);
   assertEquals(0, progressEvents);
   assertEquals(0, completeEvents);
   readFromBlob(blobHasher, 1);
   assertEquals(1, startedEvents);
   assertEquals(1, progressEvents);
   assertEquals(1, completeEvents);

   // Test the flow with multiple chunks.
   blob = new BlobMock('The quick brown fox jumps over the lazy dog');
   startedEvents = 0;
   progressEvents = 0;
   completeEvents = 0;
   var progressLoops = 0;
   blobHasher.hash(blob);
   assertEquals(1, startedEvents);
   assertEquals(0, progressEvents);
   assertEquals(0, completeEvents);
   progressLoops = readFromBlob(blobHasher, Math.ceil(blob.size / 13));
   assertEquals(1, startedEvents);
   assertEquals(progressLoops, progressEvents);
   assertEquals(1, completeEvents);
 }

 function testAbortsAndErrors() {
   if (!window.Blob) {
     return;
   }

   var hashFn = new goog.crypt.Md5();
   var blobHasher = new goog.crypt.BlobHasher(hashFn, 13);
   var blob = new BlobMock('The quick brown fox jumps over the lazy dog');
   var abortEvents = 0;
   var errorEvents = 0;
   var completeEvents = 0;
   goog.events.listen(blobHasher, goog.crypt.BlobHasher.EventType.ABORT,
                      function() { ++abortEvents; });
   goog.events.listen(blobHasher, goog.crypt.BlobHasher.EventType.ERROR,
                      function() { ++errorEvents; });
   goog.events.listen(blobHasher, goog.crypt.BlobHasher.EventType.COMPLETE,
                      function() { ++completeEvents; });

   // Immediate abort.
   blobHasher.hash(blob);
   assertEquals(0, abortEvents);
   assertEquals(0, errorEvents);
   assertEquals(0, completeEvents);
   blobHasher.abort();
   blobHasher.abort();
   assertEquals(1, abortEvents);
   assertEquals(0, errorEvents);
   assertEquals(0, completeEvents);
   abortEvents = 0;

   // Delayed abort.
   blobHasher.hash(blob);
   blobHasher.fileReader_.mockLoad();
   assertEquals(0, abortEvents);
   assertEquals(0, errorEvents);
   assertEquals(0, completeEvents);
   blobHasher.abort();
   blobHasher.abort();
   assertEquals(1, abortEvents);
   assertEquals(0, errorEvents);
   assertEquals(0, completeEvents);
   abortEvents = 0;

   // Immediate error.
   blobHasher.hash(blob);
   blobHasher.fileReader_.mockError();
   assertEquals(0, abortEvents);
   assertEquals(1, errorEvents);
   assertEquals(0, completeEvents);
   errorEvents = 0;

   // Delayed error.
   blobHasher.hash(blob);
   blobHasher.fileReader_.mockLoad();
   blobHasher.fileReader_.mockError();
   assertEquals(0, abortEvents);
   assertEquals(1, errorEvents);
   assertEquals(0, completeEvents);
   abortEvents = 0;

 }

 function testBasicThrottling() {
   if (!window.Blob) {
     return;
   }

   var hashFn = new goog.crypt.Md5();
   var blobHasher = new goog.crypt.BlobHasher(hashFn, 5);
   var blob = new BlobMock('The quick brown fox jumps over the lazy dog');
   var throttledEvents = 0;
   var completeEvents = 0;
   goog.events.listen(blobHasher, goog.crypt.BlobHasher.EventType.THROTTLED,
                      function() { ++throttledEvents; });
   goog.events.listen(blobHasher, goog.crypt.BlobHasher.EventType.COMPLETE,
                      function() { ++completeEvents; });

   // Start a throttled hash. No chunks should be processed yet.
   blobHasher.setHashingLimit(0);
   assertEquals(0, throttledEvents);
   blobHasher.hash(blob);
   assertEquals(1, throttledEvents);
   assertEquals(0, blobHasher.getBytesProcessed());
   assertNull(blobHasher.fileReader_);

   // One chunk should be processed.
   blobHasher.setHashingLimit(4);
   assertEquals(1, throttledEvents);
   assertEquals(1, readFromBlob(blobHasher, 1));
   assertEquals(2, throttledEvents);
   assertEquals(4, blobHasher.getBytesProcessed());

   // One more chunk should be processed.
   blobHasher.setHashingLimit(5);
   assertEquals(2, throttledEvents);
   assertEquals(1, readFromBlob(blobHasher, 1));
   assertEquals(3, throttledEvents);
   assertEquals(5, blobHasher.getBytesProcessed());

   // Two more chunks should be processed.
   blobHasher.setHashingLimit(15);
   assertEquals(3, throttledEvents);
   assertEquals(2, readFromBlob(blobHasher, 2));
   assertEquals(4, throttledEvents);
   assertEquals(15, blobHasher.getBytesProcessed());

   // The entire blob should be processed.
   blobHasher.setHashingLimit(Infinity);
   var expectedChunks = Math.ceil(blob.size / 5) - 3;
   assertEquals(expectedChunks, readFromBlob(blobHasher, expectedChunks));
   assertEquals(4, throttledEvents);
   assertEquals(1, completeEvents);
   assertEquals('9e107d9d372bb6826bd81d3542a419d6',
                goog.crypt.byteArrayToHex(blobHasher.getHash()));
 }

 function testLengthZeroThrottling() {
   if (!window.Blob) {
     return;
   }

   var hashFn = new goog.crypt.Md5();
   var blobHasher = new goog.crypt.BlobHasher(hashFn);
   var throttledEvents = 0;
   var completeEvents = 0;
   goog.events.listen(blobHasher, goog.crypt.BlobHasher.EventType.THROTTLED,
                      function() { ++throttledEvents; });
   goog.events.listen(blobHasher, goog.crypt.BlobHasher.EventType.COMPLETE,
                      function() { ++completeEvents; });

   // Test throttling with length 0 blob.
   var blob = new BlobMock('');
   blobHasher.setHashingLimit(0);
   blobHasher.hash(blob);
   assertEquals(0, throttledEvents);
   assertEquals(1, completeEvents);
   assertEquals('d41d8cd98f00b204e9800998ecf8427e',
                goog.crypt.byteArrayToHex(blobHasher.getHash()));
 }

 function testAbortsAndErrorsWhileThrottling() {
   if (!window.Blob) {
     return;
   }

   var hashFn = new goog.crypt.Md5();
   var blobHasher = new goog.crypt.BlobHasher(hashFn, 5);
   var blob = new BlobMock('The quick brown fox jumps over the lazy dog');
   var abortEvents = 0;
   var errorEvents = 0;
   var throttledEvents = 0;
   var completeEvents = 0;
   goog.events.listen(blobHasher, goog.crypt.BlobHasher.EventType.ABORT,
                      function() { ++abortEvents; });
   goog.events.listen(blobHasher, goog.crypt.BlobHasher.EventType.ERROR,
                      function() { ++errorEvents; });
   goog.events.listen(blobHasher, goog.crypt.BlobHasher.EventType.THROTTLED,
                      function() { ++throttledEvents; });
   goog.events.listen(blobHasher, goog.crypt.BlobHasher.EventType.COMPLETE,
                      function() { ++completeEvents; });

   // Test that processing cannot be continued after abort.
   blobHasher.setHashingLimit(0);
   blobHasher.hash(blob);
   assertEquals(1, throttledEvents);
   blobHasher.abort();
   assertEquals(1, abortEvents);
   blobHasher.setHashingLimit(10);
   assertNull(blobHasher.fileReader_);
   assertEquals(1, throttledEvents);
   assertEquals(0, completeEvents);
   assertNull(blobHasher.getHash());

   // Test that processing cannot be continued after error.
   blobHasher.hash(blob);
   assertEquals(1, throttledEvents);
   blobHasher.fileReader_.mockError();
   assertEquals(1, errorEvents);
   blobHasher.setHashingLimit(100);
   assertNull(blobHasher.fileReader_);
   assertEquals(1, throttledEvents);
   assertEquals(0, completeEvents);
   assertNull(blobHasher.getHash());
 }
	// Copyright 2011 The Closure Library Authors. All Rights Reserved.
	//
	// Licensed under the Apache License, Version 2.0 (the "License");
	// you may not use this file except in compliance with the License.
	// You may obtain a copy of the License at
	//
	// http://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing, software
	// distributed under the License is distributed on an "AS-IS" BASIS,
	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	// See the License for the specific language governing permissions and
	// limitations under the License.

	goog.provide('goog.crypt.BlobHasherTest');
	goog.setTestOnly('goog.crypt.BlobHasherTest');

	goog.require('goog.crypt');
	goog.require('goog.crypt.BlobHasher');
	goog.require('goog.crypt.Md5');
	goog.require('goog.events');
	goog.require('goog.testing.PropertyReplacer');
	goog.require('goog.testing.jsunit');

	// A browser-independent mock of goog.fs.sliceBlob. The actual implementation
	// calls the underlying slice method differently based on browser version.
	// This mock does not support negative opt_end.
	var fsSliceBlobMock = function(blob, start, opt_end) {
	if (!goog.isNumber(opt_end)) {
	opt_end = blob.size;
	}
	return blob.slice(start, opt_end);
	};

	// Mock out the Blob using a string.
	BlobMock = function(string) {
	this.data = string;
	this.size = this.data.length;
	};

	BlobMock.prototype.slice = function(start, end) {
	return new BlobMock(this.data.substr(start, end - start));
	};


	// Mock out the FileReader to have control over the flow.
	FileReaderMock = function() {
	this.array_ = [];
	this.result = null;
	this.readyState = this.EMPTY;

	this.onload = null;
	this.onabort = null;
	this.onerror = null;
	};

	FileReaderMock.prototype.EMPTY = 0;
	FileReaderMock.prototype.LOADING = 1;
	FileReaderMock.prototype.DONE = 2;

	FileReaderMock.prototype.mockLoad = function() {
	this.readyState = this.DONE;
	this.result = this.array_;
	if (this.onload) {
	this.onload.call();
	}
	};

	FileReaderMock.prototype.abort = function() {
	this.readyState = this.DONE;
	if (this.onabort) {
	this.onabort.call();
	}
	};

	FileReaderMock.prototype.mockError = function() {
	this.readyState = this.DONE;
	if (this.onerror) {
	this.onerror.call();
	}
	};

	FileReaderMock.prototype.readAsArrayBuffer = function(blobMock) {
	this.readyState = this.LOADING;
	this.array_ = [];
	for (var i = 0; i < blobMock.size; ++i) {
	this.array_[i] = blobMock.data.charCodeAt(i);
	}
	};

	FileReaderMock.prototype.isLoading = function() {
	return this.readyState == this.LOADING;
	};

	var stubs = new goog.testing.PropertyReplacer();
	function setUp() {
	stubs.set(goog.global, 'FileReader', FileReaderMock);
	stubs.set(goog.fs, 'sliceBlob', fsSliceBlobMock);
	}

	function tearDown() {
	stubs.reset();
	}


	/**
	* Makes the blobHasher read chunks from the blob and hash it. The number of
	* reads shall not exceed a pre-determined number (typically blob size / chunk
	* size) for computing hash. This function fails fast (after maxReads is
	* reached), assuming that the hasher failed to generate hashes. This prevents
	* the test suite from going into infinite loop.
	* @param {!goog.crypt.BlobHasher} blobHasher Hasher in action.
	* @param {number} maxReads Max number of read attempts.
	*/
	function readFromBlob(blobHasher, maxReads) {
	var counter = 0;
	while (blobHasher.fileReader_ && blobHasher.fileReader_.isLoading() &&
	counter <= maxReads) {
	blobHasher.fileReader_.mockLoad();
	counter++;
	}
	assertTrue(counter <= maxReads);
	return counter;
	}

	function testBasicOperations() {
	if (!window.Blob) {
	return;
	}

	// Test hashing with one chunk.
	var hashFn = new goog.crypt.Md5();
	var blobHasher = new goog.crypt.BlobHasher(hashFn);
	var blob = new BlobMock('The quick brown fox jumps over the lazy dog');
	blobHasher.hash(blob);
	readFromBlob(blobHasher, 1);
	assertEquals('9e107d9d372bb6826bd81d3542a419d6',
	goog.crypt.byteArrayToHex(blobHasher.getHash()));

	// Test hashing with multiple chunks.
	blobHasher = new goog.crypt.BlobHasher(hashFn, 7);
	blobHasher.hash(blob);
	readFromBlob(blobHasher, Math.ceil(blob.size / 7));
	assertEquals('9e107d9d372bb6826bd81d3542a419d6',
	goog.crypt.byteArrayToHex(blobHasher.getHash()));

	// Test hashing with no chunks.
	blob = new BlobMock('');
	blobHasher.hash(blob);
	readFromBlob(blobHasher, 1);
	assertEquals('d41d8cd98f00b204e9800998ecf8427e',
	goog.crypt.byteArrayToHex(blobHasher.getHash()));

	}

	function testNormalFlow() {
	if (!window.Blob) {
	return;
	}

	// Test the flow with one chunk.
	var hashFn = new goog.crypt.Md5();
	var blobHasher = new goog.crypt.BlobHasher(hashFn, 13);
	var blob = new BlobMock('short');
	var startedEvents = 0;
	var progressEvents = 0;
	var completeEvents = 0;
	goog.events.listen(blobHasher, goog.crypt.BlobHasher.EventType.STARTED,
	function() { ++startedEvents; });
	goog.events.listen(blobHasher, goog.crypt.BlobHasher.EventType.PROGRESS,
	function() { ++progressEvents; });
	goog.events.listen(blobHasher, goog.crypt.BlobHasher.EventType.COMPLETE,
	function() { ++completeEvents; });
	blobHasher.hash(blob);
	assertEquals(1, startedEvents);
	assertEquals(0, progressEvents);
	assertEquals(0, completeEvents);
	readFromBlob(blobHasher, 1);
	assertEquals(1, startedEvents);
	assertEquals(1, progressEvents);
	assertEquals(1, completeEvents);

	// Test the flow with multiple chunks.
	blob = new BlobMock('The quick brown fox jumps over the lazy dog');
	startedEvents = 0;
	progressEvents = 0;
	completeEvents = 0;
	var progressLoops = 0;
	blobHasher.hash(blob);
	assertEquals(1, startedEvents);
	assertEquals(0, progressEvents);
	assertEquals(0, completeEvents);
	progressLoops = readFromBlob(blobHasher, Math.ceil(blob.size / 13));
	assertEquals(1, startedEvents);
	assertEquals(progressLoops, progressEvents);
	assertEquals(1, completeEvents);
	}

	function testAbortsAndErrors() {
	if (!window.Blob) {
	return;
	}

	var hashFn = new goog.crypt.Md5();
	var blobHasher = new goog.crypt.BlobHasher(hashFn, 13);
	var blob = new BlobMock('The quick brown fox jumps over the lazy dog');
	var abortEvents = 0;
	var errorEvents = 0;
	var completeEvents = 0;
	goog.events.listen(blobHasher, goog.crypt.BlobHasher.EventType.ABORT,
	function() { ++abortEvents; });
	goog.events.listen(blobHasher, goog.crypt.BlobHasher.EventType.ERROR,
	function() { ++errorEvents; });
	goog.events.listen(blobHasher, goog.crypt.BlobHasher.EventType.COMPLETE,
	function() { ++completeEvents; });

	// Immediate abort.
	blobHasher.hash(blob);
	assertEquals(0, abortEvents);
	assertEquals(0, errorEvents);
	assertEquals(0, completeEvents);
	blobHasher.abort();
	blobHasher.abort();
	assertEquals(1, abortEvents);
	assertEquals(0, errorEvents);
	assertEquals(0, completeEvents);
	abortEvents = 0;

	// Delayed abort.
	blobHasher.hash(blob);
	blobHasher.fileReader_.mockLoad();
	assertEquals(0, abortEvents);
	assertEquals(0, errorEvents);
	assertEquals(0, completeEvents);
	blobHasher.abort();
	blobHasher.abort();
	assertEquals(1, abortEvents);
	assertEquals(0, errorEvents);
	assertEquals(0, completeEvents);
	abortEvents = 0;

	// Immediate error.
	blobHasher.hash(blob);
	blobHasher.fileReader_.mockError();
	assertEquals(0, abortEvents);
	assertEquals(1, errorEvents);
	assertEquals(0, completeEvents);
	errorEvents = 0;

	// Delayed error.
	blobHasher.hash(blob);
	blobHasher.fileReader_.mockLoad();
	blobHasher.fileReader_.mockError();
	assertEquals(0, abortEvents);
	assertEquals(1, errorEvents);
	assertEquals(0, completeEvents);
	abortEvents = 0;

	}

	function testBasicThrottling() {
	if (!window.Blob) {
	return;
	}

	var hashFn = new goog.crypt.Md5();
	var blobHasher = new goog.crypt.BlobHasher(hashFn, 5);
	var blob = new BlobMock('The quick brown fox jumps over the lazy dog');
	var throttledEvents = 0;
	var completeEvents = 0;
	goog.events.listen(blobHasher, goog.crypt.BlobHasher.EventType.THROTTLED,
	function() { ++throttledEvents; });
	goog.events.listen(blobHasher, goog.crypt.BlobHasher.EventType.COMPLETE,
	function() { ++completeEvents; });

	// Start a throttled hash. No chunks should be processed yet.
	blobHasher.setHashingLimit(0);
	assertEquals(0, throttledEvents);
	blobHasher.hash(blob);
	assertEquals(1, throttledEvents);
	assertEquals(0, blobHasher.getBytesProcessed());
	assertNull(blobHasher.fileReader_);

	// One chunk should be processed.
	blobHasher.setHashingLimit(4);
	assertEquals(1, throttledEvents);
	assertEquals(1, readFromBlob(blobHasher, 1));
	assertEquals(2, throttledEvents);
	assertEquals(4, blobHasher.getBytesProcessed());

	// One more chunk should be processed.
	blobHasher.setHashingLimit(5);
	assertEquals(2, throttledEvents);
	assertEquals(1, readFromBlob(blobHasher, 1));
	assertEquals(3, throttledEvents);
	assertEquals(5, blobHasher.getBytesProcessed());

	// Two more chunks should be processed.
	blobHasher.setHashingLimit(15);
	assertEquals(3, throttledEvents);
	assertEquals(2, readFromBlob(blobHasher, 2));
	assertEquals(4, throttledEvents);
	assertEquals(15, blobHasher.getBytesProcessed());

	// The entire blob should be processed.
	blobHasher.setHashingLimit(Infinity);
	var expectedChunks = Math.ceil(blob.size / 5) - 3;
	assertEquals(expectedChunks, readFromBlob(blobHasher, expectedChunks));
	assertEquals(4, throttledEvents);
	assertEquals(1, completeEvents);
	assertEquals('9e107d9d372bb6826bd81d3542a419d6',
	goog.crypt.byteArrayToHex(blobHasher.getHash()));
	}

	function testLengthZeroThrottling() {
	if (!window.Blob) {
	return;
	}

	var hashFn = new goog.crypt.Md5();
	var blobHasher = new goog.crypt.BlobHasher(hashFn);
	var throttledEvents = 0;
	var completeEvents = 0;
	goog.events.listen(blobHasher, goog.crypt.BlobHasher.EventType.THROTTLED,
	function() { ++throttledEvents; });
	goog.events.listen(blobHasher, goog.crypt.BlobHasher.EventType.COMPLETE,
	function() { ++completeEvents; });

	// Test throttling with length 0 blob.
	var blob = new BlobMock('');
	blobHasher.setHashingLimit(0);
	blobHasher.hash(blob);
	assertEquals(0, throttledEvents);
	assertEquals(1, completeEvents);
	assertEquals('d41d8cd98f00b204e9800998ecf8427e',
	goog.crypt.byteArrayToHex(blobHasher.getHash()));
	}

	function testAbortsAndErrorsWhileThrottling() {
	if (!window.Blob) {
	return;
	}

	var hashFn = new goog.crypt.Md5();
	var blobHasher = new goog.crypt.BlobHasher(hashFn, 5);
	var blob = new BlobMock('The quick brown fox jumps over the lazy dog');
	var abortEvents = 0;
	var errorEvents = 0;
	var throttledEvents = 0;
	var completeEvents = 0;
	goog.events.listen(blobHasher, goog.crypt.BlobHasher.EventType.ABORT,
	function() { ++abortEvents; });
	goog.events.listen(blobHasher, goog.crypt.BlobHasher.EventType.ERROR,
	function() { ++errorEvents; });
	goog.events.listen(blobHasher, goog.crypt.BlobHasher.EventType.THROTTLED,
	function() { ++throttledEvents; });
	goog.events.listen(blobHasher, goog.crypt.BlobHasher.EventType.COMPLETE,
	function() { ++completeEvents; });

	// Test that processing cannot be continued after abort.
	blobHasher.setHashingLimit(0);
	blobHasher.hash(blob);
	assertEquals(1, throttledEvents);
	blobHasher.abort();
	assertEquals(1, abortEvents);
	blobHasher.setHashingLimit(10);
	assertNull(blobHasher.fileReader_);
	assertEquals(1, throttledEvents);
	assertEquals(0, completeEvents);
	assertNull(blobHasher.getHash());

	// Test that processing cannot be continued after error.
	blobHasher.hash(blob);
	assertEquals(1, throttledEvents);
	blobHasher.fileReader_.mockError();
	assertEquals(1, errorEvents);
	blobHasher.setHashingLimit(100);
	assertNull(blobHasher.fileReader_);
	assertEquals(1, throttledEvents);
	assertEquals(0, completeEvents);
	assertNull(blobHasher.getHash());
	}