LayoutTests/fast/canvas/webgl/arraybuffer-transfer-of-control.html - WebKit - Git at Google

 <!DOCTYPE html>
 <html>
 <head>
 <script src="../../../resources/js-test.js"></script>
 <script src="webgl-test.js"></script>
 </head>
 <body>
 <div id="description"></div>
 <div id="console"></div>
 <script>
 window.jsTestIsAsync = true;

 description('Test transfer of control semantics for ArrayBuffers.');
 window.testsComplete = 0;

 var arraySize = 40;
 var arrayOffset = 8;
 var arrayEffectiveSize = arraySize - arrayOffset;

 var basicBufferTypes =
 [
     ["Int32", Int32Array, 4],
     ["Uint32", Uint32Array, 4],
     ["Int8", Int8Array, 1],
     ["Uint8", Uint8Array, 1],
     ["Uint8Clamped", Uint8ClampedArray, 1],
     ["Int16", Int16Array, 2],
     ["Uint16", Uint16Array, 2],
     ["Float32", Float32Array, 4],
     ["Float64", Float64Array, 8]
 ];

 var allBufferTypes =
 [
     ["Int32", Int32Array, 4],
     ["Uint32", Uint32Array, 4],
     ["Int8", Int8Array, 1],
     ["Uint8", Uint8Array, 1],
     ["Uint8Clamped", Uint8ClampedArray, 1],
     ["Int16", Int16Array, 2],
     ["Uint16", Uint16Array, 2],
     ["Float32", Float32Array, 4],
     ["Float64", Float64Array, 8],
     ["DataView", DataView, 1]
 ];

 function isTypedArray(view)
 {
     for (var i = 0; i < basicBufferTypes.length; ++i) {
         var bufferType = basicBufferTypes[i];
         if (view instanceof bufferType[1]) {
             return true;
         }
     }
     return false;
 }

 function isDataView(view)
 {
     return (view instanceof DataView);
 }

 function isArrayBuffer(buffer)
 {
     return (buffer instanceof ArrayBuffer);
 }

 function assertBufferClosed(testName, buffer)
 {
     if (buffer === null) {
         return true;
     }
     if (!isArrayBuffer(buffer)) {
         testFailed(testName + ": not an array buffer (" + buffer + ")");
         return false;
     }
     if (buffer.byteLength !== 0 || !(buffer.byteLength === 0)) {
         testFailed(testName + ": ArrayBuffer byteLength !== 0");
         return false;
     }
     return true;
 }

 function assertViewClosed(testName, view)
 {
     if (isTypedArray(view) || isDataView(view)) {
         if (view.buffer !== null && !assertBufferClosed(testName, view.buffer))
             return false;
         if (view.byteOffset !== 0 || !(view.byteOffset === 0)) {
             testFailed(testName + ": view byteOffset !== 0");
             return false;
         }
         if (view.byteLength !== 0 || !(view.byteLength === 0)) {
             testFailed(testName + ": view byteLength !== 0");
             return false;
         }
         if (!isDataView(view)) {
             if (view.length !== 0 || !(view.length === 0)) {
                 testFailed(testName + ": TypedArray length !== 0");
                 return false;
             }
             try {
                 var v = view[0];
                 testFailed(testName + ": index get on a closed view did not throw an exception");
                 return false;
             } catch(xn) {
                 if (xn != "TypeError: Underlying ArrayBuffer has been detached from the view") {
                     testFailed(testName + ": index get on a closed view threw the wrong exception: " + xn);
                     return false;
                 }
             }

             try {
                 view[0] = 42;
                 testFailed(testName + ": index set on a closed view did not throw an exception");
                 return false;
             } catch(xn) {
                 if (xn != "TypeError: Underlying ArrayBuffer has been detached from the view") {
                     testFailed(testName + ": index set then get on a closed view threw the wrong exception: " + xn);
                     return false;
                 }
             }

             try {
                 view.set(0, 1);
                 testFailed(testName + ": set on a closed view succeeded");
                 return false;
             } catch (xn) {
                 if (xn != "TypeError: Underlying ArrayBuffer has been detached from the view") {
                     testFailed(testName + ": set on a closed view threw the wrong exception: " + xn);
                     return false;
                 }
             }
         } else {
             try {
                 view.getInt8(0);
                 testFailed(testName + ": get on a closed view succeeded");
                 return false;
             } catch (xn) { }
             try {
                 view.setInt8(0, 1);
                 testFailed(testName + ": set on a closed view succeeded");
                 return false;
             } catch (xn) { }
         }
     } else {
         testFailed(testName + " not a view (" + view + ")");
         return false;
     }
     return true;
 }

 function createBuffer(length)
 {
     var buffer = new ArrayBuffer(length);
     var view = new Uint8Array(buffer);
     for (var i = 0; i < length; ++i) {
         view[i] = i + 1;
     }
     return buffer;
 }

 function checkBuffer(testName, buffer, length)
 {
     if (!isArrayBuffer(buffer)) {
         testFailed(testName + ": buffer is not an ArrayBuffer");
         return false;
     }
     if (buffer.byteLength !== length) {
         testFailed(testName + ": buffer is the wrong length");
         return false;
     }
     var view = new Uint8Array(buffer);
     for (var i = 0; i < length; ++i) {
         if (view[i] !== i + 1) {
             testFailed(testName + ": buffer contains the wrong data");
             return false;
         }
     }
     return true;
 }

 function createView(viewType, bytesPerElement)
 {
     if (viewType === DataView) {
         var view = new Uint8Array(arraySize);
         for (var i = arrayOffset; i < arraySize; ++i) {
             view[i] = i - arrayOffset + 1;
         }
         return new DataView(view.buffer, arrayOffset, arrayEffectiveSize);
     } else {
         var view = new viewType(new ArrayBuffer(arraySize), arrayOffset, arrayEffectiveSize / bytesPerElement);
         for (var i = 0; i < arrayEffectiveSize / bytesPerElement; ++i) {
             view[i] = i + 1;
         }
         return view;
     }
 }

 function createEveryView(buffer)
 {
     return allBufferTypes.map(function (bufferType) {
         return new bufferType[1](buffer, arrayOffset, arrayEffectiveSize / bufferType[2]);
     });
 }

 function checkView(testName, typedArrayType, view)
 {
     if (!(view instanceof typedArrayType)) {
         testFailed(testName + ": " + view + " not an instance of " + typedArrayType);
         return false;
     }
     if (view.buffer.byteLength !== arraySize ||
         (!(view instanceof DataView) && view.length !== arrayEffectiveSize / view.BYTES_PER_ELEMENT)) {
         testFailed(testName + ": view has the wrong length (" + view.length + " instead of " + arrayEffectiveSize + " / " + view.BYTES_PER_ELEMENT + ")");
         return false;
     }
     if (view.byteOffset !== arrayOffset) {
         testFailed(testName + ": view has wrong byte offset");
     }
     var max = arrayEffectiveSize;
     if (!(view instanceof DataView)) {
         max = max / view.BYTES_PER_ELEMENT;
     }
     for (var i = 0; i < max; ++i) {
         if (view instanceof DataView) {
             if (view.getInt8(i) !== i + 1) {
                 testFailed(testName + ": view contains the wrong data");
                 return false;
             }
         } else {
             if (view[i] !== i + 1) {
                 testFailed(testName + ": view contains the wrong data");
                 return false;
             }
         }
     }
     return true;
 }

 function checkEmptyArray(testName, array)
 {
     if (array === null || array === undefined) {
         testFailed(testName + ": port list is null or undefined");
         return false;
     }
     if (array.length !== 0) {
         testFailed(testName + ": port list is not zero-length");
         return false;
     }
     return true;
 }

 function wrapSend(testName, message, xfer)
 {
     try {
         window.postMessage(message, '*', xfer);
     } catch (e) {
         testFailed(testName + ": could not postMessage: " + e);
         doneTest();
         return false;
     }
     return true;
 }

 function wrapFailSend(testName, message, xfer)
 {
     try {
         window.postMessage(message, '*', xfer);
     } catch (e) {
         return true;
     }
     testFailed(testName + ": expected postMessage to fail but it didn't.");
     return false;
 }

 var testList = [{
     name: "sanity check",
     send: function (name) { wrapSend(name, [], []); },
     test: function (name, e) { return true; }
 }, {
     name: "raw ArrayBuffer",
     send: function (name) {
         var buffer = createBuffer(3);
         wrapSend(name, buffer, [buffer]);
         assertBufferClosed(name, buffer);
         wrapFailSend(name, buffer, [buffer]);
         wrapFailSend(name, buffer, []);
     },
     test: function (name, e) { return checkBuffer(name, e.data, 3) && checkEmptyArray(name, e.ports); }
 }, {
     name: "sending buffers is sane even if cloning doesn't special-case",
     send: function(name) {
         var view = createView(Int32Array, 4);
         var buffer = view.buffer;
         wrapSend(name, [view, buffer], [buffer]);
         assertBufferClosed(name, buffer);
         assertViewClosed(name, view);
     },
     test: function (name, e) {
         if (e.data[0].buffer !== e.data[1]) {
             testFailed("View and buffer were not linked.");
             return false;
         }
         return true;
     }
 }, {
     name: "send every view",
     send: function(name) {
         var buffer = createBuffer(arraySize);
         var views = createEveryView(buffer);
         wrapSend(name, views, [buffer]);
         assertBufferClosed(name, buffer);
         wrapFailSend(name, views, [buffer]);
         wrapFailSend(name, views, []);
     },
     test: function (name, e) {
         if (e.data.length !== allBufferTypes.length) {
             testFailed(name + ": not every view was sent.");
         }
         for (var v = 0; v < e.data.length; ++v) {
             var view = e.data[v];
             if (view.buffer !== e.data[0].buffer) {
                 testFailed(name + ": not every view pointed to the correct buffer.");
                 return false;
             }
         }
         return true;
     }
 }, {
     name: "transfer list multiple",
     send: function(name) {
         var buffer = createBuffer(arraySize);
         wrapSend(name, { buffer : buffer }, [buffer,buffer]);
         assertBufferClosed(name, buffer);
         wrapFailSend(name, [buffer], [buffer]);
         wrapFailSend(name, [], [buffer]);
         var buffer2 = createBuffer(arraySize);
         wrapFailSend(name, [], [buffer2, buffer]);
         checkBuffer(name, buffer2, arraySize);
         wrapFailSend(name, [], [buffer, buffer2]);
         checkBuffer(name, buffer2, arraySize);
         wrapFailSend(name, [buffer2], [buffer2, buffer]);
         checkBuffer(name, buffer2, arraySize);
     },
     test: function (name, e) {
         return checkBuffer(name, e.data.buffer, arraySize);
     }
 }, {
     name: "transfer neuters unmentioned",
     send: function (name) {
         var buffer = createBuffer(arraySize);
         wrapSend(name, [], [buffer]);
         assertBufferClosed(name, buffer);
     },
     test : function (name, e) {
         return e.data.length == 0;
     }
 }];

 testList = testList.concat(allBufferTypes.map(function(bufferType) { return {
     name: "raw " + bufferType[0],
     send: function (name) {
         var view = createView(bufferType[1], bufferType[2]);
         wrapSend(name, view, [view.buffer]);
         assertViewClosed(name, view);
         assertBufferClosed(name, view.buffer);
         wrapFailSend(name, view, [view.buffer]);
         wrapFailSend(name, view, []);
     },
     test: function (name, e) {
         return checkView(name, bufferType[1], e.data) && checkEmptyArray(name, e.ports);
     }
 }}));


 function viewAndBuffer(viewFirst, bufferType) {
     return {
         name: (viewFirst ? "send view, buffer for " : "send buffer, view for ") + bufferType[0],
         send: function (name) {
             var view = createView(bufferType[1], bufferType[2]);
             var buffer = view.buffer;
             wrapSend(name, viewFirst ? [view, buffer] : [buffer, view], [buffer]);
             assertViewClosed(name, view);
             assertBufferClosed(name, buffer);
             wrapFailSend(name, view, [buffer]);
             wrapFailSend(name, view, []);
             wrapFailSend(name, buffer, [buffer]);
             wrapFailSend(name, buffer, []);
             wrapFailSend(name, [view, buffer], [buffer]);
             wrapFailSend(name, [buffer, view], [buffer]);
             wrapFailSend(name, [view, buffer], []);
             wrapFailSend(name, [buffer, view], []);
         },
         test: function (name, e) {
             var view = e.data[viewFirst ? 0 : 1];
             var buffer = e.data[viewFirst ? 1 : 0];
             if (buffer !== view.buffer) {
                 testFailed(name + " buffer not shared");
                 return false;
             }
             return checkView(name, bufferType[1], view) && checkEmptyArray(name, e.ports);
         }
     }
 };

 function squashUnrelatedViews(bufferType) {
     return {
         name: "squash unrelated views for " + bufferType[0],
         send: function(name) {
             var view = createView(bufferType[1], bufferType[2]);
             var views = createEveryView(view.buffer);
             var buffer = view.buffer;
             wrapSend(name, view, [view.buffer]);
             assertViewClosed(name, view);
             assertBufferClosed(name, view.buffer);
             for (var v = 0; v < views.length; ++v) {
                 assertViewClosed(name + "(view " + v + ")", views[v]);
             }
             wrapFailSend(name, views, [buffer]);
         },
         test: function (name, e) { return checkView(name, bufferType[1], e.data) && checkEmptyArray(name, e.ports); }
     }
 }

 testList = testList.concat(allBufferTypes.map(function(bufferType) { return viewAndBuffer(true, bufferType); }));
 testList = testList.concat(allBufferTypes.map(function(bufferType) { return viewAndBuffer(false, bufferType); }));
 testList = testList.concat(allBufferTypes.map(function(bufferType) { return squashUnrelatedViews(bufferType); }));

 function doneTest() {
     if (++window.testsComplete == testList.length) {
         finishJSTest();
     }
     else {
         var t = testList[window.testsComplete];
         try {
             t.send(t.name);
         } catch(e) {
             testFailed(t.name + ": on send: " + e);
             doneTest();
         }
     }
 }

 function windowHandleMessage(event) {
     var currentTest = testList[window.testsComplete];
     if (currentTest.alreadyHit) {
         testFailed(currentTest.name + ": windowHandleMessage hit more than once.");
         return false;
     }
     currentTest.alreadyHit = true;
     try {
         if (currentTest.test(currentTest.name, event)) {
             testPassed(currentTest.name);
         }
     } catch(e) {
         testFailed(currentTest.name + ": on recieve: " + e + ". event.data = " + event.data);
     }
     doneTest();
 }

 window.addEventListener('message', windowHandleMessage);
 window.testsComplete = -1;
 doneTest();

 </script>
 </body>
 </html>
	<!DOCTYPE html>
	<html>
	<head>
	<script src="../../../resources/js-test.js"></script>
	<script src="webgl-test.js"></script>
	</head>
	<body>
	<div id="description"></div>
	<div id="console"></div>
	<script>
	window.jsTestIsAsync = true;

	description('Test transfer of control semantics for ArrayBuffers.');
	window.testsComplete = 0;

	var arraySize = 40;
	var arrayOffset = 8;
	var arrayEffectiveSize = arraySize - arrayOffset;

	var basicBufferTypes =
	[
	["Int32", Int32Array, 4],
	["Uint32", Uint32Array, 4],
	["Int8", Int8Array, 1],
	["Uint8", Uint8Array, 1],
	["Uint8Clamped", Uint8ClampedArray, 1],
	["Int16", Int16Array, 2],
	["Uint16", Uint16Array, 2],
	["Float32", Float32Array, 4],
	["Float64", Float64Array, 8]
	];

	var allBufferTypes =
	[
	["Int32", Int32Array, 4],
	["Uint32", Uint32Array, 4],
	["Int8", Int8Array, 1],
	["Uint8", Uint8Array, 1],
	["Uint8Clamped", Uint8ClampedArray, 1],
	["Int16", Int16Array, 2],
	["Uint16", Uint16Array, 2],
	["Float32", Float32Array, 4],
	["Float64", Float64Array, 8],
	["DataView", DataView, 1]
	];

	function isTypedArray(view)
	{
	for (var i = 0; i < basicBufferTypes.length; ++i) {
	var bufferType = basicBufferTypes[i];
	if (view instanceof bufferType[1]) {
	return true;
	}
	}
	return false;
	}

	function isDataView(view)
	{
	return (view instanceof DataView);
	}

	function isArrayBuffer(buffer)
	{
	return (buffer instanceof ArrayBuffer);
	}

	function assertBufferClosed(testName, buffer)
	{
	if (buffer === null) {
	return true;
	}
	if (!isArrayBuffer(buffer)) {
	testFailed(testName + ": not an array buffer (" + buffer + ")");
	return false;
	}
	if (buffer.byteLength !== 0 \|\| !(buffer.byteLength === 0)) {
	testFailed(testName + ": ArrayBuffer byteLength !== 0");
	return false;
	}
	return true;
	}

	function assertViewClosed(testName, view)
	{
	if (isTypedArray(view) \|\| isDataView(view)) {
	if (view.buffer !== null && !assertBufferClosed(testName, view.buffer))
	return false;
	if (view.byteOffset !== 0 \|\| !(view.byteOffset === 0)) {
	testFailed(testName + ": view byteOffset !== 0");
	return false;
	}
	if (view.byteLength !== 0 \|\| !(view.byteLength === 0)) {
	testFailed(testName + ": view byteLength !== 0");
	return false;
	}
	if (!isDataView(view)) {
	if (view.length !== 0 \|\| !(view.length === 0)) {
	testFailed(testName + ": TypedArray length !== 0");
	return false;
	}
	try {
	var v = view[0];
	testFailed(testName + ": index get on a closed view did not throw an exception");
	return false;
	} catch(xn) {
	if (xn != "TypeError: Underlying ArrayBuffer has been detached from the view") {
	testFailed(testName + ": index get on a closed view threw the wrong exception: " + xn);
	return false;
	}
	}

	try {
	view[0] = 42;
	testFailed(testName + ": index set on a closed view did not throw an exception");
	return false;
	} catch(xn) {
	if (xn != "TypeError: Underlying ArrayBuffer has been detached from the view") {
	testFailed(testName + ": index set then get on a closed view threw the wrong exception: " + xn);
	return false;
	}
	}

	try {
	view.set(0, 1);
	testFailed(testName + ": set on a closed view succeeded");
	return false;
	} catch (xn) {
	if (xn != "TypeError: Underlying ArrayBuffer has been detached from the view") {
	testFailed(testName + ": set on a closed view threw the wrong exception: " + xn);
	return false;
	}
	}
	} else {
	try {
	view.getInt8(0);
	testFailed(testName + ": get on a closed view succeeded");
	return false;
	} catch (xn) { }
	try {
	view.setInt8(0, 1);
	testFailed(testName + ": set on a closed view succeeded");
	return false;
	} catch (xn) { }
	}
	} else {
	testFailed(testName + " not a view (" + view + ")");
	return false;
	}
	return true;
	}

	function createBuffer(length)
	{
	var buffer = new ArrayBuffer(length);
	var view = new Uint8Array(buffer);
	for (var i = 0; i < length; ++i) {
	view[i] = i + 1;
	}
	return buffer;
	}

	function checkBuffer(testName, buffer, length)
	{
	if (!isArrayBuffer(buffer)) {
	testFailed(testName + ": buffer is not an ArrayBuffer");
	return false;
	}
	if (buffer.byteLength !== length) {
	testFailed(testName + ": buffer is the wrong length");
	return false;
	}
	var view = new Uint8Array(buffer);
	for (var i = 0; i < length; ++i) {
	if (view[i] !== i + 1) {
	testFailed(testName + ": buffer contains the wrong data");
	return false;
	}
	}
	return true;
	}

	function createView(viewType, bytesPerElement)
	{
	if (viewType === DataView) {
	var view = new Uint8Array(arraySize);
	for (var i = arrayOffset; i < arraySize; ++i) {
	view[i] = i - arrayOffset + 1;
	}
	return new DataView(view.buffer, arrayOffset, arrayEffectiveSize);
	} else {
	var view = new viewType(new ArrayBuffer(arraySize), arrayOffset, arrayEffectiveSize / bytesPerElement);
	for (var i = 0; i < arrayEffectiveSize / bytesPerElement; ++i) {
	view[i] = i + 1;
	}
	return view;
	}
	}

	function createEveryView(buffer)
	{
	return allBufferTypes.map(function (bufferType) {
	return new bufferType[1](buffer, arrayOffset, arrayEffectiveSize / bufferType[2]);
	});
	}

	function checkView(testName, typedArrayType, view)
	{
	if (!(view instanceof typedArrayType)) {
	testFailed(testName + ": " + view + " not an instance of " + typedArrayType);
	return false;
	}
	if (view.buffer.byteLength !== arraySize \|\|
	(!(view instanceof DataView) && view.length !== arrayEffectiveSize / view.BYTES_PER_ELEMENT)) {
	testFailed(testName + ": view has the wrong length (" + view.length + " instead of " + arrayEffectiveSize + " / " + view.BYTES_PER_ELEMENT + ")");
	return false;
	}
	if (view.byteOffset !== arrayOffset) {
	testFailed(testName + ": view has wrong byte offset");
	}
	var max = arrayEffectiveSize;
	if (!(view instanceof DataView)) {
	max = max / view.BYTES_PER_ELEMENT;
	}
	for (var i = 0; i < max; ++i) {
	if (view instanceof DataView) {
	if (view.getInt8(i) !== i + 1) {
	testFailed(testName + ": view contains the wrong data");
	return false;
	}
	} else {
	if (view[i] !== i + 1) {
	testFailed(testName + ": view contains the wrong data");
	return false;
	}
	}
	}
	return true;
	}

	function checkEmptyArray(testName, array)
	{
	if (array === null \|\| array === undefined) {
	testFailed(testName + ": port list is null or undefined");
	return false;
	}
	if (array.length !== 0) {
	testFailed(testName + ": port list is not zero-length");
	return false;
	}
	return true;
	}

	function wrapSend(testName, message, xfer)
	{
	try {
	window.postMessage(message, '*', xfer);
	} catch (e) {
	testFailed(testName + ": could not postMessage: " + e);
	doneTest();
	return false;
	}
	return true;
	}

	function wrapFailSend(testName, message, xfer)
	{
	try {
	window.postMessage(message, '*', xfer);
	} catch (e) {
	return true;
	}
	testFailed(testName + ": expected postMessage to fail but it didn't.");
	return false;
	}

	var testList = [{
	name: "sanity check",
	send: function (name) { wrapSend(name, [], []); },
	test: function (name, e) { return true; }
	}, {
	name: "raw ArrayBuffer",
	send: function (name) {
	var buffer = createBuffer(3);
	wrapSend(name, buffer, [buffer]);
	assertBufferClosed(name, buffer);
	wrapFailSend(name, buffer, [buffer]);
	wrapFailSend(name, buffer, []);
	},
	test: function (name, e) { return checkBuffer(name, e.data, 3) && checkEmptyArray(name, e.ports); }
	}, {
	name: "sending buffers is sane even if cloning doesn't special-case",
	send: function(name) {
	var view = createView(Int32Array, 4);
	var buffer = view.buffer;
	wrapSend(name, [view, buffer], [buffer]);
	assertBufferClosed(name, buffer);
	assertViewClosed(name, view);
	},
	test: function (name, e) {
	if (e.data[0].buffer !== e.data[1]) {
	testFailed("View and buffer were not linked.");
	return false;
	}
	return true;
	}
	}, {
	name: "send every view",
	send: function(name) {
	var buffer = createBuffer(arraySize);
	var views = createEveryView(buffer);
	wrapSend(name, views, [buffer]);
	assertBufferClosed(name, buffer);
	wrapFailSend(name, views, [buffer]);
	wrapFailSend(name, views, []);
	},
	test: function (name, e) {
	if (e.data.length !== allBufferTypes.length) {
	testFailed(name + ": not every view was sent.");
	}
	for (var v = 0; v < e.data.length; ++v) {
	var view = e.data[v];
	if (view.buffer !== e.data[0].buffer) {
	testFailed(name + ": not every view pointed to the correct buffer.");
	return false;
	}
	}
	return true;
	}
	}, {
	name: "transfer list multiple",
	send: function(name) {
	var buffer = createBuffer(arraySize);
	wrapSend(name, { buffer : buffer }, [buffer,buffer]);
	assertBufferClosed(name, buffer);
	wrapFailSend(name, [buffer], [buffer]);
	wrapFailSend(name, [], [buffer]);
	var buffer2 = createBuffer(arraySize);
	wrapFailSend(name, [], [buffer2, buffer]);
	checkBuffer(name, buffer2, arraySize);
	wrapFailSend(name, [], [buffer, buffer2]);
	checkBuffer(name, buffer2, arraySize);
	wrapFailSend(name, [buffer2], [buffer2, buffer]);
	checkBuffer(name, buffer2, arraySize);
	},
	test: function (name, e) {
	return checkBuffer(name, e.data.buffer, arraySize);
	}
	}, {
	name: "transfer neuters unmentioned",
	send: function (name) {
	var buffer = createBuffer(arraySize);
	wrapSend(name, [], [buffer]);
	assertBufferClosed(name, buffer);
	},
	test : function (name, e) {
	return e.data.length == 0;
	}
	}];

	testList = testList.concat(allBufferTypes.map(function(bufferType) { return {
	name: "raw " + bufferType[0],
	send: function (name) {
	var view = createView(bufferType[1], bufferType[2]);
	wrapSend(name, view, [view.buffer]);
	assertViewClosed(name, view);
	assertBufferClosed(name, view.buffer);
	wrapFailSend(name, view, [view.buffer]);
	wrapFailSend(name, view, []);
	},
	test: function (name, e) {
	return checkView(name, bufferType[1], e.data) && checkEmptyArray(name, e.ports);
	}
	}}));


	function viewAndBuffer(viewFirst, bufferType) {
	return {
	name: (viewFirst ? "send view, buffer for " : "send buffer, view for ") + bufferType[0],
	send: function (name) {
	var view = createView(bufferType[1], bufferType[2]);
	var buffer = view.buffer;
	wrapSend(name, viewFirst ? [view, buffer] : [buffer, view], [buffer]);
	assertViewClosed(name, view);
	assertBufferClosed(name, buffer);
	wrapFailSend(name, view, [buffer]);
	wrapFailSend(name, view, []);
	wrapFailSend(name, buffer, [buffer]);
	wrapFailSend(name, buffer, []);
	wrapFailSend(name, [view, buffer], [buffer]);
	wrapFailSend(name, [buffer, view], [buffer]);
	wrapFailSend(name, [view, buffer], []);
	wrapFailSend(name, [buffer, view], []);
	},
	test: function (name, e) {
	var view = e.data[viewFirst ? 0 : 1];
	var buffer = e.data[viewFirst ? 1 : 0];
	if (buffer !== view.buffer) {
	testFailed(name + " buffer not shared");
	return false;
	}
	return checkView(name, bufferType[1], view) && checkEmptyArray(name, e.ports);
	}
	}
	};

	function squashUnrelatedViews(bufferType) {
	return {
	name: "squash unrelated views for " + bufferType[0],
	send: function(name) {
	var view = createView(bufferType[1], bufferType[2]);
	var views = createEveryView(view.buffer);
	var buffer = view.buffer;
	wrapSend(name, view, [view.buffer]);
	assertViewClosed(name, view);
	assertBufferClosed(name, view.buffer);
	for (var v = 0; v < views.length; ++v) {
	assertViewClosed(name + "(view " + v + ")", views[v]);
	}
	wrapFailSend(name, views, [buffer]);
	},
	test: function (name, e) { return checkView(name, bufferType[1], e.data) && checkEmptyArray(name, e.ports); }
	}
	}

	testList = testList.concat(allBufferTypes.map(function(bufferType) { return viewAndBuffer(true, bufferType); }));
	testList = testList.concat(allBufferTypes.map(function(bufferType) { return viewAndBuffer(false, bufferType); }));
	testList = testList.concat(allBufferTypes.map(function(bufferType) { return squashUnrelatedViews(bufferType); }));

	function doneTest() {
	if (++window.testsComplete == testList.length) {
	finishJSTest();
	}
	else {
	var t = testList[window.testsComplete];
	try {
	t.send(t.name);
	} catch(e) {
	testFailed(t.name + ": on send: " + e);
	doneTest();
	}
	}
	}

	function windowHandleMessage(event) {
	var currentTest = testList[window.testsComplete];
	if (currentTest.alreadyHit) {
	testFailed(currentTest.name + ": windowHandleMessage hit more than once.");
	return false;
	}
	currentTest.alreadyHit = true;
	try {
	if (currentTest.test(currentTest.name, event)) {
	testPassed(currentTest.name);
	}
	} catch(e) {
	testFailed(currentTest.name + ": on recieve: " + e + ". event.data = " + event.data);
	}
	doneTest();
	}

	window.addEventListener('message', windowHandleMessage);
	window.testsComplete = -1;
	doneTest();

	</script>
	</body>
	</html>