<!DOCTYPE html>
<meta charset="utf-8">
<title>Ambient Light Events IDL tests</title>
<link rel="author" title="Intel" href="http://www.intel.com">
<link rel="help" href="http://www.w3.org/TR/ambient-light/">
<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 ondevicelight;
};

dictionary DeviceLightEventInit : EventInit {
    unrestricted double value;
};

[Constructor (DOMString type, optional DeviceLightEventInit eventInitDict)]
interface DeviceLightEvent : Event {
    readonly    attribute unrestricted double value;
};
</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'],
    DeviceLightEvent: ['new DeviceLightEvent("foo")']
  });

  idl_array.test();
})();
</script>

