RubyGems - closure - Versions diffs - 1.1.692 - Mend

closure 1.1.692

Files changed (1494) hide show

data/closure-library/closure/goog/testing/net/xhrio_test.html ADDED Viewed

@@ -0,0 +1,321 @@
+<!DOCTYPE html>
+<html>
+<!--
+Copyright 2008 The Closure Library Authors. All Rights Reserved.
+Use of this source code is governed by the Apache License, Version 2.0.
+See the COPYING file for details.
+-->
+<head>
+<meta http-equiv="X-UA-Compatible" content="IE=edge">
+<title>Closure Unit Tests - goog.testing.net.XhrIo</title>
+<script src="../../base.js"></script>
+<script>
+  goog.require('goog.dom.xml');
+  goog.require('goog.events');
+  goog.require('goog.events.Event');
+  goog.require('goog.net.EventType');
+  goog.require('goog.testing.asserts');
+  goog.require('goog.testing.jsunit');
+  goog.require('goog.testing.net.XhrIo');
+  goog.require('goog.testing.mockmatchers.InstanceOf');
+  goog.require('goog.testing.MockControl');
+</script>
+</head>
+<body>
+<script>
+var mockControl;
+function setUp() {
+  mockControl = new goog.testing.MockControl();
+}
+function testStaticSend() {
+  sendInstances = goog.testing.net.XhrIo.getSendInstances();
+  goog.testing.net.XhrIo.send('url');
+  assertEquals('sendInstances_ after send',
+               1, sendInstances.length);
+  xhr = sendInstances[sendInstances.length - 1];
+  assertTrue('isActive after request', xhr.isActive());
+  assertEquals('readyState after request',
+               goog.net.XmlHttp.ReadyState.LOADING,
+               xhr.getReadyState());
+  xhr.simulateResponse(200, '');
+  assertFalse('isActive after response', xhr.isActive());
+  assertEquals('readyState after response',
+               goog.net.XmlHttp.ReadyState.COMPLETE,
+               xhr.getReadyState());
+  xhr.simulateReady();
+  assertEquals('sendInstances_ after READY',
+               0, sendInstances.length);
+}
+function testMultipleSend() {
+  var xhr = new goog.testing.net.XhrIo();
+  assertFalse('isActive before first request', xhr.isActive());
+  assertEquals('readyState before first request',
+               goog.net.XmlHttp.ReadyState.UNINITIALIZED,
+               xhr.getReadyState());
+  xhr.send('url');
+  assertTrue('isActive after first request', xhr.isActive());
+  assertEquals('readyState after first request',
+               goog.net.XmlHttp.ReadyState.LOADING,
+               xhr.getReadyState());
+  xhr.simulateResponse(200, '');
+  assertFalse('isActive after first response', xhr.isActive());
+  assertEquals('readyState after first response',
+               goog.net.XmlHttp.ReadyState.COMPLETE,
+               xhr.getReadyState());
+  xhr.send('url');
+  assertTrue('isActive after second request', xhr.isActive());
+  assertEquals('readyState after second request',
+               goog.net.XmlHttp.ReadyState.LOADING,
+               xhr.getReadyState());
+}
+function testGetLastUri() {
+  var xhr = new goog.testing.net.XhrIo();
+  assertEquals('nothing sent yet, empty URI', '', xhr.getLastUri());
+  var requestUrl = 'http://www.example.com/';
+  xhr.send(requestUrl);
+  assertEquals('message sent, URI saved', requestUrl, xhr.getLastUri());
+}
+function testGetResponseText() {
+  // Text response came.
+  var called = false;
+  var xhr = new goog.testing.net.XhrIo();
+  goog.events.listen(xhr, goog.net.EventType.SUCCESS, function(e) {
+    called = true;
+    assertEquals('text', e.target.getResponseText());
+  });
+  xhr.simulateResponse(200, 'text');
+  assertTrue(called);
+  // XML response came.
+  var called = false;
+  var xhr = new goog.testing.net.XhrIo();
+  var xml = goog.dom.xml.createDocument();
+  xml.appendChild(xml.createElement('root'));
+  goog.events.listen(xhr, goog.net.EventType.SUCCESS, function(e) {
+    called = true;
+    var text = e.target.getResponseText();
+    assertTrue(/<root ?\/>/.test(text));
+  });
+  xhr.simulateResponse(200, xml);
+  assertTrue(called);
+}
+function testGetResponseJson() {
+  // Valid JSON response came.
+  var called = false;
+  var xhr = new goog.testing.net.XhrIo();
+  goog.events.listen(xhr, goog.net.EventType.SUCCESS, function(e) {
+    called = true;
+    assertArrayEquals([0, 1], e.target.getResponseJson());
+  });
+  xhr.simulateResponse(200, '[0, 1]');
+  assertTrue(called);
+  // Valid JSON response with XSSI prefix encoded came.
+  var called = false;
+  var xhr = new goog.testing.net.XhrIo();
+  goog.events.listen(xhr, goog.net.EventType.SUCCESS, function(e) {
+    called = true;
+    assertArrayEquals([0, 1], e.target.getResponseJson(')]}\', \n'));
+  });
+  xhr.simulateResponse(200, ')]}\', \n[0, 1]');
+  assertTrue(called);
+  // Invalid JSON response came.
+  var called = false;
+  var xhr = new goog.testing.net.XhrIo();
+  goog.events.listen(xhr, goog.net.EventType.SUCCESS, function(e) {
+    called = true;
+    assertThrows(e.target.getResponseJson);
+  });
+  xhr.simulateResponse(200, '[0, 1');
+  assertTrue(called);
+  // XML response came.
+  var called = false;
+  var xhr = new goog.testing.net.XhrIo();
+  var xml = goog.dom.xml.createDocument();
+  xml.appendChild(xml.createElement('root'));
+  goog.events.listen(xhr, goog.net.EventType.SUCCESS, function(e) {
+    called = true;
+    assertThrows(e.target.getResponseJson);
+  });
+  xhr.simulateResponse(200, xml);
+  assertTrue(called);
+}
+function testGetResponseXml() {
+  // Text response came.
+  var called = false;
+  var xhr = new goog.testing.net.XhrIo();
+  goog.events.listen(xhr, goog.net.EventType.SUCCESS, function(e) {
+    called = true;
+    assertNull(e.target.getResponseXml());
+  });
+  xhr.simulateResponse(200, 'text');
+  assertTrue(called);
+  // XML response came.
+  var called = false;
+  var xhr = new goog.testing.net.XhrIo();
+  var xml = goog.dom.xml.createDocument();
+  xml.appendChild(xml.createElement('root'));
+  goog.events.listen(xhr, goog.net.EventType.SUCCESS, function(e) {
+    called = true;
+    assertEquals(xml, e.target.getResponseXml());
+  });
+  xhr.simulateResponse(200, xml);
+  assertTrue(called);
+}
+function testGetResponseHeaders_noHeadersPresent() {
+  var xhr = new goog.testing.net.XhrIo();
+  var mockListener = mockControl.createFunctionMock();
+  mockListener(new goog.testing.mockmatchers.InstanceOf(goog.events.Event))
+      .$does(function(e) {
+    assertTrue(e.type == goog.net.EventType.SUCCESS);
+    assertUndefined(e.target.getResponseHeader('XHR'));
+  });
+  mockControl.$replayAll();
+  goog.events.listen(xhr, goog.net.EventType.SUCCESS, mockListener);
+  xhr.simulateResponse(200, '');
+  mockControl.$verifyAll();
+  mockControl.$resetAll();
+}
+function testGetResponseHeaders_headersPresent() {
+  var xhr = new goog.testing.net.XhrIo();
+  var mockListener = mockControl.createFunctionMock();
+  mockListener(new goog.testing.mockmatchers.InstanceOf(goog.events.Event))
+      .$does(function(e) {
+    assertTrue(e.type == goog.net.EventType.SUCCESS);
+    assertUndefined(e.target.getResponseHeader('XHR'));
+    assertEquals(e.target.getResponseHeader('Pragma'), 'no-cache');
+  });
+  mockControl.$replayAll();
+  goog.events.listen(xhr, goog.net.EventType.SUCCESS, mockListener);
+  xhr.simulateResponse(200, '', {'Pragma': 'no-cache'});
+  mockControl.$verifyAll();
+  mockControl.$resetAll();
+}
+function testAbort_WhenNoPendingSentRequests() {
+  var xhr = new goog.testing.net.XhrIo();
+  var eventListener = mockControl.createFunctionMock();
+  mockControl.$replayAll();
+  goog.events.listen(xhr, goog.net.EventType.COMPLETE, eventListener);
+  goog.events.listen(xhr, goog.net.EventType.SUCCESS, eventListener);
+  goog.events.listen(xhr, goog.net.EventType.ABORT, eventListener);
+  goog.events.listen(xhr, goog.net.EventType.ERROR, eventListener);
+  goog.events.listen(xhr, goog.net.EventType.READY, eventListener);
+  xhr.abort();
+  mockControl.$verifyAll();
+  mockControl.$resetAll();
+}
+function testAbort_PendingSentRequest() {
+  var xhr = new goog.testing.net.XhrIo();
+  var mockListener = mockControl.createFunctionMock();
+  mockListener(new goog.testing.mockmatchers.InstanceOf(goog.events.Event))
+  .$does(function(e) {
+    assertTrue(e.type == goog.net.EventType.COMPLETE);
+    assertObjectEquals(e.target, xhr);
+    assertEquals(e.target.getLastErrorCode(), goog.net.ErrorCode.ABORT);
+    assertTrue(e.target.isActive());
+  });
+  mockListener(new goog.testing.mockmatchers.InstanceOf(goog.events.Event))
+  .$does(function(e) {
+    assertTrue(e.type == goog.net.EventType.ABORT);
+    assertObjectEquals(e.target, xhr);
+    assertTrue(e.target.isActive());
+  });
+  mockListener(new goog.testing.mockmatchers.InstanceOf(goog.events.Event))
+  .$does(function(e) {
+    assertTrue(e.type == goog.net.EventType.READY);
+    assertObjectEquals(e.target, xhr);
+    assertFalse(e.target.isActive());
+  });
+  mockControl.$replayAll();
+  goog.events.listen(xhr, goog.net.EventType.COMPLETE, mockListener);
+  goog.events.listen(xhr, goog.net.EventType.SUCCESS, mockListener);
+  goog.events.listen(xhr, goog.net.EventType.ABORT, mockListener);
+  goog.events.listen(xhr, goog.net.EventType.ERROR, mockListener);
+  goog.events.listen(xhr, goog.net.EventType.READY, mockListener);
+  xhr.send('dummyurl');
+  xhr.abort();
+  mockControl.$verifyAll();
+  mockControl.$resetAll();
+}
+function testEvents_Success() {
+  var xhr = new goog.testing.net.XhrIo();
+  var mockListener = mockControl.createFunctionMock();
+  var readyState = goog.net.XmlHttp.ReadyState.UNINITIALIZED;
+  function readyStateListener(e) {
+    assertEquals(e.type, goog.net.EventType.READY_STATE_CHANGE);
+    assertObjectEquals(e.target, xhr);
+    readyState++;
+    assertEquals(e.target.getReadyState(), readyState);
+    assertTrue(e.target.isActive());
+  }
+  mockListener(new goog.testing.mockmatchers.InstanceOf(goog.events.Event))
+  .$does(function(e) {
+    assertEquals(e.type, goog.net.EventType.COMPLETE);
+    assertObjectEquals(e.target, xhr);
+    assertEquals(e.target.getLastErrorCode(), goog.net.ErrorCode.NO_ERROR);
+    assertTrue(e.target.isActive());
+  });
+  mockListener(new goog.testing.mockmatchers.InstanceOf(goog.events.Event))
+  .$does(function(e) {
+    assertEquals(e.type, goog.net.EventType.SUCCESS);
+    assertObjectEquals(e.target, xhr);
+    assertTrue(e.target.isActive());
+  });
+  mockListener(new goog.testing.mockmatchers.InstanceOf(goog.events.Event))
+  .$does(function(e) {
+    assertEquals(e.type, goog.net.EventType.READY);
+    assertObjectEquals(e.target, xhr);
+    assertFalse(e.target.isActive());
+  });
+  mockControl.$replayAll();
+  goog.events.listen(xhr, goog.net.EventType.READY_STATE_CHANGE,
+      readyStateListener);
+  goog.events.listen(xhr, goog.net.EventType.COMPLETE, mockListener);
+  goog.events.listen(xhr, goog.net.EventType.SUCCESS, mockListener);
+  goog.events.listen(xhr, goog.net.EventType.ABORT, mockListener);
+  goog.events.listen(xhr, goog.net.EventType.ERROR, mockListener);
+  goog.events.listen(xhr, goog.net.EventType.READY, mockListener);
+  xhr.send('dummyurl');
+  xhr.simulateResponse(200, null);
+  mockControl.$verifyAll();
+  mockControl.$resetAll();
+}
+</script>
+</body>
+</html>

