diff options
Diffstat (limited to 'testing/web-platform/tests/proximity')
6 files changed, 880 insertions, 0 deletions
diff --git a/testing/web-platform/tests/proximity/DeviceProximityEvent_tests.html b/testing/web-platform/tests/proximity/DeviceProximityEvent_tests.html new file mode 100644 index 000000000..d4d08fda7 --- /dev/null +++ b/testing/web-platform/tests/proximity/DeviceProximityEvent_tests.html @@ -0,0 +1,10 @@ +<!doctype html> +<meta charset=utf8> +<meta content="width=device-width, initial-scale=1" name=viewport> +<title>Proximity Events Test Suite</title> +<h1>Test Suite for Proximity Events</h1> +<div id="log"></div> +<script src="/resources/testharness.js"></script> +<script src="/resources/testharnessreport.js"></script> +<script src="DeviceProximityEvent_tests.js"></script> + diff --git a/testing/web-platform/tests/proximity/DeviceProximityEvent_tests.js b/testing/web-platform/tests/proximity/DeviceProximityEvent_tests.js new file mode 100644 index 000000000..4d3c00c0a --- /dev/null +++ b/testing/web-platform/tests/proximity/DeviceProximityEvent_tests.js @@ -0,0 +1,439 @@ +(function() { + //inheritance tests + test(function() { + var event = new DeviceProximityEvent(''); + assert_true(event instanceof window.DeviceProximityEvent); + }, 'the event is an instance of DeviceProximityEvent'); + + test(function() { + var event = new DeviceProximityEvent(''); + assert_true(event instanceof window.Event); + }, 'the event inherits from Event'); + + //Type attribute tests + test(function() { + assert_throws(new TypeError(), function() { + new DeviceProximityEvent(); + }, 'First argument is required, so was expecting a TypeError.'); + }, 'Missing type argument'); + + test(function() { + var event = new DeviceProximityEvent(undefined); + assert_equals(event.type, 'undefined'); + }, 'Event type set to undefined'); + + test(function() { + var event = new DeviceProximityEvent(null); + assert_equals(event.type, 'null'); + }, 'type argument is null'); + + test(function() { + var event = new DeviceProximityEvent(123); + assert_equals(event.type, '123'); + }, 'type argument is number'); + + test(function() { + var event = new DeviceProximityEvent(new Number(123)); + assert_equals(event.type, '123'); + }, 'type argument is Number'); + + test(function() { + var event = new DeviceProximityEvent([]); + assert_equals(event.type, ''); + }, 'type argument is array'); + + test(function() { + var event = new DeviceProximityEvent(new Array()); + assert_equals(event.type, ''); + }, 'type argument is instance of Array'); + + test(function() { + var event = new DeviceProximityEvent(['t', ['e', ['s', ['t']]]]); + assert_equals(event.type, 't,e,s,t'); + }, 'type argument is nested array'); + + test(function() { + var event = new DeviceProximityEvent(Math); + assert_equals(event.type, '[object Math]'); + }, 'type argument is host object'); + + test(function() { + var event = new DeviceProximityEvent(true); + assert_equals(event.type, 'true'); + }, 'type argument is boolean (true)'); + + test(function() { + var event = new DeviceProximityEvent(new Boolean(true)); + assert_equals(event.type, 'true'); + }, 'type argument is instance of Boolean (true)'); + + test(function() { + var event = new DeviceProximityEvent(false); + assert_equals(event.type, 'false'); + }, 'type argument is boolean (false)'); + + test(function() { + var event = new DeviceProximityEvent(new Boolean(false)); + assert_equals(event.type, 'false'); + }, 'type argument is instance of Boolean (false)'); + + test(function() { + var event = new DeviceProximityEvent('test'); + assert_equals(event.type, 'test'); + }, 'type argument is string'); + + test(function() { + var event = new DeviceProximityEvent(new String('test')); + assert_equals(event.type, 'test'); + }, 'type argument is instance of String'); + + test(function() { + var event = new DeviceProximityEvent(function test() {}); + assert_regexp_match(event.type, /function test.+{\s?}/); + }, 'type argument is function'); + + test(function() { + var event = new DeviceProximityEvent({ + toString: function() { + return '123'; + } + }); + assert_equals(event.type, '123'); + }, 'type argument is complext object, with toString method'); + + test(function() { + assert_throws(new TypeError(), function() { + new DeviceProximityEvent({ + toString: function() { + return function() {} + } + }); + }); + }, 'toString is of type function'); + + //eventInitDict attribute tests + test(function() { + var event = new DeviceProximityEvent('test', undefined); + assert_equals(event.value, Infinity); + assert_equals(event.min, -Infinity); + assert_equals(event.max, Infinity); + }, 'eventInitDict argument sets to undefined'); + + test(function() { + var event = new DeviceProximityEvent('test', null); + assert_equals(event.value, Infinity); + assert_equals(event.min, -Infinity); + assert_equals(event.max, Infinity); + }, 'eventInitDict argument is null'); + + test(function() { + var date = new Date(); + assert_throws(new TypeError(), function() { + new DeviceProximityEvent('test', date); + }); + }, 'eventInitDict argument is Date object'); + + test(function() { + var regexp = /abc/; + assert_throws(new TypeError(), function() { + new DeviceProximityEvent('test', regexp); + }); + }, 'eventInitDict argument is RegExp object'); + + test(function() { + assert_throws(new TypeError(), function() { + new DeviceProximityEvent('test', false); + }); + }, 'eventInitDict argument is boolean'); + + test(function() { + assert_throws(new TypeError(), function() { + new DeviceProximityEvent('test', 123); + }); + }, 'eventInitDict argument is number'); + + test(function() { + assert_throws(new TypeError(), function() { + new DeviceProximityEvent('test', 'hello'); + }); + }, 'eventInitDict argument is string'); + + //test readonly attribute unrestricted double value; + test(function() { + var event = new DeviceProximityEvent('test'); + assert_idl_attribute(event, 'value', 'must have attribute value'); + }, 'value attribute exist'); + + test(function() { + var event = new DeviceProximityEvent('test'); + assert_readonly(event, 'value', 'readonly attribute value'); + }, 'value attribute is readonly'); + + test(function() { + var event = new DeviceProximityEvent('test'); + assert_equals(event.value, Infinity); + }, 'value initializes to positive Infinity'); + + test(function() { + var event = new DeviceProximityEvent('test', { + value: Infinity + }); + assert_equals(event.value, Infinity); + }, 'value set to positive Infinity'); + + test(function() { + var event = new DeviceProximityEvent('test', { + value: -Infinity + }); + assert_equals(event.value, -Infinity); + }, 'value set to negative Infinity'); + + test(function() { + var event = new DeviceProximityEvent('test', { + value: 0 + }); + assert_equals(event.value, 0); + }, 'value set to 0'); + + test(function() { + var event = new DeviceProximityEvent('test', { + value: 1 + }); + assert_equals(event.value, 1); + }, 'value set to 1'); + + test(function() { + var event = new DeviceProximityEvent('test', { + value: 0.5 + }); + assert_equals(event.value, 0.5); + }, 'value set to 0.5'); + + test(function() { + var event = new DeviceProximityEvent('test', { + value: false + }); + assert_equals(event.value, 0, 'value set to false, converts to 0.'); + }, 'value set to false'); + + test(function() { + var event = new DeviceProximityEvent('test', { + value: true + }); + assert_equals(event.value, 1, 'value set to true, converts to 1.'); + }, 'value set to true'); + + + test(function() { + var prop = { + value: undefined + }; + try { + var event = new DeviceProximityEvent('test', prop); + assert_true(isNaN(event.value)); + } catch(e) { + assert_unreached('error message: ' + e.message); + } + }, 'value of undefined resolves to NaN'); + + test(function() { + var event = new DeviceProximityEvent('test', { + value: null + }); + assert_equals(event.value, 0, 'value resolves to 0'); + }, 'value of null resolves to 0'); + + test(function() { + var event = new DeviceProximityEvent('test', { + value: '' + }); + assert_equals(event.value, 0, 'value must resolve to 0'); + }, 'value of empty string must resolve to 0'); + + test(function() { + var event = new DeviceProximityEvent('test', { + value: '\u0020' + }); + assert_equals(event.value, 0, 'value must resolve to 0'); + }, 'value of U+0020 must resolve to 0'); + + test(function() { + var event = new DeviceProximityEvent('test', { + value: '\u0020\u0020\u0020\u0020\u0020\u0020' + }); + assert_equals(event.value, 0, 'value must resolve to 0'); + }, 'value of multiple U+0020 must resolve to 0'); + + test(function() { + var event = new DeviceProximityEvent('test', { + value: '\u0020\u0020\u00201234\u0020\u0020\u0020' + }); + assert_equals(event.value, 1234, 'converts to 1234'); + }, 'value converts to 1234'); + + test(function() { + var event = new DeviceProximityEvent('test', { + value: [] + }); + assert_equals(event.value, 0, 'converts to 0'); + }, 'value converts to 0'); + + + test(function() { + var prop = { + value: {} + }; + try { + var event = new DeviceProximityEvent('test', prop); + assert_true(isNaN(event.value)); + } catch(e) { + assert_unreached('error message: ' + e.message); + } + }, 'value of {} resolves to NaN'); + + test(function() { + var prop = { + get value() { + return NaN; + } + }; + try { + var event = new DeviceProximityEvent('test', prop); + assert_true(isNaN(event.value)); + } catch(e) { + assert_unreached('error message: ' + e.message); + } + }, 'value resolves to NaN'); + + test(function() { + var prop = { + get value() { + return '123'; + } + }; + var event = new DeviceProximityEvent('test', prop); + assert_equals(event.value, 123, 'converts to 123'); + }, 'value resolves 123'); + + //test readonly attribute unrestricted double min + test(function() { + var event = new DeviceProximityEvent('test'); + assert_idl_attribute(event, 'min', 'must have attribute min'); + }, 'min attribute exist'); + + test(function() { + var event = new DeviceProximityEvent('test'); + assert_readonly(event, 'min', 'readonly attribute min'); + }, 'min attribute is readonly'); + + test(function() { + var event = new DeviceProximityEvent('test'); + assert_equals(event.min, -Infinity); + }, 'min initializes to negative Infinity'); + + //test readonly attribute unrestricted double max; + test(function() { + var event = new DeviceProximityEvent('test'); + assert_idl_attribute(event, 'max', 'must have attribute max'); + }, 'max attribute exist'); + + test(function() { + var event = new DeviceProximityEvent('test'); + assert_readonly(event, 'max', 'readonly attribute max'); + }, 'max attribute is readonly'); + + test(function() { + var event = new DeviceProximityEvent('test'); + assert_equals(event.max, Infinity); + }, 'max initializes to positive Infinity'); + + //test attribute EventHandler ondeviceproximity; + test(function() { + var desc = 'Expected to find ondeviceproximity attribute on window object'; + assert_idl_attribute(window, 'ondeviceproximity', desc); + }, 'ondeviceproximity exists'); + + test(function() { + var desc = 'window.ondeviceproximity must be null'; + assert_equals(window.ondeviceproximity, null, desc); + }, 'ondeviceproximity is null'); + + test(function() { + var desc = 'window.ondeviceproximity did not accept callable object', + func = function() {}, + descidl = 'Expected to find ondeviceproximity attribute on window object'; + assert_idl_attribute(window, 'ondeviceproximity', descidl); + window.ondeviceproximity = func; + assert_equals(window.ondeviceproximity, func, desc); + }, 'ondeviceproximity is set to function'); + + test(function() { + var desc = 'window.ondeviceproximity did not treat noncallable as null'; + window.ondeviceproximity = function() {}; + window.ondeviceproximity = {}; + assert_equals(window.ondeviceproximity, null, desc); + }, 'treat object as null'); + + test(function() { + var desc = 'window.ondeviceproximity did not treat noncallable as null'; + window.ondeviceproximity = function() {}; + window.ondeviceproximity = { + call: 'test' + }; + assert_equals(window.ondeviceproximity, null, desc); + }, 'treat object with non-callable call property as null'); + + test(function() { + var desc = 'window.ondeviceproximity did not treat noncallable (string) as null'; + window.ondeviceproximity = function() {}; + window.ondeviceproximity = 'string'; + assert_equals(window.ondeviceproximity, null, desc); + }, 'treat string as null'); + + test(function() { + var desc = 'window.ondeviceproximity did not treat noncallable (number) as null'; + window.ondeviceproximity = function() {}; + window.ondeviceproximity = 123; + assert_equals(window.ondeviceproximity, null, desc); + }, 'treat number as null'); + + test(function() { + var desc = 'window.ondeviceproximity did not treat noncallable (undefined) as null'; + window.ondeviceproximity = function() {}; + window.ondeviceproximity = undefined; + assert_equals(window.ondeviceproximity, null, desc); + }, 'treat undefined as null'); + + test(function() { + var desc = 'window.ondeviceproximity did not treat noncallable (array) as null'; + window.ondeviceproximity = function() {}; + window.ondeviceproximity = []; + assert_equals(window.ondeviceproximity, null, desc); + }, 'treat array as null'); + + test(function() { + var desc = 'window.ondeviceproximity did not treat noncallable host object as null'; + window.ondeviceproximity = function() {}; + window.ondeviceproximity = Node; + assert_equals(window.ondeviceproximity, null, desc); + }, 'treat non-callable host object as null'); + + //Async tests + var t = async_test('test if device proximity event received'); + window.addEventListener('deviceproximity', function(e) { + t.step(function() { + var msg = 'expected instance of DeviceProximityEvent: '; + assert_true(e instanceof window.DeviceProximityEvent, msg); + }); + t.done(); + }); + + var t2 = async_test('test if user proximity event received'); + window.ondeviceproximity = function(e) { + t2.step(function() { + var msg = 'expected instance of DeviceProximityEvent: '; + assert_true(e instanceof window.DeviceProximityEvent, msg); + }); + t2.done(); + }; +})(); diff --git a/testing/web-platform/tests/proximity/OWNERS b/testing/web-platform/tests/proximity/OWNERS new file mode 100644 index 000000000..7fab6d626 --- /dev/null +++ b/testing/web-platform/tests/proximity/OWNERS @@ -0,0 +1,2 @@ +@zqzhang +@dontcallmedom diff --git a/testing/web-platform/tests/proximity/UserProximityEvent_tests.html b/testing/web-platform/tests/proximity/UserProximityEvent_tests.html new file mode 100644 index 000000000..f58550db0 --- /dev/null +++ b/testing/web-platform/tests/proximity/UserProximityEvent_tests.html @@ -0,0 +1,10 @@ +<!doctype html> +<meta charset=utf8> +<meta content="width=device-width, initial-scale=1" name=viewport> +<title>Proximity Events Test Suite</title> +<h1>Test Suite for Proximity Events</h1> +<div id="log"></div> +<script src="/resources/testharness.js"></script> +<script src="/resources/testharnessreport.js"></script> +<script src="UserProximityEvent_tests.js"></script> + diff --git a/testing/web-platform/tests/proximity/UserProximityEvent_tests.js b/testing/web-platform/tests/proximity/UserProximityEvent_tests.js new file mode 100644 index 000000000..cac5bd586 --- /dev/null +++ b/testing/web-platform/tests/proximity/UserProximityEvent_tests.js @@ -0,0 +1,342 @@ +(function() { + //inheritance tests + test(function() { + var event = new UserProximityEvent(''); + assert_true(event instanceof window.UserProximityEvent); + }, 'the event is an instance of UserProximityEvent'); + + test(function() { + var event = new UserProximityEvent(''); + assert_true(event instanceof window.Event); + }, 'the event inherits from Event'); + + //Type attribute tests + test(function() { + assert_throws(new TypeError(), function() { + new UserProximityEvent(); + }, 'First argument is required, so was expecting a TypeError.'); + }, 'Missing type argument'); + + test(function() { + var event = new UserProximityEvent(undefined); + assert_equals(event.type, 'undefined'); + }, 'Event type set to undefined'); + + test(function() { + var event = new UserProximityEvent(null); + assert_equals(event.type, 'null'); + }, 'type argument is null'); + + test(function() { + var event = new UserProximityEvent(123); + assert_equals(event.type, '123'); + }, 'type argument is number'); + + test(function() { + var event = new UserProximityEvent(new Number(123)); + assert_equals(event.type, '123'); + }, 'type argument is Number'); + + test(function() { + var event = new UserProximityEvent([]); + assert_equals(event.type, ''); + }, 'type argument is array'); + + test(function() { + var event = new UserProximityEvent(new Array()); + assert_equals(event.type, ''); + }, 'type argument is instance of Array'); + + test(function() { + var event = new UserProximityEvent(['t', ['e', ['s', ['t']]]]); + assert_equals(event.type, 't,e,s,t'); + }, 'type argument is nested array'); + + test(function() { + var event = new UserProximityEvent(Math); + assert_equals(event.type, '[object Math]'); + }, 'type argument is host object'); + + test(function() { + var event = new UserProximityEvent(true); + assert_equals(event.type, 'true'); + }, 'type argument is boolean (true)'); + + test(function() { + var event = new UserProximityEvent(new Boolean(true)); + assert_equals(event.type, 'true'); + }, 'type argument is instance of Boolean (true)'); + + test(function() { + var event = new UserProximityEvent(false); + assert_equals(event.type, 'false'); + }, 'type argument is boolean (false)'); + + test(function() { + var event = new UserProximityEvent(new Boolean(false)); + assert_equals(event.type, 'false'); + }, 'type argument is instance of Boolean (false)'); + + test(function() { + var event = new UserProximityEvent('test'); + assert_equals(event.type, 'test'); + }, 'type argument is string'); + + test(function() { + var event = new UserProximityEvent(new String('test')); + assert_equals(event.type, 'test'); + }, 'type argument is instance of String'); + + test(function() { + var event = new UserProximityEvent(function test() {}); + assert_regexp_match(event.type, /function test.+{\s?}/); + }, 'type argument is function'); + + test(function() { + var event = new UserProximityEvent({ + toString: function() { + return '123'; + } + }); + assert_equals(event.type, '123'); + }, 'type argument is complext object, with toString method'); + + test(function() { + assert_throws(new TypeError(), function() { + new UserProximityEvent({ + toString: function() { + return function() {} + } + }); + }); + }, 'toString is of type function'); + + //eventInitDict attribute tests + test(function() { + var event = new UserProximityEvent('test', undefined); + assert_false(event.near); + }, 'eventInitDict argument sets to undefined'); + + test(function() { + var event = new UserProximityEvent('test', null); + assert_false(event.near); + }, 'eventInitDict argument is null'); + + test(function() { + var date = new Date(); + assert_throws(new TypeError(), function() { + new UserProximityEvent('test', date); + }); + }, 'eventInitDict argument is Date object'); + + test(function() { + var regexp = /abc/; + assert_throws(new TypeError(), function() { + new UserProximityEvent('test', regexp); + }); + }, 'eventInitDict argument is RegExp object'); + + test(function() { + assert_throws(new TypeError(), function() { + new UserProximityEvent('test', false); + }); + }, 'eventInitDict argument is boolean'); + + test(function() { + assert_throws(new TypeError(), function() { + new UserProximityEvent('test', 123); + }); + }, 'eventInitDict argument is number'); + + test(function() { + assert_throws(new TypeError(), function() { + new UserProximityEvent('test', 'hello'); + }); + }, 'eventInitDict argument is string'); + + //test readonly attribute boolean near; + test(function() { + var event = new UserProximityEvent('test'); + assert_idl_attribute(event, 'near', 'must have attribute near'); + }, 'must have attribute near'); + + test(function() { + var event = new UserProximityEvent('test'); + assert_readonly(event, 'near', 'readonly attribute near'); + }, 'near is readonly'); + + test(function() { + var event = new UserProximityEvent('test'); + assert_false(event.near, 'near initializes to false'); + }, 'near initializes to false'); + + test(function() { + var event = new UserProximityEvent('test', { + near: false + }); + assert_false(event.near, 'near set to false'); + }, 'near set to false'); + + test(function() { + var event = new UserProximityEvent('test', { + near: true + }); + assert_true(event.near, 'near set to true'); + }, 'near set to true'); + + test(function() { + var event = new UserProximityEvent('test', { + near: undefined + }); + assert_false(event.near, 'argument is truthy'); + }, 'near set to undefined'); + + test(function() { + var event = new UserProximityEvent('test', { + near: null + }); + assert_false(event.near, 'argument is flasy'); + }, 'near set to null'); + + test(function() { + var event = new UserProximityEvent('test', { + near: 0 + }); + assert_false(event.near, 'argument is flasy'); + }, 'near set to 0'); + + test(function() { + var event = new UserProximityEvent('test', { + near: '' + }); + assert_false(event.near, 'argument is flasy'); + }, 'near set to empty string'); + + test(function() { + var event = new UserProximityEvent('test', { + near: '\u0020' + }); + assert_true(event.near, 'argument is truthy'); + }, 'near set to U+0020'); + + test(function() { + var event = new UserProximityEvent('test', { + near: 1 + }); + assert_true(event.near, 'argument is truthy'); + }, 'near set to 1'); + + test(function() { + var event = new UserProximityEvent('test', { + near: [] + }); + assert_true(event.near, 'argument is truthy'); + }, 'near set to []'); + + test(function() { + var event = new UserProximityEvent('test', { + near: {} + }); + assert_true(event.near, 'argument is truthy'); + }, 'near set to {}'); + + test(function() { + var dict = { + get test() { + return false; + } + }; + var event = new UserProximityEvent('test', { + near: dict.test + }); + assert_false(event.near, 'explict false'); + }, 'near set to object that resolves to false'); + + test(function() { + var desc = 'Expected to find onuserproximity attribute on window object'; + assert_idl_attribute(window, 'onuserproximity', desc); + }, 'onuserproximity exists'); + + test(function() { + var desc = 'window.onuserproximity must be null'; + assert_equals(window.onuserproximity, null, desc); + }, 'onuserproximity is null'); + + test(function() { + var desc = 'window.onuserproximity did not accept callable object', + func = function() {}, + descidl = 'onuserproximity does not exist'; + window.onuserproximity = func; + assert_equals(window.onuserproximity, func, descidl); + }, 'onuserproximity exists and can be set to a function'); + + test(function() { + var desc = 'window.onuserproximity did not treat noncallable as null'; + window.onuserproximity = function() {}; + window.onuserproximity = {}; + assert_equals(window.onuserproximity, null, desc); + }, 'treat object as null'); + + test(function() { + var desc = 'window.onuserproximity did not treat noncallable as null'; + window.onuserproximity = function() {}; + window.onuserproximity = { + call: 'test' + }; + assert_equals(window.onuserproximity, null, desc); + }, 'treat object with non-callable call property as null'); + + test(function() { + var desc = 'window.onuserproximity did not treat noncallable (string) as null'; + window.onuserproximity = function() {}; + window.onuserproximity = 'string'; + assert_equals(window.onuserproximity, null, desc); + }, 'treat string as null'); + + test(function() { + var desc = 'window.onuserproximity did not treat noncallable (number) as null'; + window.onuserproximity = function() {}; + window.onuserproximity = 123; + assert_equals(window.onuserproximity, null, desc); + }, 'treat number as null'); + + test(function() { + var desc = 'window.onuserproximity did not treat noncallable (undefined) as null'; + window.onuserproximity = function() {}; + window.onuserproximity = undefined; + assert_equals(window.onuserproximity, null, desc); + }, 'treat undefined as null'); + + test(function() { + var desc = 'window.onuserproximity did not treat noncallable (array) as null'; + window.onuserproximity = function() {}; + window.onuserproximity = []; + assert_equals(window.onuserproximity, null, desc); + }, 'treat array as null'); + + test(function() { + var desc = 'window.onuserproximity did not treat noncallable host object as null'; + window.onuserproximity = function() {}; + window.onuserproximity = Node; + assert_equals(window.onuserproximity, null, desc); + }, 'treat non-callable host object as null'); + + //Async tests + var t = async_test('test if user proximity event received'); + window.addEventListener('userproximity', function(e) { + t.step(function() { + var msg = 'expected instance of UserProximityEvent: '; + assert_true(e instanceof window.UserProximityEvent, msg); + }); + t.done(); + }); + + var t2 = async_test('test if user proximity event received (idl attribute)'); + window.onuserproximity = function(e) { + t2.step(function() { + var msg = 'expected instance of UserProximityEvent: '; + assert_true(e instanceof window.UserProximityEvent, msg); + }); + t2.done(); + }; +})(); diff --git a/testing/web-platform/tests/proximity/idlharness.html b/testing/web-platform/tests/proximity/idlharness.html new file mode 100644 index 000000000..817aa5c05 --- /dev/null +++ b/testing/web-platform/tests/proximity/idlharness.html @@ -0,0 +1,77 @@ +<!DOCTYPE html> +<meta charset="utf-8"> +<title>Proximity Events IDL tests</title> +<link rel="author" title="Intel" href="http://www.intel.com"> +<link rel="help" href="http://www.w3.org/TR/proximity/"> +<script src="/resources/testharness.js"></script> +<script src="/resources/testharnessreport.js"></script> +<script src="/resources/WebIDLParser.js"></script> +<script src="/resources/idlharness.js"></script> +<style> + pre { + display: none; + } +</style> +<div id="log"></div> + +<pre id="untested_idl"> +[PrimaryGlobal] +interface Window { +}; + +interface Event { +}; + +dictionary EventInit { +}; +</pre> + +<pre id='idl'> +partial interface Window { + attribute EventHandler ondeviceproximity; + attribute EventHandler onuserproximity; +}; + +dictionary DeviceProximityEventInit : EventInit { + double value; + double min; + double max; +}; + +[Constructor (DOMString type, optional DeviceProximityEventInit eventInitDict)] +interface DeviceProximityEvent : Event { + readonly attribute unrestricted double value; + readonly attribute unrestricted double min; + readonly attribute unrestricted double max; +}; + +dictionary UserProximityEventInit : EventInit { + boolean near; +}; + +[Constructor (DOMString type, optional UserProximityEventInit eventInitDict)] +interface UserProximityEvent : Event { + readonly attribute boolean near; +}; +</pre> + +<script> +(function() { + "use strict"; + var idl_array = new IdlArray(); + // replace 'EventHandler' and 'unrestricted double' unrecognised by idlharness.js + var idls = document.getElementById('idl').textContent.replace(/EventHandler/g, 'Function?').replace(/unrestricted double/g, 'double'); + + idl_array.add_untested_idls(document.getElementById('untested_idl').textContent); + idl_array.add_idls(idls); + + idl_array.add_objects({ + Window: ['window'], + DeviceProximityEvent: ['new DeviceProximityEvent("foo")'], + UserProximityEvent: ['new UserProximityEvent("foo")'] + }); + + idl_array.test(); +})(); +</script> + |