<!--
try {
  var source = new EventSource("../resources/message.py")
  source.onmessage = function(e) {
    postMessage([true, e.data])
    this.close()
  }
} catch(e) {
  postMessage([false, String(e)])
}
/*-->
<!DOCTYPE html>
<html>
  <head>
    <title>dedicated worker - EventSource: onmessage</title>
    <script src="/resources/testharness.js"></script>
    <script src="/resources/testharnessreport.js"></script>
  </head>
  <body>
    <div id="log"></div>
    <script>
      var test = async_test()
      test.step(function() {
        var worker = new Worker('#')
        worker.onmessage = function(e) {
          test.step(function() {
            assert_true(e.data[0], e.data[1])
            assert_equals(e.data[1], "data", 'e.data')
          })
          test.done()
        }
      })
    </script>
  </body>
</html>
<!--*/ //-->