data/closure-library/closure/goog/testing/objectpropertystring.js ADDED Viewed

@@ -0,0 +1,67 @@
+// Copyright 2009 The Closure Library Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS-IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+/**
+ * @fileoverview Helper for passing property names as string literals in
+ * compiled test code.
+ *
+ */
+goog.provide('goog.testing.ObjectPropertyString');
+/**
+ * Object to pass a property name as a string literal and its containing object
+ * when the JSCompiler is rewriting these names. This should only be used in
+ * test code.
+ *
+ * @param {Object} object The containing object.
+ * @param {Object|string} propertyString Property name as a string literal.
+ * @constructor
+ */
+goog.testing.ObjectPropertyString = function(object, propertyString) {
+  this.object_ = object;
+  this.propertyString_ = /** @type {string} */ (propertyString);
+};
+/**
+ * @type {Object}
+ * @private
+ */
+goog.testing.ObjectPropertyString.prototype.object_;
+/**
+ * @type {string}
+ * @private
+ */
+goog.testing.ObjectPropertyString.prototype.propertyString_;
+/**
+ * @return {Object} The object.
+ */
+goog.testing.ObjectPropertyString.prototype.getObject = function() {
+  return this.object_;
+};
+/**
+ * @return {string} The property string.
+ */
+goog.testing.ObjectPropertyString.prototype.getPropertyString = function() {
+  return this.propertyString_;
+};

