tests/spec/core/webidl.html

<!DOCTYPE html>
<html xmlns='http://www.w3.org/1999/xhtml'>
  <head>
    <meta charset='utf-8'/>
    <title>WebIDL Tests</title>
    <script class='remove' src='/js/deps/require.js' data-main='/js/profile-w3c-common'>
    </script>
    <script class='remove'>
      var respecConfig = {
              specStatus:   "ED"
          ,   shortName:    "webidl"
          ,   editors:      [{ name: "Robin Berjon", url: "http://berjon.com/" }]
          ,   wg:           "ReSpec Hackin' Gang"
          ,   wgURI:        "http://darobin.github.com/respec"
          ,   wgPublicList: "none"
          ,   wgPatentURI:  "XXX"
          ,   edDraftURI:   "http://darobin.github.com/respec"
        };
    </script>
  </head>
  <body>
<section data-dfn-for="ExampleInterface" data-link-for="ExampleInterface">
  <h2><dfn>ExampleInterface</dfn> interface</h2>
  <pre class="idl no-link-warnings">
  interface ExampleInterface {
    void exampleMethod();
    readonly attribute USVString url;
  };
  </pre>
  <dl>
    <dt><dfn>exampleMethod()</dfn></dt>
    <dd>Define <a>exampleMethod</a> here...</dd>
    <dt><dfn>url</dfn></dt>
    <dd>Define <a>url</a> here...</dd>
  </dl>
</section>
<section data-link-for="ExampleInterface">
  <h2>Here is how you link!</h2>
  <p>The <a>ExampleInterface</a> or the <a>ExampleInterface.exampleMethod()</a></p>
  <p>Or like this: <a>exampleMethod</a> - which uses data-link-for</p>
