LayoutTests/media/encrypted-media/mock-navigator-requestMediaKeySystemAccess.html - external/github.com/WebKit/webkit - Git at Google

 <!DOCTYPE html>
 <html>
 <head>
     <script src=../video-test.js></script>
     <script type="text/javascript">
     var mock;
     var promise;
     var capabilities = {};

     function doTest ()
     {
         if (!window.internals) {
             // failTest("Internals is required for this test.")
             // return;
         }

         run('internals.initializeMockMediaSource()');
         run('mock = internals.registerMockCDM()');
         run('mock.supportedDataTypes = ["mock"]');

         next();
     }

     function next() {
         if (!tests.length) {
             mock.unregister();
             endTest()
             return;
         }

         var nextTest = tests.shift();
         consoleWrite('');
         nextTest();
     }

     function passingTestWithCapabilities(capabilities, success) {
         shouldResolve(testWithCapabilities(capabilities)).then(success).then(next, next);
     }

     function failingTestWithCapabilities(capabilities, failure) {
         shouldReject(testWithCapabilities(capabilities)).then(failure).then(next, next);
     }

     function testWithCapabilities(capabilities) {
         window.capabilities = capabilities;
         consoleWrite(`SET capabilities = '${ JSON.stringify(capabilities, null, 1) }'`);
         run('promise  = navigator.requestMediaKeySystemAccess("org.webkit.mock", capabilities)');
         return promise;
     }

     tests = [
         function() {
             passingTestWithCapabilities([{
                     initDataTypes: ['mock'],
                     videoCapabilities: [{ contentType: 'video/mock; codecs="mock"' }]
                 }],
                 mediaKeySystemAccess => {
                     window.access = mediaKeySystemAccess;
                     testExpected('access.keySystem', 'org.webkit.mock');
                     testExpected('access.getConfiguration().initDataTypes.length', '1');
                     testExpected('access.getConfiguration().initDataTypes[0]', 'mock');
                     testExpected('access.getConfiguration().sessionTypes.length', '1');
                     testExpected('access.getConfiguration().sessionTypes[0]', 'temporary');
                     testExpected('access.getConfiguration().distinctiveIdentifier', 'not-allowed');
                     testExpected('access.getConfiguration().persistentState', 'not-allowed');
                 });
         },

         function() {
             failingTestWithCapabilities([{
                     initDataTypes: ['mock'],
                     videoCapabilities: [{ contentType: 'video/mock; codecs="unknown"' }]
                 }],
                 exceptionCode => {
                     window.exceptionCode = exceptionCode;
                     testExpected('exceptionCode.name', 'NotSupportedError');
                 });
         },

         function() {
             failingTestWithCapabilities([{
                     initDataTypes: ['mock'],
                     videoCapabilities: [{ contentType: 'unknown/mime; codecs="unknown"' }]
                 }],
                 exceptionCode => {
                     window.exceptionCode = exceptionCode;
                     testExpected('exceptionCode.name', 'NotSupportedError');
                 });
         },

         function() {
             failingTestWithCapabilities([{
                     initDataTypes: ['unknownType'],
                     videoCapabilities: [{ contentType: 'video/mock; codecs="mock"' }]
                 }],
                 exceptionCode => {
                     window.exceptionCode = exceptionCode;
                     testExpected('exceptionCode.name', 'NotSupportedError');
                 });
         },

         function() {
             run('mock.supportedRobustness = ["high"]');
             passingTestWithCapabilities([{
                     initDataTypes: ['mock'],
                     videoCapabilities: [{ contentType: 'video/mock; codecs="mock"', robustness: "high" }],
                 }],
                 mediaKeySystemAccess => {
                     window.access = mediaKeySystemAccess;
                     testExpected('access.getConfiguration().videoCapabilities.length', '1');
                     testExpected('access.getConfiguration().videoCapabilities[0].robustness', 'high');
                 });
         },

         function() {
             run('mock.supportedRobustness = ["high"]');
             failingTestWithCapabilities([{
                     initDataTypes: ['mock'],
                     videoCapabilities: [{ contentType: 'video/mock; codecs="mock"', robustness: "low" }],
                 }],
                 exceptionCode => {
                     window.exceptionCode = exceptionCode;
                     testExpected('exceptionCode.name', 'NotSupportedError');
                 });
         },

         function() {
             run('mock.distinctiveIdentifierRequirement = "not-allowed"');
             passingTestWithCapabilities([{
                     initDataTypes: ['mock'],
                     videoCapabilities: [{ contentType: 'video/mock; codecs="mock"'}],
                     distinctiveIdentifier: 'optional'
                 }],
                 mediaKeySystemAccess => {
                     window.access = mediaKeySystemAccess;
                     testExpected('access.getConfiguration().distinctiveIdentifier', 'not-allowed');
                 });
         },

         function() {
             run('mock.distinctiveIdentifiersRequirement = "required"');
             passingTestWithCapabilities([{
                     initDataTypes: ['mock'],
                     videoCapabilities: [{ contentType: 'video/mock; codecs="mock"'}],
                     distinctiveIdentifier: 'optional'
                 }],
                 mediaKeySystemAccess => {
                     window.access = mediaKeySystemAccess;
                     testExpected('access.getConfiguration().distinctiveIdentifier', 'required');
                 });
         },

         function() {
             run('mock.distinctiveIdentifiersRequirement = "not-allowed"');
             failingTestWithCapabilities([{
                     initDataTypes: ['mock'],
                     videoCapabilities: [{ contentType: 'video/mock; codecs="mock"'}],
                     distinctiveIdentifier: 'required'
                 }],
                 exceptionCode => {
                     window.exceptionCode = exceptionCode;
                     testExpected('exceptionCode.name', 'NotSupportedError');
                 });
         },

         function() {
             run('mock.distinctiveIdentifiersRequirement = "not-allowed"');
             passingTestWithCapabilities([{
                     label: 'distinctive-identifiers-required',
                     initDataTypes: ['mock'],
                     videoCapabilities: [{ contentType: 'video/mock; codecs="mock"'}],
                     distinctiveIdentifier: 'required'
                 }, {
                     label: 'distinctive-identifiers-not-required',
                     initDataTypes: ['mock'],
                     videoCapabilities: [{ contentType: 'video/mock; codecs="mock"'}],
                     distinctiveIdentifier: 'optional'
                 }],
                 mediaKeySystemAccess => {
                     window.access = mediaKeySystemAccess;
                     testExpected('access.getConfiguration().label', 'distinctive-identifiers-not-required');
                     testExpected('access.getConfiguration().distinctiveIdentifier', 'not-allowed');
                 });
         },

         function() {
             run('mock.persistentStateRequirement = "required"');
             passingTestWithCapabilities([{
                     initDataTypes: ['mock'],
                     videoCapabilities: [{ contentType: 'video/mock; codecs="mock"'}],
                     persistentState: 'optional'
                 }],
                 mediaKeySystemAccess => {
                     window.access = mediaKeySystemAccess;
                     testExpected('access.getConfiguration().persistentState', 'required');
                 });
         },

         function() {
             run('mock.persistentStateRequirement = "not-allowed"');
             passingTestWithCapabilities([{
                     initDataTypes: ['mock'],
                     videoCapabilities: [{ contentType: 'video/mock; codecs="mock"'}],
                     persistentState: 'optional'
                 }],
                 mediaKeySystemAccess => {
                     window.access = mediaKeySystemAccess;
                     testExpected('access.getConfiguration().persistentState', 'not-allowed');
                 });
         },

         function() {
             run('mock.persistentStateRequirement = "not-allowed"');
             failingTestWithCapabilities([{
                     initDataTypes: ['mock'],
                     videoCapabilities: [{ contentType: 'video/mock; codecs="mock"'}],
                     persistentState: 'required'
                 }],
                 exceptionCode => {
                     window.exceptionCode = exceptionCode;
                     testExpected('exceptionCode.name', 'NotSupportedError');
                 });
         },

         function() {
             run('mock.persistentStateRequirement = "not-allowed"');
             passingTestWithCapabilities([{
                     label: 'persistent-state-required',
                     initDataTypes: ['mock'],
                     videoCapabilities: [{ contentType: 'video/mock; codecs="mock"'}],
                     persistentState: 'required'
                 }, {
                     label: 'persistent-state-not-required',
                     initDataTypes: ['mock'],
                     videoCapabilities: [{ contentType: 'video/mock; codecs="mock"'}],
                     persistentState: 'optional'
                 }],
                 mediaKeySystemAccess => {
                     window.access = mediaKeySystemAccess;
                     testExpected('access.getConfiguration().label', 'persistent-state-not-required');
                     testExpected('access.getConfiguration().persistentState', 'not-allowed');
                 });
         },

         function() {
             run('mock.supportedEncryptionSchemes = ["cenc"]');
             passingTestWithCapabilities([{
                     label: 'encryption-scheme-cenc',
                     initDataTypes: ['mock'],
                     videoCapabilities: [{ contentType: 'video/mock; codecs="mock"', encryptionScheme: 'cenc'}],
                 }],
                 mediaKeySystemAccess => {
                     window.access = mediaKeySystemAccess;
                     testExpected('access.getConfiguration().label', 'encryption-scheme-cenc');
                     testExpected('access.getConfiguration().videoCapabilities[0].encryptionScheme', 'cenc');
                 });
         },

         function() {
             failingTestWithCapabilities([{
                     initDataTypes: ['mock'],
                     videoCapabilities: [{ contentType: 'video/mock; codecs="mock"', encryptionScheme: 'cbcs'}],
                 }],
                 exceptionCode => {
                     window.exceptionCode = exceptionCode;
                     testExpected('exceptionCode.name', 'NotSupportedError');
                 });
         },

         function() {
             run('mock.supportedEncryptionSchemes = ["cenc", "cbcs"]');
             passingTestWithCapabilities([{
                     label: 'encryption-scheme-cbcs',
                     initDataTypes: ['mock'],
                     videoCapabilities: [{ contentType: 'video/mock; codecs="mock"', encryptionScheme: 'cbcs'}],
                 }],
                 mediaKeySystemAccess => {
                     window.access = mediaKeySystemAccess;
                     testExpected('access.getConfiguration().label', 'encryption-scheme-cbcs');
                     testExpected('access.getConfiguration().videoCapabilities[0].encryptionScheme', 'cbcs');
                 });
         },

         // Behavior 49: persistentState 'not-allowed' with a persistent session type -> NotSupported.
         function() {
             run('mock.persistentStateRequirement = "optional"');
             failingTestWithCapabilities([{
                     initDataTypes: ['mock'],
                     videoCapabilities: [{ contentType: 'video/mock; codecs="mock"' }],
                     persistentState: 'not-allowed',
                     sessionTypes: ['persistent-license']
                 }],
                 exceptionCode => {
                     window.exceptionCode = exceptionCode;
                     testExpected('exceptionCode.name', 'NotSupportedError');
                 });
         },

         // Behavior 50: persistentState 'optional' + persistent session type -> normalized to 'required'.
         function() {
             run('mock.persistentStateRequirement = "optional"');
             passingTestWithCapabilities([{
                     initDataTypes: ['mock'],
                     videoCapabilities: [{ contentType: 'video/mock; codecs="mock"' }],
                     persistentState: 'optional',
                     sessionTypes: ['persistent-license']
                 }],
                 mediaKeySystemAccess => {
                     window.access = mediaKeySystemAccess;
                     testExpected('access.getConfiguration().persistentState', 'required');
                     testExpected('access.getConfiguration().sessionTypes.length', '1');
                     testExpected('access.getConfiguration().sessionTypes[0]', 'persistent-license');
                 });
         },

         // Behavior 51: both audioCapabilities and videoCapabilities empty -> NotSupported.
         function() {
             failingTestWithCapabilities([{
                     initDataTypes: ['mock'],
                     audioCapabilities: [],
                     videoCapabilities: []
                 }],
                 exceptionCode => {
                     window.exceptionCode = exceptionCode;
                     testExpected('exceptionCode.name', 'NotSupportedError');
                 });
         },

         // Behavior 66: capability with a wrong-family MIME (audio in videoCapabilities) is filtered
         // out; only the video-family capability survives.
         function() {
             passingTestWithCapabilities([{
                     initDataTypes: ['mock'],
                     videoCapabilities: [
                         { contentType: 'audio/mock; codecs="mock"' },
                         { contentType: 'video/mock; codecs="mock"' }
                     ]
                 }],
                 mediaKeySystemAccess => {
                     window.access = mediaKeySystemAccess;
                     testExpected('access.getConfiguration().videoCapabilities.length', '1');
                     testExpected('access.getConfiguration().videoCapabilities[0].contentType', 'video/mock; codecs="mock"');
                 });
         },

         // Behavior 1: Key System strings are compared case-sensitively — a mis-cased name
         // MUST NOT match the registered CDM.
         function() {
             window.capabilities = [{
                 initDataTypes: ['mock'],
                 videoCapabilities: [{ contentType: 'video/mock; codecs="mock"' }]
             }];
             consoleWrite(`SET capabilities = '${ JSON.stringify(window.capabilities, null, 1) }'`);
             run('promise = navigator.requestMediaKeySystemAccess("Org.Webkit.Mock", capabilities)');
             shouldReject(promise).then(exceptionCode => {
                 window.exceptionCode = exceptionCode;
                 testExpected('exceptionCode.name', 'NotSupportedError');
             }).then(next, next);
         },

         // Behavior 10: initDataType strings are compared case-sensitively — a mis-cased type
         // ('MOCK' vs registered 'mock') MUST NOT match.
         function() {
             failingTestWithCapabilities([{
                     initDataTypes: ['MOCK'],
                     videoCapabilities: [{ contentType: 'video/mock; codecs="mock"' }]
                 }],
                 exceptionCode => {
                     window.exceptionCode = exceptionCode;
                     testExpected('exceptionCode.name', 'NotSupportedError');
                 });
         },
     ];
     </script>
 </head>
 <body onload="doTest()">
 </body>
 </html>
	<!DOCTYPE html>
	<html>
	<head>
	<script src=../video-test.js></script>
	<script type="text/javascript">
	var mock;
	var promise;
	var capabilities = {};

	function doTest ()
	{
	if (!window.internals) {
	// failTest("Internals is required for this test.")
	// return;
	}

	run('internals.initializeMockMediaSource()');
	run('mock = internals.registerMockCDM()');
	run('mock.supportedDataTypes = ["mock"]');

	next();
	}

	function next() {
	if (!tests.length) {
	mock.unregister();
	endTest()
	return;
	}

	var nextTest = tests.shift();
	consoleWrite('');
	nextTest();
	}

	function passingTestWithCapabilities(capabilities, success) {
	shouldResolve(testWithCapabilities(capabilities)).then(success).then(next, next);
	}

	function failingTestWithCapabilities(capabilities, failure) {
	shouldReject(testWithCapabilities(capabilities)).then(failure).then(next, next);
	}

	function testWithCapabilities(capabilities) {
	window.capabilities = capabilities;
	consoleWrite(`SET capabilities = '${ JSON.stringify(capabilities, null, 1) }'`);
	run('promise = navigator.requestMediaKeySystemAccess("org.webkit.mock", capabilities)');
	return promise;
	}

	tests = [
	function() {
	passingTestWithCapabilities([{
	initDataTypes: ['mock'],
	videoCapabilities: [{ contentType: 'video/mock; codecs="mock"' }]
	}],
	mediaKeySystemAccess => {
	window.access = mediaKeySystemAccess;
	testExpected('access.keySystem', 'org.webkit.mock');
	testExpected('access.getConfiguration().initDataTypes.length', '1');
	testExpected('access.getConfiguration().initDataTypes[0]', 'mock');
	testExpected('access.getConfiguration().sessionTypes.length', '1');
	testExpected('access.getConfiguration().sessionTypes[0]', 'temporary');
	testExpected('access.getConfiguration().distinctiveIdentifier', 'not-allowed');
	testExpected('access.getConfiguration().persistentState', 'not-allowed');
	});
	},

	function() {
	failingTestWithCapabilities([{
	initDataTypes: ['mock'],
	videoCapabilities: [{ contentType: 'video/mock; codecs="unknown"' }]
	}],
	exceptionCode => {
	window.exceptionCode = exceptionCode;
	testExpected('exceptionCode.name', 'NotSupportedError');
	});
	},

	function() {
	failingTestWithCapabilities([{
	initDataTypes: ['mock'],
	videoCapabilities: [{ contentType: 'unknown/mime; codecs="unknown"' }]
	}],
	exceptionCode => {
	window.exceptionCode = exceptionCode;
	testExpected('exceptionCode.name', 'NotSupportedError');
	});
	},

	function() {
	failingTestWithCapabilities([{
	initDataTypes: ['unknownType'],
	videoCapabilities: [{ contentType: 'video/mock; codecs="mock"' }]
	}],
	exceptionCode => {
	window.exceptionCode = exceptionCode;
	testExpected('exceptionCode.name', 'NotSupportedError');
	});
	},

	function() {
	run('mock.supportedRobustness = ["high"]');
	passingTestWithCapabilities([{
	initDataTypes: ['mock'],
	videoCapabilities: [{ contentType: 'video/mock; codecs="mock"', robustness: "high" }],
	}],
	mediaKeySystemAccess => {
	window.access = mediaKeySystemAccess;
	testExpected('access.getConfiguration().videoCapabilities.length', '1');
	testExpected('access.getConfiguration().videoCapabilities[0].robustness', 'high');
	});
	},

	function() {
	run('mock.supportedRobustness = ["high"]');
	failingTestWithCapabilities([{
	initDataTypes: ['mock'],
	videoCapabilities: [{ contentType: 'video/mock; codecs="mock"', robustness: "low" }],
	}],
	exceptionCode => {
	window.exceptionCode = exceptionCode;
	testExpected('exceptionCode.name', 'NotSupportedError');
	});
	},

	function() {
	run('mock.distinctiveIdentifierRequirement = "not-allowed"');
	passingTestWithCapabilities([{
	initDataTypes: ['mock'],
	videoCapabilities: [{ contentType: 'video/mock; codecs="mock"'}],
	distinctiveIdentifier: 'optional'
	}],
	mediaKeySystemAccess => {
	window.access = mediaKeySystemAccess;
	testExpected('access.getConfiguration().distinctiveIdentifier', 'not-allowed');
	});
	},

	function() {
	run('mock.distinctiveIdentifiersRequirement = "required"');
	passingTestWithCapabilities([{
	initDataTypes: ['mock'],
	videoCapabilities: [{ contentType: 'video/mock; codecs="mock"'}],
	distinctiveIdentifier: 'optional'
	}],
	mediaKeySystemAccess => {
	window.access = mediaKeySystemAccess;
	testExpected('access.getConfiguration().distinctiveIdentifier', 'required');
	});
	},

	function() {
	run('mock.distinctiveIdentifiersRequirement = "not-allowed"');
	failingTestWithCapabilities([{
	initDataTypes: ['mock'],
	videoCapabilities: [{ contentType: 'video/mock; codecs="mock"'}],
	distinctiveIdentifier: 'required'
	}],
	exceptionCode => {
	window.exceptionCode = exceptionCode;
	testExpected('exceptionCode.name', 'NotSupportedError');
	});
	},

	function() {
	run('mock.distinctiveIdentifiersRequirement = "not-allowed"');
	passingTestWithCapabilities([{
	label: 'distinctive-identifiers-required',
	initDataTypes: ['mock'],
	videoCapabilities: [{ contentType: 'video/mock; codecs="mock"'}],
	distinctiveIdentifier: 'required'
	}, {
	label: 'distinctive-identifiers-not-required',
	initDataTypes: ['mock'],
	videoCapabilities: [{ contentType: 'video/mock; codecs="mock"'}],
	distinctiveIdentifier: 'optional'
	}],
	mediaKeySystemAccess => {
	window.access = mediaKeySystemAccess;
	testExpected('access.getConfiguration().label', 'distinctive-identifiers-not-required');
	testExpected('access.getConfiguration().distinctiveIdentifier', 'not-allowed');
	});
	},

	function() {
	run('mock.persistentStateRequirement = "required"');
	passingTestWithCapabilities([{
	initDataTypes: ['mock'],
	videoCapabilities: [{ contentType: 'video/mock; codecs="mock"'}],
	persistentState: 'optional'
	}],
	mediaKeySystemAccess => {
	window.access = mediaKeySystemAccess;
	testExpected('access.getConfiguration().persistentState', 'required');
	});
	},

	function() {
	run('mock.persistentStateRequirement = "not-allowed"');
	passingTestWithCapabilities([{
	initDataTypes: ['mock'],
	videoCapabilities: [{ contentType: 'video/mock; codecs="mock"'}],
	persistentState: 'optional'
	}],
	mediaKeySystemAccess => {
	window.access = mediaKeySystemAccess;
	testExpected('access.getConfiguration().persistentState', 'not-allowed');
	});
	},

	function() {
	run('mock.persistentStateRequirement = "not-allowed"');
	failingTestWithCapabilities([{
	initDataTypes: ['mock'],
	videoCapabilities: [{ contentType: 'video/mock; codecs="mock"'}],
	persistentState: 'required'
	}],
	exceptionCode => {
	window.exceptionCode = exceptionCode;
	testExpected('exceptionCode.name', 'NotSupportedError');
	});
	},

	function() {
	run('mock.persistentStateRequirement = "not-allowed"');
	passingTestWithCapabilities([{
	label: 'persistent-state-required',
	initDataTypes: ['mock'],
	videoCapabilities: [{ contentType: 'video/mock; codecs="mock"'}],
	persistentState: 'required'
	}, {
	label: 'persistent-state-not-required',
	initDataTypes: ['mock'],
	videoCapabilities: [{ contentType: 'video/mock; codecs="mock"'}],
	persistentState: 'optional'
	}],
	mediaKeySystemAccess => {
	window.access = mediaKeySystemAccess;
	testExpected('access.getConfiguration().label', 'persistent-state-not-required');
	testExpected('access.getConfiguration().persistentState', 'not-allowed');
	});
	},

	function() {
	run('mock.supportedEncryptionSchemes = ["cenc"]');
	passingTestWithCapabilities([{
	label: 'encryption-scheme-cenc',
	initDataTypes: ['mock'],
	videoCapabilities: [{ contentType: 'video/mock; codecs="mock"', encryptionScheme: 'cenc'}],
	}],
	mediaKeySystemAccess => {
	window.access = mediaKeySystemAccess;
	testExpected('access.getConfiguration().label', 'encryption-scheme-cenc');
	testExpected('access.getConfiguration().videoCapabilities[0].encryptionScheme', 'cenc');
	});
	},

	function() {
	failingTestWithCapabilities([{
	initDataTypes: ['mock'],
	videoCapabilities: [{ contentType: 'video/mock; codecs="mock"', encryptionScheme: 'cbcs'}],
	}],
	exceptionCode => {
	window.exceptionCode = exceptionCode;
	testExpected('exceptionCode.name', 'NotSupportedError');
	});
	},

	function() {
	run('mock.supportedEncryptionSchemes = ["cenc", "cbcs"]');
	passingTestWithCapabilities([{
	label: 'encryption-scheme-cbcs',
	initDataTypes: ['mock'],
	videoCapabilities: [{ contentType: 'video/mock; codecs="mock"', encryptionScheme: 'cbcs'}],
	}],
	mediaKeySystemAccess => {
	window.access = mediaKeySystemAccess;
	testExpected('access.getConfiguration().label', 'encryption-scheme-cbcs');
	testExpected('access.getConfiguration().videoCapabilities[0].encryptionScheme', 'cbcs');
	});
	},

	// Behavior 49: persistentState 'not-allowed' with a persistent session type -> NotSupported.
	function() {
	run('mock.persistentStateRequirement = "optional"');
	failingTestWithCapabilities([{
	initDataTypes: ['mock'],
	videoCapabilities: [{ contentType: 'video/mock; codecs="mock"' }],
	persistentState: 'not-allowed',
	sessionTypes: ['persistent-license']
	}],
	exceptionCode => {
	window.exceptionCode = exceptionCode;
	testExpected('exceptionCode.name', 'NotSupportedError');
	});
	},

	// Behavior 50: persistentState 'optional' + persistent session type -> normalized to 'required'.
	function() {
	run('mock.persistentStateRequirement = "optional"');
	passingTestWithCapabilities([{
	initDataTypes: ['mock'],
	videoCapabilities: [{ contentType: 'video/mock; codecs="mock"' }],
	persistentState: 'optional',
	sessionTypes: ['persistent-license']
	}],
	mediaKeySystemAccess => {
	window.access = mediaKeySystemAccess;
	testExpected('access.getConfiguration().persistentState', 'required');
	testExpected('access.getConfiguration().sessionTypes.length', '1');
	testExpected('access.getConfiguration().sessionTypes[0]', 'persistent-license');
	});
	},

	// Behavior 51: both audioCapabilities and videoCapabilities empty -> NotSupported.
	function() {
	failingTestWithCapabilities([{
	initDataTypes: ['mock'],
	audioCapabilities: [],
	videoCapabilities: []
	}],
	exceptionCode => {
	window.exceptionCode = exceptionCode;
	testExpected('exceptionCode.name', 'NotSupportedError');
	});
	},

	// Behavior 66: capability with a wrong-family MIME (audio in videoCapabilities) is filtered
	// out; only the video-family capability survives.
	function() {
	passingTestWithCapabilities([{
	initDataTypes: ['mock'],
	videoCapabilities: [
	{ contentType: 'audio/mock; codecs="mock"' },
	{ contentType: 'video/mock; codecs="mock"' }
	]
	}],
	mediaKeySystemAccess => {
	window.access = mediaKeySystemAccess;
	testExpected('access.getConfiguration().videoCapabilities.length', '1');
	testExpected('access.getConfiguration().videoCapabilities[0].contentType', 'video/mock; codecs="mock"');
	});
	},

	// Behavior 1: Key System strings are compared case-sensitively — a mis-cased name
	// MUST NOT match the registered CDM.
	function() {
	window.capabilities = [{
	initDataTypes: ['mock'],
	videoCapabilities: [{ contentType: 'video/mock; codecs="mock"' }]
	}];
	consoleWrite(`SET capabilities = '${ JSON.stringify(window.capabilities, null, 1) }'`);
	run('promise = navigator.requestMediaKeySystemAccess("Org.Webkit.Mock", capabilities)');
	shouldReject(promise).then(exceptionCode => {
	window.exceptionCode = exceptionCode;
	testExpected('exceptionCode.name', 'NotSupportedError');
	}).then(next, next);
	},

	// Behavior 10: initDataType strings are compared case-sensitively — a mis-cased type
	// ('MOCK' vs registered 'mock') MUST NOT match.
	function() {
	failingTestWithCapabilities([{
	initDataTypes: ['MOCK'],
	videoCapabilities: [{ contentType: 'video/mock; codecs="mock"' }]
	}],
	exceptionCode => {
	window.exceptionCode = exceptionCode;
	testExpected('exceptionCode.name', 'NotSupportedError');
	});
	},
	];
	</script>
	</head>
	<body onload="doTest()">
	</body>
	</html>