data/closure-library/closure/goog/testing/performancetable.css ADDED Viewed

@@ -0,0 +1,46 @@
+/*
+ * Copyright 2009 The Closure Library Authors. All Rights Reserved.
+ *
+ * Use of this source code is governed by the Apache License, Version 2.0.
+ * See the COPYING file for details.
+ */
+/* Author: attila@google.com (Attila Bodis) */
+/* Author: nicksantos@google.com (Nick Santos) */
+table.test-results {
+  font: 12px "Courier New", Courier, monospace;
+}
+table.test-results thead th {
+  padding: 2px;
+  color: #fff;
+  background-color: #369;
+  text-align: center;
+}
+table.test-results tbody td {
+  padding: 2px;
+  color: #333;
+  background-color: #ffc;
+  text-align: right;
+}
+table.test-results tbody td.test-description {
+  text-align: left;
+}
+table.test-results tbody td.test-average {
+  color: #000;
+  font-weight: bold;
+}
+table.test-results tbody tr.test-suspicious td.test-standard-deviation {
+  color: #800;
+}
+table.test-results tbody td.test-error {
+  color: #800;
+  font-weight: bold;
+  text-align: center;
+}

data/closure-library/closure/goog/testing/performancetable.js ADDED Viewed

@@ -0,0 +1,162 @@
+// Copyright 2009 The Closure Library Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS-IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+/**
+ * @fileoverview A table for showing the results of performance testing.
+ *
+ * {@see goog.testing.benchmark} for an easy way to use this functionality.
+ *
+ */
+goog.provide('goog.testing.PerformanceTable');
+goog.require('goog.dom');
+goog.require('goog.testing.PerformanceTimer');
+/**
+ * A UI widget that runs performance tests and displays the results.
+ * @param {Element} root The element where the table should be attached.
+ * @param {goog.testing.PerformanceTimer=} opt_timer A timer to use for
+ *     executing functions and profiling them.
+ * @param {number=} opt_precision Number of digits of precision to include in
+ *     results.  Defaults to 0.
+ * @constructor
+ */
+goog.testing.PerformanceTable = function(root, opt_timer, opt_precision) {
+  /**
+   * Where the table should be attached.
+   * @type {Element}
+   * @private
+   */
+  this.root_ = root;
+  /**
+   * Number of digits of precision to include in results.
+   * Defaults to 0.
+   * @type {number}
+   * @private
+   */
+  this.precision_ = opt_precision || 0;
+  var timer = opt_timer;
+  if (!timer) {
+    timer = new goog.testing.PerformanceTimer();
+    timer.setNumSamples(5);
+    timer.setDiscardOutliers(true);
+  }
+  /**
+   * A timer for running the tests.
+   * @type {goog.testing.PerformanceTimer}
+   * @private
+   */
+  this.timer_ = timer;
+  this.initRoot_();
+};
+/**
+ * @return {goog.testing.PerformanceTimer} The timer being used.
+ */
+goog.testing.PerformanceTable.prototype.getTimer = function() {
+  return this.timer_;
+};
+/**
+ * Render the initial table.
+ * @private
+ */
+goog.testing.PerformanceTable.prototype.initRoot_ = function() {
+  this.root_.innerHTML =
+      '<table class="test-results" cellspacing="1">' +
+      '  <thead>' +
+      '    <tr>' +
+      '      <th rowspan="2">Test Description</th>' +
+      '      <th rowspan="2">Runs</th>' +
+      '      <th colspan="4">Results (ms)</th>' +
+      '    </tr>' +
+      '    <tr>' +
+      '      <th>Average</th>' +
+      '      <th>Std Dev</th>' +
+      '      <th>Minimum</th>' +
+      '      <th>Maximum</th>' +
+      '    </tr>' +
+      '  </thead>' +
+      '  <tbody>' +
+      '  </tbody>' +
+      '</table>';
+};
+/**
+ * @return {Element} The body of the table.
+ * @private
+ */
+goog.testing.PerformanceTable.prototype.getTableBody_ = function() {
+  return this.root_.getElementsByTagName(goog.dom.TagName.TBODY)[0];
+};
+/**
+ * Round to the specified precision.
+ * @param {number} num The number to round.
+ * @return {string} The rounded number, as a string.
+ * @private
+ */
+goog.testing.PerformanceTable.prototype.round_ = function(num) {
+  var factor = Math.pow(10, this.precision_);
+  return String(Math.round(num * factor) / factor);
+};
+/**
+ * Run the given function with the performance timer, and show the results.
+ * @param {Function} fn The function to run.
+ * @param {string=} opt_desc A description to associate with this run.
+ */
+goog.testing.PerformanceTable.prototype.run = function(fn, opt_desc) {
+  var results = this.timer_.run(fn);
+  var average = results['average'];
+  var standardDeviation = results['standardDeviation'];
+  var isSuspicious = average < 0 || standardDeviation > average * .5;
+  var resultsRow = goog.dom.createDom('tr', null,
+      goog.dom.createDom('td', 'test-description',
+          opt_desc || 'No description'),
+      goog.dom.createDom('td', 'test-count', String(results['count'])),
+      goog.dom.createDom('td', 'test-average', this.round_(average)),
+      goog.dom.createDom('td', 'test-standard-deviation',
+          this.round_(standardDeviation)),
+      goog.dom.createDom('td', 'test-minimum', String(results['minimum'])),
+      goog.dom.createDom('td', 'test-maximum', String(results['maximum'])));
+  if (isSuspicious) {
+    resultsRow.className = 'test-suspicious';
+  }
+  this.getTableBody_().appendChild(resultsRow);
+};
+/**
+ * Report an error in the table.
+ * @param {*} reason The reason for the error.
+ */
+goog.testing.PerformanceTable.prototype.reportError = function(reason) {
+  this.getTableBody_().appendChild(
+      goog.dom.createDom('tr', null,
+          goog.dom.createDom('td', {'class': 'test-error', 'colSpan': 5},
+              String(reason))));
+};