src/third_party/web_platform_tests/FileAPI/blob/Blob-constructor.html - cobalt - Git at Google

 <!DOCTYPE html>
 <meta charset=utf-8>
 <title>Blob constructor</title>
 <link rel=help href="http://dev.w3.org/2006/webapi/FileAPI/#constructorBlob">
 <link rel=help href="https://heycam.github.io/webidl/#es-union">
 <link rel=help href="https://heycam.github.io/webidl/#es-dictionary">
 <link rel=help href="https://heycam.github.io/webidl/#es-sequence">
 <script src="/resources/testharness.js"></script>
 <script src="/resources/testharnessreport.js"></script>
 <script src="../support/Blob.js"></script>
 <p><strong><a href="https://www.w3.org/Bugs/Public/show_bug.cgi?id=23683">Discussion</a>
 is ongoing that will affect a number of the following tests.</strong>
 <div id="log"></div>
 <!-- used by "platform object that supports indexed properties" tests -->
 <iframe style="display:none"></iframe>
 <script>
 test(function() {
   assert_true("Blob" in window, "window should have a Blob property.");
   assert_equals(Blob.length, 0, "Blob.length should be 0.");
   assert_true(Blob instanceof Function, "Blob should be a function.");
 }, "Blob interface object");

 // Step 1.
 test(function() {
   var blob = new Blob();
   assert_true(blob instanceof Blob);
   assert_equals(String(blob), '[object Blob]');
   assert_equals(blob.size, 0);
   assert_equals(blob.type, "");
 }, "no-argument Blob constructor");
 test(function() {
   assert_throws(new TypeError(), function() { var blob = Blob(); });
 }, "no-argument Blob constructor without 'new'");
 test(function() {
   var blob = new Blob;
   assert_true(blob instanceof Blob);
   assert_equals(blob.size, 0);
   assert_equals(blob.type, "");
 }, "no-argument Blob constructor without brackets");

 // blobParts argument (WebIDL).
 test(function() {
   var args = [
     null,
     undefined,
     true,
     false,
     0,
     1,
     1.5,
     "FAIL",
     new Date(),
     new RegExp(),
   ];
   args.forEach(function(arg) {
     assert_throws(new TypeError(), function() {
       new Blob(arg);
     }, "Should throw for argument " + format_value(arg) + ".");
   });
 }, "Passing non-objects, Dates and RegExps for blobParts should throw a TypeError.");

 test_blob(function() {
   return new Blob({});
 }, {
   expected: "",
   type: "",
   desc: "A plain object should be treated as a sequence for the blobParts argument."
 });
 test_blob(function() {
   return new Blob({ 0: "PASS", length: 1 });
 }, {
   expected: "PASS",
   type: "",
   desc: "A plain object with a length property should be treated as a sequence for the blobParts argument."
 });
 test_blob(function() {
   return new Blob(new String("xyz"));
 }, {
   expected: "xyz",
   type: "",
   desc: "A String object should be treated as a sequence for the blobParts argument."
 });
 test_blob(function() {
   return new Blob(new Uint8Array([1, 2, 3]));
 }, {
   expected: "123",
   type: "",
   desc: "A Uint8Array object should be treated as a sequence for the blobParts argument."
 });

 var test_error = { name: "test" };

 test(function() {
   var obj = {
     get length() { throw test_error; }
   };
   assert_throws(test_error, function() {
     new Blob(obj);
   });
 }, "The length getter should be invoked and any exceptions should be propagated.");

 test_blob(function() {
   var element = document.createElement("div");
   element.appendChild(document.createElement("div"));
   element.appendChild(document.createElement("p"));
   var list = element.children;
   Object.defineProperty(list, "length", {
     get: function() { throw test_error; }
   });
   return new Blob(list);
 }, {
   expected: "[object HTMLDivElement][object HTMLParagraphElement]",
   type: "",
   desc: "A platform object that supports indexed properties should be treated as a sequence for the blobParts argument (overwritten 'length'.)"
 });

 test(function() {
   assert_throws(test_error, function() {
     var obj = {
       length: {
         valueOf: null,
         toString: function() { throw test_error; }
       }
     };
     new Blob(obj);
   });
   assert_throws(test_error, function() {
     var obj = {
       length: { valueOf: function() { throw test_error; } }
     };
     new Blob(obj);
   });
 }, "ToUint32 should be applied to the length and any exceptions should be propagated.");

 test(function() {
   var received = [];
   var obj = {
     get length() {
       received.push("length getter");
       return {
         valueOf: function() {
           received.push("length valueOf");
           return 3;
         }
       };
     },
     get 0() {
       received.push("0 getter");
       return {
         toString: function() {
           received.push("0 toString");
           return "a";
         }
       };
     },
     get 1() {
       received.push("1 getter");
       throw test_error;
     },
     get 2() {
       received.push("2 getter");
       assert_unreached("Should not call the getter for 2 if the getter for 1 threw.");
     }
   };
   assert_throws(test_error, function() {
     new Blob(obj);
   });
   assert_array_equals(received, [
     "length getter",
     "length valueOf",
     "0 getter",
     "0 toString",
     "1 getter"
   ]);
 }, "Getters and value conversions should happen in order until an exception is thrown.");

 // XXX should add tests edge cases of ToUint32(length)

 test(function() {
   assert_throws(test_error, function() {
     new Blob([{ toString: function() { throw test_error; } }]);
   }, "Throwing toString");
   assert_throws(test_error, function() {
     new Blob([{ toString: undefined, valueOf: function() { throw test_error; } }]);
   }, "Throwing valueOf");
   assert_throws(test_error, function() {
     new Blob([{
       toString: function() { throw test_error; },
       valueOf: function() { assert_unreached("Should not call valueOf if toString is present."); }
     }]);
   }, "Throwing toString and valueOf");
   assert_throws(new TypeError(), function() {
     new Blob([{toString: null, valueOf: null}]);
   }, "Null toString and valueOf");
 }, "ToString should be called on elements of the blobParts array and any exceptions should be propagated.");

 test_blob(function() {
   var arr = [
     { toString: function() { arr.pop(); return "PASS"; } },
     { toString: function() { assert_unreached("Should have removed the second element of the array rather than called toString() on it."); } }
   ];
   return new Blob(arr);
 }, {
   expected: "PASSundefined",
   type: "",
   desc: "Changes to the blobParts array should be reflected in the returned Blob (pop)."
 });

 test_blob(function() {
   var arr = [
     {
       toString: function() {
         if (arr.length === 3) {
           return "SS";
         }
         arr.unshift({
           toString: function() {
             assert_unreached("Should only access index 0 once.");
           }
         });
         return "PA";
       }
     },
     {
       toString: function() {
         assert_unreached("Should not access the final element.");
       }
     }
   ];
   return new Blob(arr);
 }, {
   expected: "PASS",
   type: "",
   desc: "Changes to the blobParts array should be reflected in the returned Blob (unshift)."
 });

 test_blob(function() {
   // https://www.w3.org/Bugs/Public/show_bug.cgi?id=17652
   return new Blob([
     null,
     undefined,
     true,
     false,
     0,
     1,
     new String("stringobject"),
     [],
     ['x', 'y'],
     {},
     { 0: "FAIL", length: 1 },
     { toString: function() { return "stringA"; } },
     { toString: undefined, valueOf: function() { return "stringB"; } },
     { valueOf: function() { assert_unreached("Should not call valueOf if toString is present on the prototype."); } }
   ]);
 }, {
   expected: "nullundefinedtruefalse01stringobjectx,y[object Object][object Object]stringAstringB[object Object]",
   type: "",
   desc: "ToString should be called on elements of the blobParts array."
 });

 test_blob(function() {
   return new Blob([
     new ArrayBuffer(8)
   ]);
 }, {
   expected: "\0\0\0\0\0\0\0\0",
   type: "",
   desc: "ArrayBuffer elements of the blobParts array should be supported."
 });

 test_blob(function() {
   return new Blob([
     new Uint8Array([0x50, 0x41, 0x53, 0x53]),
     new Int8Array([0x50, 0x41, 0x53, 0x53]),
     new Uint16Array([0x4150, 0x5353]),
     new Int16Array([0x4150, 0x5353]),
     new Uint32Array([0x53534150]),
     new Int32Array([0x53534150]),
     new Float32Array([0xD341500000])
   ]);
 }, {
   expected: "PASSPASSPASSPASSPASSPASSPASS",
   type: "",
   desc: "Passing typed arrays as elements of the blobParts array should work."
 });
 test_blob(function() {
   return new Blob([
     // 0x535 3415053534150
     // 0x535 = 0b010100110101 -> Sign = +, Exponent = 1333 - 1023 = 310
     // 0x13415053534150 * 2**(-52)
     // ==> 0x13415053534150 * 2**258 = 2510297372767036725005267563121821874921913208671273727396467555337665343087229079989707079680
     new Float64Array([2510297372767036725005267563121821874921913208671273727396467555337665343087229079989707079680])
   ]);
 }, {
   expected: "PASSPASS",
   type: "",
   desc: "Passing a Float64Array as element of the blobParts array should work."
 });

 test_blob(function() {
   return new Blob(document.createElement("div"));
 }, {
   expected: "",
   type: "",
   desc: "Passing an element as the blobParts array should work."
 });

 test_blob(function() {
   return new Blob(window);
 }, {
   expected: "[object Window]",
   type: "",
   desc: "Passing an platform object that supports indexed properties as the blobParts array should work (window)."
 });
 test_blob(function() {
   window[0].toString = function() { return "foo"; };
   return new Blob(window);
 }, {
   expected: "foo",
   type: "",
   desc: "Passing an platform object that supports indexed properties as the blobParts array should work (window with custom toString)."
 });
 test_blob(function() {
   var select = document.createElement("select");
   select.appendChild(document.createElement("option"));
   return new Blob(select);
 }, {
   expected: "[object HTMLOptionElement]",
   type: "",
   desc: "Passing an platform object that supports indexed properties as the blobParts array should work (select)."
 });

 var t_ports = async_test("Passing a platform array object as the blobParts array should work (MessagePort[]).");
 t_ports.step(function() {
     var channel = new MessageChannel();
     channel.port2.onmessage = this.step_func(function(e) {
         var b_ports = new Blob(e.ports);
         assert_equals(b_ports.size, "[object MessagePort]".length);
         this.done();
     });
     var channel2 = new MessageChannel();
     channel.port1.postMessage('', [channel2.port1]);
 });

 test_blob(function() {
   var elm = document.createElement("div");
   elm.setAttribute("foo", "bar");
   return new Blob(elm.attributes);
 }, {
   expected: "[object Attr]",
   type: "",
   desc: "Passing a platform array object as the blobParts array should work (Attr[])."
 });

 test_blob(function() {
   var blob = new Blob(['foo']);
   return new Blob([blob, blob]);
 }, {
   expected: "foofoo",
   type: "",
   desc: "Array with two blobs"
 });

 test_blob_binary(function() {
   var view = new Uint8Array([0, 255, 0]);
   return new Blob([view.buffer, view.buffer]);
 }, {
   expected: [0, 255, 0, 0, 255, 0],
   type: "",
   desc: "Array with two buffers"
 });

 test_blob_binary(function() {
   var view = new Uint8Array([0, 255, 0, 4]);
   var blob = new Blob([view, view]);
   assert_equals(blob.size, 8);
   var view1 = new Uint16Array(view.buffer, 2);
   return new Blob([view1, view.buffer, view1]);
 }, {
   expected: [0, 4, 0, 255, 0, 4, 0, 4],
   type: "",
   desc: "Array with two bufferviews"
 });

 test_blob(function() {
   var view = new Uint8Array([0]);
   var blob = new Blob(["fo"]);
   return new Blob([view.buffer, blob, "foo"]);
 }, {
   expected: "\0fofoo",
   type: "",
   desc: "Array with mixed types"
 });

 // options argument
 test(function() {
   new Blob([], { endings: "invalidEnumValue" });
   new Blob([], { endings: null });
   new Blob([], { endings: undefined });
   new Blob([], { endings: 0 });
   new Blob([], { get endings() { assert_unreached("Should not call getter"); } });
 }, "The 'endings' property should be ignored.");

 test(function() {
   assert_throws(test_error, function() {
     new Blob([], {
       get type() { throw test_error; }
     });
   });
   assert_throws(test_error, function() {
     new Blob([], {
       type: { toString: function() { throw test_error; } }
     });
   });
 }, "options properties should be accessed in lexicographic order.");

 test(function() {
   assert_throws(test_error, function() {
     new Blob(
       [{ toString: function() { throw test_error } }],
       {
         get type() { assert_unreached("type getter should not be called."); }
       }
     );
   });
 }, "Arguments should be evaluated from left to right.");

 [
   null,
   undefined,
   {},
   { unrecognized: true },
   /regex/,
   function() {}
 ].forEach(function(arg, idx) {
   test_blob(function() {
     return new Blob([], arg);
   }, {
     expected: "",
     type: "",
     desc: "Passing " + format_value(arg) + " (index " + idx + ") for options should use the defaults."
   });
   test_blob(function() {
     return new Blob(["\na\r\nb\n\rc\r"], arg);
   }, {
     expected: "\na\r\nb\n\rc\r",
     type: "",
     desc: "Passing " + format_value(arg) + " (index " + idx + ") for options should use the defaults (with newlines)."
   });
 });

 test_blob(function() {
   return new Blob(["\na\r\nb\n\rc\r"], { endings: "transparent" });
 }, {
   expected: "\na\r\nb\n\rc\r",
   type: "",
   desc: "Newlines should not change when endings is 'transparent'."
 });
 test_blob(function() {
   return new Blob(["\na\r\nb\n\rc\r"], { endings: "native" });
 }, {
   expected: "\na\r\nb\n\rc\r",
   type: "",
   desc: "Newlines should not change when endings is 'native'."
 });

 var type_tests = [
   // blobParts, type, expected type
   [[], '', ''],
   [[], 'a', 'a'],
   [[], 'A', 'a'],
   [[], 'text/html', 'text/html'],
   [[], 'TEXT/HTML', 'text/html'],
   [[], '\u00E5', ''],
   [[], '\uD801\uDC7E', ''], // U+1047E
   [[], ' image/gif ', ' image/gif '],
   [[], '\timage/gif\t', ''],
   [[], 'image/gif;\u007f', ''],
   [[], '\u0130mage/gif', ''], // uppercase i with dot
   [[], '\u0131mage/gif', ''], // lowercase dotless i
   [[], 'image/gif\u0000', ''],
   // check that type isn't changed based on sniffing
   [[0x3C, 0x48, 0x54, 0x4D, 0x4C, 0x3E], 'unknown/unknown', 'unknown/unknown'], // "<HTML>"
   [[0x00, 0xFF], 'text/plain', 'text/plain'],
   [[0x47, 0x49, 0x46, 0x38, 0x39, 0x61], 'image/png', 'image/png'], // "GIF89a"
 ];

 type_tests.forEach(function(t) {
   test(function() {
     var arr = new Uint8Array([t[0]]).buffer;
     var b = new Blob([arr], {type:t[1]});
     assert_equals(b.type, t[2]);
   }, "Blob with type " + format_value(t[1]));
 });
 </script>
	<!DOCTYPE html>
	<meta charset=utf-8>
	<title>Blob constructor</title>
	<link rel=help href="http://dev.w3.org/2006/webapi/FileAPI/#constructorBlob">
	<link rel=help href="https://heycam.github.io/webidl/#es-union">
	<link rel=help href="https://heycam.github.io/webidl/#es-dictionary">
	<link rel=help href="https://heycam.github.io/webidl/#es-sequence">
	<script src="/resources/testharness.js"></script>
	<script src="/resources/testharnessreport.js"></script>
	<script src="../support/Blob.js"></script>
	<p><strong><a href="https://www.w3.org/Bugs/Public/show_bug.cgi?id=23683">Discussion</a>
	is ongoing that will affect a number of the following tests.</strong>
	<div id="log"></div>
	<!-- used by "platform object that supports indexed properties" tests -->
	<iframe style="display:none"></iframe>
	<script>
	test(function() {
	assert_true("Blob" in window, "window should have a Blob property.");
	assert_equals(Blob.length, 0, "Blob.length should be 0.");
	assert_true(Blob instanceof Function, "Blob should be a function.");
	}, "Blob interface object");

	// Step 1.
	test(function() {
	var blob = new Blob();
	assert_true(blob instanceof Blob);
	assert_equals(String(blob), '[object Blob]');
	assert_equals(blob.size, 0);
	assert_equals(blob.type, "");
	}, "no-argument Blob constructor");
	test(function() {
	assert_throws(new TypeError(), function() { var blob = Blob(); });
	}, "no-argument Blob constructor without 'new'");
	test(function() {
	var blob = new Blob;
	assert_true(blob instanceof Blob);
	assert_equals(blob.size, 0);
	assert_equals(blob.type, "");
	}, "no-argument Blob constructor without brackets");

	// blobParts argument (WebIDL).
	test(function() {
	var args = [
	null,
	undefined,
	true,
	false,
	0,
	1,
	1.5,
	"FAIL",
	new Date(),
	new RegExp(),
	];
	args.forEach(function(arg) {
	assert_throws(new TypeError(), function() {
	new Blob(arg);
	}, "Should throw for argument " + format_value(arg) + ".");
	});
	}, "Passing non-objects, Dates and RegExps for blobParts should throw a TypeError.");

	test_blob(function() {
	return new Blob({});
	}, {
	expected: "",
	type: "",
	desc: "A plain object should be treated as a sequence for the blobParts argument."
	});
	test_blob(function() {
	return new Blob({ 0: "PASS", length: 1 });
	}, {
	expected: "PASS",
	type: "",
	desc: "A plain object with a length property should be treated as a sequence for the blobParts argument."
	});
	test_blob(function() {
	return new Blob(new String("xyz"));
	}, {
	expected: "xyz",
	type: "",
	desc: "A String object should be treated as a sequence for the blobParts argument."
	});
	test_blob(function() {
	return new Blob(new Uint8Array([1, 2, 3]));
	}, {
	expected: "123",
	type: "",
	desc: "A Uint8Array object should be treated as a sequence for the blobParts argument."
	});

	var test_error = { name: "test" };

	test(function() {
	var obj = {
	get length() { throw test_error; }
	};
	assert_throws(test_error, function() {
	new Blob(obj);
	});
	}, "The length getter should be invoked and any exceptions should be propagated.");

	test_blob(function() {
	var element = document.createElement("div");
	element.appendChild(document.createElement("div"));
	element.appendChild(document.createElement("p"));
	var list = element.children;
	Object.defineProperty(list, "length", {
	get: function() { throw test_error; }
	});
	return new Blob(list);
	}, {
	expected: "[object HTMLDivElement][object HTMLParagraphElement]",
	type: "",
	desc: "A platform object that supports indexed properties should be treated as a sequence for the blobParts argument (overwritten 'length'.)"
	});

	test(function() {
	assert_throws(test_error, function() {
	var obj = {
	length: {
	valueOf: null,
	toString: function() { throw test_error; }
	}
	};
	new Blob(obj);
	});
	assert_throws(test_error, function() {
	var obj = {
	length: { valueOf: function() { throw test_error; } }
	};
	new Blob(obj);
	});
	}, "ToUint32 should be applied to the length and any exceptions should be propagated.");

	test(function() {
	var received = [];
	var obj = {
	get length() {
	received.push("length getter");
	return {
	valueOf: function() {
	received.push("length valueOf");
	return 3;
	}
	};
	},
	get 0() {
	received.push("0 getter");
	return {
	toString: function() {
	received.push("0 toString");
	return "a";
	}
	};
	},
	get 1() {
	received.push("1 getter");
	throw test_error;
	},
	get 2() {
	received.push("2 getter");
	assert_unreached("Should not call the getter for 2 if the getter for 1 threw.");
	}
	};
	assert_throws(test_error, function() {
	new Blob(obj);
	});
	assert_array_equals(received, [
	"length getter",
	"length valueOf",
	"0 getter",
	"0 toString",
	"1 getter"
	]);
	}, "Getters and value conversions should happen in order until an exception is thrown.");

	// XXX should add tests edge cases of ToUint32(length)

	test(function() {
	assert_throws(test_error, function() {
	new Blob([{ toString: function() { throw test_error; } }]);
	}, "Throwing toString");
	assert_throws(test_error, function() {
	new Blob([{ toString: undefined, valueOf: function() { throw test_error; } }]);
	}, "Throwing valueOf");
	assert_throws(test_error, function() {
	new Blob([{
	toString: function() { throw test_error; },
	valueOf: function() { assert_unreached("Should not call valueOf if toString is present."); }
	}]);
	}, "Throwing toString and valueOf");
	assert_throws(new TypeError(), function() {
	new Blob([{toString: null, valueOf: null}]);
	}, "Null toString and valueOf");
	}, "ToString should be called on elements of the blobParts array and any exceptions should be propagated.");

	test_blob(function() {
	var arr = [
	{ toString: function() { arr.pop(); return "PASS"; } },
	{ toString: function() { assert_unreached("Should have removed the second element of the array rather than called toString() on it."); } }
	];
	return new Blob(arr);
	}, {
	expected: "PASSundefined",
	type: "",
	desc: "Changes to the blobParts array should be reflected in the returned Blob (pop)."
	});

	test_blob(function() {
	var arr = [
	{
	toString: function() {
	if (arr.length === 3) {
	return "SS";
	}
	arr.unshift({
	toString: function() {
	assert_unreached("Should only access index 0 once.");
	}
	});
	return "PA";
	}
	},
	{
	toString: function() {
	assert_unreached("Should not access the final element.");
	}
	}
	];
	return new Blob(arr);
	}, {
	expected: "PASS",
	type: "",
	desc: "Changes to the blobParts array should be reflected in the returned Blob (unshift)."
	});

	test_blob(function() {
	// https://www.w3.org/Bugs/Public/show_bug.cgi?id=17652
	return new Blob([
	null,
	undefined,
	true,
	false,
	0,
	1,
	new String("stringobject"),
	[],
	['x', 'y'],
	{},
	{ 0: "FAIL", length: 1 },
	{ toString: function() { return "stringA"; } },
	{ toString: undefined, valueOf: function() { return "stringB"; } },
	{ valueOf: function() { assert_unreached("Should not call valueOf if toString is present on the prototype."); } }
	]);
	}, {
	expected: "nullundefinedtruefalse01stringobjectx,y[object Object][object Object]stringAstringB[object Object]",
	type: "",
	desc: "ToString should be called on elements of the blobParts array."
	});

	test_blob(function() {
	return new Blob([
	new ArrayBuffer(8)
	]);
	}, {
	expected: "\0\0\0\0\0\0\0\0",
	type: "",
	desc: "ArrayBuffer elements of the blobParts array should be supported."
	});

	test_blob(function() {
	return new Blob([
	new Uint8Array([0x50, 0x41, 0x53, 0x53]),
	new Int8Array([0x50, 0x41, 0x53, 0x53]),
	new Uint16Array([0x4150, 0x5353]),
	new Int16Array([0x4150, 0x5353]),
	new Uint32Array([0x53534150]),
	new Int32Array([0x53534150]),
	new Float32Array([0xD341500000])
	]);
	}, {
	expected: "PASSPASSPASSPASSPASSPASSPASS",
	type: "",
	desc: "Passing typed arrays as elements of the blobParts array should work."
	});
	test_blob(function() {
	return new Blob([
	// 0x535 3415053534150
	// 0x535 = 0b010100110101 -> Sign = +, Exponent = 1333 - 1023 = 310
	// 0x13415053534150 * 2**(-52)
	// ==> 0x13415053534150 * 2**258 = 2510297372767036725005267563121821874921913208671273727396467555337665343087229079989707079680
	new Float64Array([2510297372767036725005267563121821874921913208671273727396467555337665343087229079989707079680])
	]);
	}, {
	expected: "PASSPASS",
	type: "",
	desc: "Passing a Float64Array as element of the blobParts array should work."
	});

	test_blob(function() {
	return new Blob(document.createElement("div"));
	}, {
	expected: "",
	type: "",
	desc: "Passing an element as the blobParts array should work."
	});

	test_blob(function() {
	return new Blob(window);
	}, {
	expected: "[object Window]",
	type: "",
	desc: "Passing an platform object that supports indexed properties as the blobParts array should work (window)."
	});
	test_blob(function() {
	window[0].toString = function() { return "foo"; };
	return new Blob(window);
	}, {
	expected: "foo",
	type: "",
	desc: "Passing an platform object that supports indexed properties as the blobParts array should work (window with custom toString)."
	});
	test_blob(function() {
	var select = document.createElement("select");
	select.appendChild(document.createElement("option"));
	return new Blob(select);
	}, {
	expected: "[object HTMLOptionElement]",
	type: "",
	desc: "Passing an platform object that supports indexed properties as the blobParts array should work (select)."
	});

	var t_ports = async_test("Passing a platform array object as the blobParts array should work (MessagePort[]).");
	t_ports.step(function() {
	var channel = new MessageChannel();
	channel.port2.onmessage = this.step_func(function(e) {
	var b_ports = new Blob(e.ports);
	assert_equals(b_ports.size, "[object MessagePort]".length);
	this.done();
	});
	var channel2 = new MessageChannel();
	channel.port1.postMessage('', [channel2.port1]);
	});

	test_blob(function() {
	var elm = document.createElement("div");
	elm.setAttribute("foo", "bar");
	return new Blob(elm.attributes);
	}, {
	expected: "[object Attr]",
	type: "",
	desc: "Passing a platform array object as the blobParts array should work (Attr[])."
	});

	test_blob(function() {
	var blob = new Blob(['foo']);
	return new Blob([blob, blob]);
	}, {
	expected: "foofoo",
	type: "",
	desc: "Array with two blobs"
	});

	test_blob_binary(function() {
	var view = new Uint8Array([0, 255, 0]);
	return new Blob([view.buffer, view.buffer]);
	}, {
	expected: [0, 255, 0, 0, 255, 0],
	type: "",
	desc: "Array with two buffers"
	});

	test_blob_binary(function() {
	var view = new Uint8Array([0, 255, 0, 4]);
	var blob = new Blob([view, view]);
	assert_equals(blob.size, 8);
	var view1 = new Uint16Array(view.buffer, 2);
	return new Blob([view1, view.buffer, view1]);
	}, {
	expected: [0, 4, 0, 255, 0, 4, 0, 4],
	type: "",
	desc: "Array with two bufferviews"
	});

	test_blob(function() {
	var view = new Uint8Array([0]);
	var blob = new Blob(["fo"]);
	return new Blob([view.buffer, blob, "foo"]);
	}, {
	expected: "\0fofoo",
	type: "",
	desc: "Array with mixed types"
	});

	// options argument
	test(function() {
	new Blob([], { endings: "invalidEnumValue" });
	new Blob([], { endings: null });
	new Blob([], { endings: undefined });
	new Blob([], { endings: 0 });
	new Blob([], { get endings() { assert_unreached("Should not call getter"); } });
	}, "The 'endings' property should be ignored.");

	test(function() {
	assert_throws(test_error, function() {
	new Blob([], {
	get type() { throw test_error; }
	});
	});
	assert_throws(test_error, function() {
	new Blob([], {
	type: { toString: function() { throw test_error; } }
	});
	});
	}, "options properties should be accessed in lexicographic order.");

	test(function() {
	assert_throws(test_error, function() {
	new Blob(
	[{ toString: function() { throw test_error } }],
	{
	get type() { assert_unreached("type getter should not be called."); }
	}
	);
	});
	}, "Arguments should be evaluated from left to right.");

	[
	null,
	undefined,
	{},
	{ unrecognized: true },
	/regex/,
	function() {}
	].forEach(function(arg, idx) {
	test_blob(function() {
	return new Blob([], arg);
	}, {
	expected: "",
	type: "",
	desc: "Passing " + format_value(arg) + " (index " + idx + ") for options should use the defaults."
	});
	test_blob(function() {
	return new Blob(["\na\r\nb\n\rc\r"], arg);
	}, {
	expected: "\na\r\nb\n\rc\r",
	type: "",
	desc: "Passing " + format_value(arg) + " (index " + idx + ") for options should use the defaults (with newlines)."
	});
	});

	test_blob(function() {
	return new Blob(["\na\r\nb\n\rc\r"], { endings: "transparent" });
	}, {
	expected: "\na\r\nb\n\rc\r",
	type: "",
	desc: "Newlines should not change when endings is 'transparent'."
	});
	test_blob(function() {
	return new Blob(["\na\r\nb\n\rc\r"], { endings: "native" });
	}, {
	expected: "\na\r\nb\n\rc\r",
	type: "",
	desc: "Newlines should not change when endings is 'native'."
	});

	var type_tests = [
	// blobParts, type, expected type
	[[], '', ''],
	[[], 'a', 'a'],
	[[], 'A', 'a'],
	[[], 'text/html', 'text/html'],
	[[], 'TEXT/HTML', 'text/html'],
	[[], '\u00E5', ''],
	[[], '\uD801\uDC7E', ''], // U+1047E
	[[], ' image/gif ', ' image/gif '],
	[[], '\timage/gif\t', ''],
	[[], 'image/gif;\u007f', ''],
	[[], '\u0130mage/gif', ''], // uppercase i with dot
	[[], '\u0131mage/gif', ''], // lowercase dotless i
	[[], 'image/gif\u0000', ''],
	// check that type isn't changed based on sniffing
	[[0x3C, 0x48, 0x54, 0x4D, 0x4C, 0x3E], 'unknown/unknown', 'unknown/unknown'], // "<HTML>"
	[[0x00, 0xFF], 'text/plain', 'text/plain'],
	[[0x47, 0x49, 0x46, 0x38, 0x39, 0x61], 'image/png', 'image/png'], // "GIF89a"
	];

	type_tests.forEach(function(t) {
	test(function() {
	var arr = new Uint8Array([t[0]]).buffer;
	var b = new Blob([arr], {type:t[1]});
	assert_equals(b.type, t[2]);
	}, "Blob with type " + format_value(t[1]));
	});
	</script>