summaryrefslogtreecommitdiffstats
path: root/testing/web-platform/tests/proximity
diff options
context:
space:
mode:
Diffstat (limited to 'testing/web-platform/tests/proximity')
-rw-r--r--testing/web-platform/tests/proximity/DeviceProximityEvent_tests.html10
-rw-r--r--testing/web-platform/tests/proximity/DeviceProximityEvent_tests.js439
-rw-r--r--testing/web-platform/tests/proximity/OWNERS2
-rw-r--r--testing/web-platform/tests/proximity/UserProximityEvent_tests.html10
-rw-r--r--testing/web-platform/tests/proximity/UserProximityEvent_tests.js342
-rw-r--r--testing/web-platform/tests/proximity/idlharness.html77
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>
+