</section>
    <section id='abstract'>
      <p>
        This fake spec tried to exercise all aspects of WebIDL so as to do regression testing in this
        complex piece of code.
      </p>
    </section>
    <section id='sotd'>
      <p>
        CUSTOM PARAGRAPH
      </p>
    </section>
    <section id="records">
    <h2>Testing records</h2>
    <pre class="idl no-link-warnings">
    dictionary Foo {
      record&lt;DOMString, USVString> pass;
    };
    </pre>
    </section>
    <section id="linkToIDLSpec">
    <h2>Linking to WebIDL spec</h2>
    <pre class="idl no-link-warnings">
    [Constructor(sequence&lt;DOMString> methodData), SecureContext]
    interface LinkingTest {
      readonly attribute DOMString? aBoolAttribute;
      Promise&lt;void>            returnsPromise(unsigned long long argument);
    };
    </pre>
    </section>
    <section id="sec-parenthesis-method" data-dfn-for="ParenthesisTest" data-link-for="ParenthesisTest">
      <h2>More linking</h2>
      <pre class="idl no-link-warnings">
      interface ParenthesisTest {
          void basic();
          void noParens();
          [Something] void ext();
          unsigned long long ull(short s);
          unsigned long long ull(long s);
          getter float withName ();
          setter void named ();
          void dataLtOverride();
          void fullyQualified();
          void fullyQualifiedNoParens();
      };
      </pre>
      <p id="meth-basic-doc" data-dfn-for="ParenthesisTest">
        <dfn>ull</dfn> is a method. Its <dfn data-lt="ull!overload-1">overloaded form</dfn> returns a <code>SuperStar/</code>
      </p>
      <p><dfn data-lt="this also links">dataLtOverride()</dfn></p>
      <p><dfn>ParenthesisTest</dfn></p>
      <p><dfn>basic()</dfn>...</p>
      <p><dfn>ext()</dfn>...</p>
      <p><dfn>ull()</dfn>...</p>
      <p><dfn>paramed()</dfn>...</p>
      <p><dfn>withName()</dfn>...</p>
      <p><dfn>named()</dfn>...</p>
      <p><dfn>dfnDoesNotLinkToAnything()</dfn>...</p>
      <p><dfn>noParens</dfn>...</p>
      <p><dfn>ParenthesisTest.fullyQualified()</dfn>...</p>
      <p><dfn>ParenthesisTest.fullyQualifiedNoParens</dfn> ...</p>
      <p>1 <a>basic</a></p>
      <p>2 <a>basic()</a></p>
      <p>3 <a data-lt="basic">basic</a></p>
      <p>4 <a data-lt="basic()">basic</a></p>
      <p><a>noParens</a></p>
      <p><a>noParens()</a></p>
      <p><a data-lt="noParens">noParens</a></p>
      <p><a data-lt="noParens()">noParens</a></p>
      <p><a>noParens()</a></p>
      <p><a data-lt="this also links">this also links</a></p>
    </section>
    <p><a data-lt="ParenthesisTest.basic">test qualified</a></p>
    <p><a id="fullyQualifiedNoParens-1">ParenthesisTest.fullyQualifiedNoParens</a></p>
    <p><a id="fullyQualifiedNoParens-2">ParenthesisTest.fullyQualifiedNoParens()</a></p>
    <p><a id="fullyQualifiedNoParens-3" data-link-for="ParenthesisTest">fullyQualifiedNoParens()</a></p>
    <p><a id="fullyQualifiedNoParens-4" data-link-for="ParenthesisTest">fullyQualifiedNoParens</a></p>
    <section>
      <h2>Unsupported</h2>
      <p>
        The following aspects of WebIDL are not currently supported and are not yet tested for:
      </p>
      <ul>
        <li>
          Names that begin with <code>_</code> in the IDL must drop the leading <code>_</code> for
          their real name.
        </li>
        <li>
          Static, inherit, stringifier attributes.
        </li>
        <li>Static operations</li>
        <li>Default arguments</li>
        <li>IDL wrapping</li>
        <li>Special operations</li>
        <li>Union types</li>
        <li>partial dictionaries</li>
      </ul>
      <p>
        Support for these features will likely be added later.
      </p>
      <p>
        The following features are supposedly supported but actually buggy:
      </p>
      <ul>
        <li><em>list currently empty</em></li>
      </ul>
      <p>
        Things that still need to be done:
      </p>
      <ul>
        <li>Check that sequence, Promise, ?, and other such bothersome types are tested everywhere</li>
      </ul>
    </section>
    <section>
      <h2>Interfaces</h2>
      <p>
        Basic interface.
      </p>
      <pre id='if-basic' class='idl'>
        interface SuperStar {};
      </pre>
      <p>
        Interface with extended attribute.
      </p>
      <pre id='if-extended-attribute' class='idl'>
        [Something, Constructor()] interface SuperStar {};
      </pre>
      <p>
        Interface with extended attribute and RHS identifier list.
      </p>
      <pre id='if-identifier-list' class='idl'>
        [Global=Window, Exposed=(Window,Worker)] interface SuperStar {};
      </pre>
      <p>
        Interface with inheritance.
      </p>
      <pre id='if-inheritance' class='idl'>
        interface SuperStar : HyperStar {};
      </pre>
      <p>
        Partial interface .
      </p>
      <pre id='if-partial' class='idl'>
        partial interface SuperStar {};
      </pre>
      <p>
        Callback interface .
      </p>
      <pre id='if-callback' class='idl'>
        callback interface SuperStar {};
      </pre>
      <p>
        Interface mixin .
      </p>
      <pre id='if-mixin' class='idl'>
        interface mixin SuperStar {};
      </pre>
      <pre id='if-partial-mixin' class='idl'>
        partial interface mixin SuperStar {};
      </pre>
      <pre id='if-doc' class='idl'>
        interface DocInterface {};
        interface DocIsNotCaseSensitive {};
        interface UndocInterface {};
      </pre>
      <p id='if-doc-p'><dfn>DocInterface</dfn> is an interface and so is <dfn>DoCiSnOtCaSeSeNsItIvE</dfn>.</p>
    </section>
    <section>
      <h2>Constructors</h2>
      <p>
        Constructors on interfaces
      </p>
      <pre id='ctor-basic' class='idl'>
        [Something,
         Constructor,
         Constructor(boolean bar, sequence&lt;double> foo, Promise&lt;double&gt; blah)]
        interface SuperStar {};
      </pre>
      <pre id='ctor-noea' class='idl'>
        [Constructor] interface SuperStar {};
      </pre>
    </section>
    <section>
      <h2>NamedConstructors</h2>
      <p>
        NamedConstructors on interfaces
      </p>
      <pre id='namedctor-basic' class='idl'>
        [Something,
         NamedConstructor=Sun(),
         NamedConstructor=Sun(boolean bar, Date foo)]
        interface SuperStar {};
      </pre>
    </section>
    <section>
      <h2>Constants</h2>
      <p>
        All constants and some type testing
      </p>
      <pre id='const-basic' class='idl'>
        interface ConstTest {
          // 1
          const boolean test = true;
          // 2
          const byte bite = 8;
          // 3
          const octet eight = 7;
          // 4
          const short small = 42;
          // 5
          const unsigned short shortish = 250;
          // 6
          const long notSoLong = 99999;
          // 7
          const unsigned long somewhatLong = 9999999;
          // 8
          const long long veryLong = 9999999999999;
          // 9
          const unsigned long long soLong = 99999999999999999;
          // 10
          const float ationDevice = 4.2;
          // 11
          const unrestricted float buoy = 4.2222222222;
          // 12
          const double twice = 4.222222222;
          // 13
          const unrestricted double rambaldi = 47.0;

          // 14
          const boolean? why = false;
          // 15
          const boolean? notSo = null;
          // 16
          const short inf = Infinity;
          // 17
          const short mininf = -Infinity;
          // 18
          const short cheese = NaN;
          // 19
          [Something] const short extAttr = NaN;
        };
      </pre>
      <p id="const-basic-doc">
        <dfn data-dfn-for="ConstTest">rambaldi</dfn> is a constant and so are <dfn data-dfn-for="ConstTest">why</dfn> and <dfn data-dfn-for="ConstTest" data-lt="inf">this other thing</dfn>.
      </p>
    </section>
    <section>
      <h2>Attributes</h2>
      <p>
        Basic attributes testing.
      </p>
      <pre id='attr-basic' class='idl'>
        interface AttrBasic {
          // 1
          attribute DOMString regular;
          // 2
          readonly attribute DOMString ro;
          // 2.2
          readonly attribute DOMString _readonly;
          // 2.5
          inherit attribute DOMString in;
          // 2.7
          stringifier attribute DOMString st;
          // 3
          [Something] readonly attribute DOMString ext;
          // 3.10.31
          attribute FrozenArray&lt;DOMString&gt; alist;
          // 4.0
          attribute Promise&lt;DOMString&gt; operation;<!--

          // 3
           static attribute DOMString unmovable;
          // 4
          stringifier attribute DOMString asString;
          // 5
          inherit attribute DOMString css;
          // 6
          static inherit readonly attribute DOMString everything;
          // 7
          stringifier inherit readonly attribute DOMString all;-->
        };
      </pre>
      <p id="attr-basic-doc" data-dfn-for="AttrBasic"><dfn>readonly</dfn> and <dfn>regular</dfn> are attributes.</p>
    </section>
    <section>
      <h2>Operations</h2>
      <p>
        Basic operations testing.
      </p>
      <!--
      getter, setter, creator, deleter, legacycaller, stringifier, serilizer
      static
      specials don't necessarily have an indentifier
       -->
      <pre id='meth-basic' class='idl'>
        interface MethBasic {
          // 1
          void basic();
          // 2
          [Something] void ext();
          // 3
          unsigned long long ull(short s);
          // 3.5
          SuperStar? ull();
          // 5
          getter float ();
          // 6
          getter float withName ();
          // 7
          setter void ();
          // 8
          setter void named ();
<!--        ... and other special operations
     -->};
      </pre>
      <p id="meth-basic-doc" data-dfn-for="MethBasic">
        <dfn>ull</dfn> is a method. Its <dfn data-lt="ull!overload-1">overloaded form</dfn> returns a <code>SuperStar/</code>
      </p>
    </section>
    <section>
      <h2>Comments</h2>
      <pre id="comments-basic" class='idl'>
        interface SuperStar {
          // This is a comment
          // over two lines.
          /* This one
             has
             three. */
        };
      </pre>
    </section>
    <section>
      <h2>Dictionaries</h2>
      <p>
        Basic dictionary.
      </p>
      <pre id='dict-basic' class='idl'>
        dictionary SuperStar {};
      </pre>
      <p>
        Inheriting dictionary.
      </p>
      <pre id='dict-inherit' class='idl'>
        dictionary SuperStar : HyperStar {};
      </pre>
      <p>
        Data in  dictionary.
      </p>
      <pre id='dict-fields' class='idl'>
        dictionary SuperStar {
          // 1
          DOMString value;
          // 2
          DOMString? nullable;
          // 3
          [Something]float ext;
          // 4
          unsigned long long longLong;

          // 5
          boolean test = true;
          // 6
          byte little = 2;
          // 7
          byte big = Infinity;
          // 8
          byte cheese = NaN;
          // 9
          DOMString blah = "blah blah";
        };
      </pre>
      <pre id='dict-required-fields' class='idl'>
        dictionary SuperStar {
          required DOMString value;
          DOMString optValue;
        };
      </pre>
      <pre id='dict-doc' class='idl'>
        dictionary DictDocTest {
          DOMString dictDocField;
          DOMString? otherField;
          long undocField;
        };
      </pre>
      <p id='dict-doc-p'><dfn>DictDocTest</dfn> contains <dfn data-dfn-for="DictDocTest">dictDocField</dfn> and <dfn data-dfn-for="DictDocTest">otherField</dfn></p>
    </section>
    <section id="enumerations">
      <h2>Enumerations</h2>
      <p>
        Basic enumeration.
      </p>
      <pre id='enum-basic' class='idl'>
        enum EnumBasic {
          // 1
          "one",
          // 2
          "two"
          // 3
        , "three",

          // 4
          "white space"
        };
      </pre>
      <p id="enum-basic-doc"><dfn>EnumBasic</dfn></p>
      <p data-dfn-for="EnumBasic"><dfn>one</dfn> is first.</p>
      <p data-link-for="EnumBasic"><a>one</a> is referenced with a <code>[link-for]</code> attribute.</p>
      <p id="enum-ref-without-link-for"><a>EnumBasic.one</a> may also be referenced with fully-qualified name.</p>
      <section id="enum-empty-sec" data-dfn-for="EmptyEnum">
        <pre class="idl no-link-warnings">
        enum EmptyEnum {
          "",
          "not empty"
        };
        </pre>
        <p><dfn>EmptyEnum</dfn></p>
        <p><dfn>""</dfn></p>...
        <p><dfn>not empty</dfn>...</p>
      </section>
    </section>
    <section>
      <h2>Callbacks</h2>
      <p>
        Basic callback.
      </p>
      <pre id='cb-basic' class='idl'>
        callback SuperStar = void();
      </pre>
      <p>
        Less basic callback.
      </p>
      <pre id='cb-less-basic' class='idl'>
        callback CbLessBasic = unsigned long long?(optional any value);
      </pre>
      <p>
        Callback with multiple arguments.
      </p>
      <pre id='cb-mult-args' class='idl'>
        callback SortCallback = void (any a, any b);
      </pre>
      <p id="cb-less-basic-doc"><dfn>CbLessBasic</dfn></p>
      <!--
        XXX extattr?
       -->
    </section>
    <section>
      <h2>Typedefs</h2>
      <p>
        Basic typedef.
      </p>
      <pre id='td-basic' class='idl'>
        typedef DOMString string;
      </pre>
      <p>
        Less basic typedef.
      </p>
      <pre id='td-less-basic' class='idl'>
        typedef unsigned long long? tdLessBasic;
      </pre>
      <p id='td-less-basic-doc'><dfn>tdLessBasic</dfn></p>
    </section>
    <section>
      <h2>Implements</h2>
      <p>
        Basic implements.
      </p>
      <pre id='impl-basic' class='idl'>
        Window implements Breakable;
      </pre>
      <p>
        Less basic implements.
      </p>
      <pre id='impl-less-basic' class='idl'>
        [Something]Window implements Breakable;
      </pre>
    </section>
    <section>
      <h2>Includes</h2>
      <p>
        Basic includes.
      </p>
      <pre id='incl-basic' class='idl'>
        Window includes Breakable;
      </pre>
      <p>
        Less basic includes.
      </p>
      <pre id='incl-less-basic' class='idl'>
        [Something]Window includes Breakable;
      </pre>
    </section>
    <section id="documentation">
      <h2>Documentation</h2>
      <pre id='doc-iface' class='idl'>
        interface Documented {
          attribute DOMString docString;
          attribute DOMString notDefined;
          attribute DOMString definedElsewhere;
        };
      </pre>
      <p class='note' data-dfn-for="Documented">
        <dfn>docString</dfn> is defined in a note.
      </p>
      <p data-link-for="Documented">
        Testing <code>[link-for]</code>:
        <dfn>Some generic term</dfn> isn't IDL.
        <a>Some generic term</a> also isn't part of <a>Documented</a>.
        <a>docString</a> is.
        <a>notDefined</a> is too, but isn't defined elsewhere.
      </p>
      <p>
        <dfn>Documented.definedElsewhere</dfn> is defined by writing its fully-qualified name.
        <a>Documented.docString</a> is linked by writing its fully-qualified name.
      </p>
      <p id="without-link-for">
        We had a bug where <a>Documented</a> got a [dfn-for] attribute,
        which broke links to it without [link-for].
      </p>
    </section>
    <section>
      <pre id='retain-css-classes' class='idl a b c overlarge'>
        interface NotTested {};
      </pre>      
    </section>
    <section>
      <h2>Autolink to WebIDL spec for toJSON</h2>
      <pre id="AutoLinkToIDLSpec" class="idl">
        interface AutoLinkToIDLSpec {
          [Default] object toJSON();
        };
      </pre>
    </section>
    <section id="DefinedToJson" data-dfn-for="DefinedToJson" data-link-for="DefinedToJson">
      <h2>We can define our own toJSON()</h2>
      <pre class="idl">
        interface DefinedToJson {
          readonly attribute DOMString country;
          [Default] object toJSON();
          void toWhatever(); 
        };
      </pre>
      <section>
      <h2><dfn>toJSON()</dfn> method</h2>
      <p>When <a>toJSON()</a> is called, run [[!WEBIDL]]'s <a data-cite="WEBIDL#default-tojson-operation">default toJSON operation</a>.</p>
      </section>
    </section> 
  </body>
</html>