RubyGems - k4compiler - Versions diffs - 0.0.1 - Mend

k4compiler 0.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (1898) hide show

data/third_party/closure-library/closure/goog/testing/performancetimer_test.html ADDED Viewed

@@ -0,0 +1,201 @@
+<!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.
+-->
+<!--
+Author:  attila@google.com (Attila Bodis)
+-->
+<head>
+<meta http-equiv="X-UA-Compatible" content="IE=edge">
+  <title>Closure Unit Tests - goog.testing.PerformanceTimer</title>
+  <script src="../base.js"></script>
+  <script>
+    goog.require('goog.async.Deferred');
+    goog.require('goog.dom');
+    goog.require('goog.math');
+    goog.require('goog.testing.MockClock');
+    goog.require('goog.testing.PerformanceTimer');
+    goog.require('goog.testing.jsunit');
+  </script>
+</head>
+<body>
+  <div id="sandbox"></div>
+  <script>
+    var mockClock;
+    var sandbox = document.getElementById('sandbox');
+    var timer;
+    function setUp() {
+      mockClock = new goog.testing.MockClock(true);
+      timer = new goog.testing.PerformanceTimer();
+    }
+    function tearDown() {
+      mockClock.dispose();
+      timer = null;
+      goog.dom.removeChildren(sandbox);
+    }
+    function testConstructor() {
+      assertTrue('Timer must be an instance of goog.testing.PerformanceTimer',
+          timer instanceof goog.testing.PerformanceTimer);
+      assertEquals('Timer must collect the default number of samples', 10,
+          timer.getNumSamples());
+      assertEquals('Timer must have the default timeout interval', 5000,
+          timer.getTimeoutInterval());
+    }
+    function testRun_noSetUpOrTearDown() {
+      runAndAssert(false, false, false);
+    }
+    function testRun_withSetup() {
+      runAndAssert(true, false, false);
+    }
+    function testRun_withTearDown() {
+      runAndAssert(false, true, false);
+    }
+    function testRun_withSetUpAndTearDown() {
+      runAndAssert(true, true, false);
+    }
+    function testRunAsync_noSetUpOrTearDown() {
+      runAndAssert(false, false, true);
+    }
+    function testRunAsync_withSetup() {
+      runAndAssert(true, false, true);
+    }
+    function testRunAsync_withTearDown() {
+      runAndAssert(false, true, true);
+    }
+    function testRunAsync_withSetUpAndTearDown() {
+      runAndAssert(true, true, true);
+    }
+    function runAndAssert(useSetUp, useTearDown, runAsync) {
+      var fakeExecutionTime = [100, 95, 98, 104, 130, 101, 96, 98, 90, 103]
+      var count = 0;
+      var testFunction = function() {
+        mockClock.tick(fakeExecutionTime[count++]);
+        if (runAsync) {
+          var deferred = new goog.async.Deferred();
+          deferred.callback();
+          return deferred;
+        }
+      };
+      var setUpCount = 0;
+      var setUpFunction = function() {
+        // Should have no effect on total time.
+        mockClock.tick(7);
+        setUpCount++;
+        if (runAsync) {
+          var deferred = new goog.async.Deferred();
+          deferred.callback();
+          return deferred;
+        }
+      };
+      var tearDownCount = 0;
+      var tearDownFunction = function() {
+        // Should have no effect on total time.
+        mockClock.tick(11);
+        tearDownCount++;
+        if (runAsync) {
+          var deferred = new goog.async.Deferred();
+          deferred.callback();
+          return deferred;
+        }
+      };
+      // Fast test function should complete successfully in under 5 seconds...
+      var task = new goog.testing.PerformanceTimer.Task(testFunction);
+      if (useSetUp) {
+        task.withSetUp(setUpFunction);
+      }
+      if (useTearDown) {
+        task.withTearDown(tearDownFunction);
+      }
+      if (runAsync) {
+        var assertsRan = false;
+        var deferred = timer.runAsyncTask(task);
+        deferred.addCallback(
+            function(results) {
+              assertsRan = assertResults(results, useSetUp, useTearDown,
+                  setUpCount, tearDownCount, fakeExecutionTime);
+            });
+        assertTrue(assertsRan);
+      } else {
+        var results = timer.runTask(task);
+        assertResults(results, useSetUp, useTearDown, setUpCount, tearDownCount,
+            fakeExecutionTime);
+      }
+    }
+    function assertResults(results, useSetUp, useTearDown, setUpCount,
+        tearDownCount, fakeExecutionTime) {
+      assertNotNull('Results must be available.', results);
+      assertEquals('Average is wrong.',
+          goog.math.average.apply(null, fakeExecutionTime), results['average']);
+      assertEquals('Standard deviation is wrong.',
+          goog.math.standardDeviation.apply(null, fakeExecutionTime),
+          results['standardDeviation']);
+      assertEquals('Count must be as expected.', 10, results['count']);
+      assertEquals('Maximum is wrong.', 130, results['maximum']);
+      assertEquals('Mimimum is wrong.', 90, results['minimum']);
+      assertEquals('Total must be a nonnegative number.',
+          goog.math.sum.apply(null, fakeExecutionTime), results['total']);
+      assertEquals('Set up count must be as expected.',
+          useSetUp ? 10 : 0, setUpCount);
+      assertEquals('Tear down count must be as expected.',
+          useTearDown ? 10 : 0, tearDownCount);
+      return true;
+    }
+    function testTimeout() {
+      var count = 0;
+      var testFunction = function() {
+        mockClock.tick(100);
+        ++count;
+      };
+      timer.setNumSamples(200);
+      timer.setTimeoutInterval(2500);
+      var results = timer.run(testFunction);
+      assertNotNull('Results must be available', results);
+      assertEquals('Count is wrong', count, results['count']);
+      assertTrue('Count must less than expected',
+          results['count'] < timer.getNumSamples());
+    }
+    function testCreateResults() {
+      var samples = [53, 0, 103];
+      var expectedResults = {
+        'average': 52,
+        'count': 3,
+        'maximum': 103,
+        'minimum': 0,
+        'standardDeviation': goog.math.standardDeviation.apply(null, samples),
+        'total': 156
+      };
+      assertObjectEquals(
+          expectedResults,
+          goog.testing.PerformanceTimer.createResults(samples));
+    }
+  </script>
+</body>
+</html>

data/third_party/closure-library/closure/goog/testing/propertyreplacer.js ADDED Viewed

@@ -0,0 +1,243 @@
+// Copyright 2008 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 class for creating stubs for testing.
+ *
+ */
+goog.provide('goog.testing.PropertyReplacer');
+goog.require('goog.userAgent');
+/**
+ * Helper class for stubbing out variables and object properties for unit tests.
+ * This class can change the value of some variables before running the test
+ * cases, and to reset them in the tearDown phase.
+ * See googletest.StubOutForTesting as an analogy in Python:
+ * http://protobuf.googlecode.com/svn/trunk/python/stubout.py
+ *
+ * Example usage:
+ * <pre>var stubs = new goog.testing.PropertyReplacer();
+ *
+ * function setUp() {
+ *   // Mock functions used in all test cases.
+ *   stubs.set(Math, 'random', function() {
+ *     return 4;  // Chosen by fair dice roll. Guaranteed to be random.
+ *   });
+ * }
+ *
+ * function tearDown() {
+ *   stubs.reset();
+ * }
+ *
+ * function testThreeDice() {
+ *   // Mock a constant used only in this test case.
+ *   stubs.set(goog.global, 'DICE_COUNT', 3);
+ *   assertEquals(12, rollAllDice());
+ * }</pre>
+ *
+ * Constraints on altered objects:
+ * <ul>
+ *   <li>DOM subclasses aren't supported.
+ *   <li>The value of the objects' constructor property must either be equal to
+ *       the real constructor or kept untouched.
+ * </ul>
+ *
+ * @constructor
+ */
+goog.testing.PropertyReplacer = function() {
+  /**
+   * Stores the values changed by the set() method in chronological order.
+   * Its items are objects with 3 fields: 'object', 'key', 'value'. The
+   * original value for the given key in the given object is stored under the
+   * 'value' key.
+   * @type {Array.<Object>}
+   * @private
+   */
+  this.original_ = [];
+};
+/**
+ * Indicates that a key didn't exist before having been set by the set() method.
+ * @type {Object}
+ * @private
+ */
+goog.testing.PropertyReplacer.NO_SUCH_KEY_ = {};
+/**
+ * Tells if the given key exists in the object. Ignores inherited fields.
+ * @param {Object|Function} obj The JavaScript or native object or function
+ *     whose key is to be checked.
+ * @param {string} key The key to check.
+ * @return {boolean} Whether the object has the key as own key.
+ * @private
+ */
+goog.testing.PropertyReplacer.hasKey_ = function(obj, key) {
+  if (!(key in obj)) {
+    return false;
+  }
+  // hasOwnProperty is only reliable with JavaScript objects. It returns false
+  // for built-in DOM attributes.
+  if (Object.prototype.hasOwnProperty.call(obj, key)) {
+    return true;
+  }
+  // In all browsers except Opera obj.constructor never equals to Object if
+  // obj is an instance of a native class. In Opera we have to fall back on
+  // examining obj.toString().
+  if (obj.constructor == Object &&
+      (!goog.userAgent.OPERA ||
+          Object.prototype.toString.call(obj) == '[object Object]')) {
+    return false;
+  }
+  try {
+    // Firefox hack to consider "className" part of the HTML elements or
+    // "body" part of document. Although they are defined in the prototype of
+    // HTMLElement or Document, accessing them this way throws an exception.
+    // <pre>
+    //   var dummy = document.body.constructor.prototype.className
+    //   [Exception... "Cannot modify properties of a WrappedNative"]
+    // </pre>
+    var dummy = obj.constructor.prototype[key];
+  } catch (e) {
+    return true;
+  }
+  return !(key in obj.constructor.prototype);
+};
+/**
+ * Deletes a key from an object. Sets it to undefined or empty string if the
+ * delete failed.
+ * @param {Object|Function} obj The object or function to delete a key from.
+ * @param {string} key The key to delete.
+ * @private
+ */
+goog.testing.PropertyReplacer.deleteKey_ = function(obj, key) {
+  try {
+    delete obj[key];
+    // Delete has no effect for built-in properties of DOM nodes in FF.
+    if (!goog.testing.PropertyReplacer.hasKey_(obj, key)) {
+      return;
+    }
+  } catch (e) {
+    // IE throws TypeError when trying to delete properties of native objects
+    // (e.g. DOM nodes or window), even if they have been added by JavaScript.
+  }
+  obj[key] = undefined;
+  if (obj[key] == 'undefined') {
+    // Some properties such as className in IE are always evaluated as string
+    // so undefined will become 'undefined'.
+    obj[key] = '';
+  }
+};
+/**
+ * Adds or changes a value in an object while saving its original state.
+ * @param {Object|Function} obj The JavaScript or native object or function to
+ *     alter. See the constraints in the class description.
+ * @param {string} key The key to change the value for.
+ * @param {*} value The new value to set.
+ */
+goog.testing.PropertyReplacer.prototype.set = function(obj, key, value) {
+  var origValue = goog.testing.PropertyReplacer.hasKey_(obj, key) ? obj[key] :
+                  goog.testing.PropertyReplacer.NO_SUCH_KEY_;
+  this.original_.push({object: obj, key: key, value: origValue});
+  obj[key] = value;
+};
+/**
+ * Changes an existing value in an object to another one of the same type while
+ * saving its original state. The advantage of {@code replace} over {@link #set}
+ * is that {@code replace} protects against typos and erroneously passing tests
+ * after some members have been renamed during a refactoring.
+ * @param {Object|Function} obj The JavaScript or native object or function to
+ *     alter. See the constraints in the class description.
+ * @param {string} key The key to change the value for. It has to be present
+ *     either in {@code obj} or in its prototype chain.
+ * @param {*} value The new value to set. It has to have the same type as the
+ *     original value. The types are compared with {@link goog.typeOf}.
+ * @throws {Error} In case of missing key or type mismatch.
+ */
+goog.testing.PropertyReplacer.prototype.replace = function(obj, key, value) {
+  if (!(key in obj)) {
+    throw Error('Cannot replace missing property "' + key + '" in ' + obj);
+  }
+  if (goog.typeOf(obj[key]) != goog.typeOf(value)) {
+    throw Error('Cannot replace property "' + key + '" in ' + obj +
+        ' with a value of different type');
+  }
+  this.set(obj, key, value);
+};
+/**
+ * Builds an object structure for the provided namespace path.  Doesn't
+ * overwrite those prefixes of the path that are already objects or functions.
+ * @param {string} path The path to create or alter, e.g. 'goog.ui.Menu'.
+ * @param {*} value The value to set.
+ */
+goog.testing.PropertyReplacer.prototype.setPath = function(path, value) {
+  var parts = path.split('.');
+  var obj = goog.global;
+  for (var i = 0; i < parts.length - 1; i++) {
+    var part = parts[i];
+    if (part == 'prototype' && !obj[part]) {
+      throw Error('Cannot set the prototype of ' + parts.slice(0, i).join('.'));
+    }
+    if (!goog.isObject(obj[part]) && !goog.isFunction(obj[part])) {
+      this.set(obj, part, {});
+    }
+    obj = obj[part];
+  }
+  this.set(obj, parts[parts.length - 1], value);
+};
+/**
+ * Deletes the key from the object while saving its original value.
+ * @param {Object|Function} obj The JavaScript or native object or function to
+ *     alter. See the constraints in the class description.
+ * @param {string} key The key to delete.
+ */
+goog.testing.PropertyReplacer.prototype.remove = function(obj, key) {
+  if (goog.testing.PropertyReplacer.hasKey_(obj, key)) {
+    this.original_.push({object: obj, key: key, value: obj[key]});
+    goog.testing.PropertyReplacer.deleteKey_(obj, key);
+  }
+};
+/**
+ * Resets all changes made by goog.testing.PropertyReplacer.prototype.set.
+ */
+goog.testing.PropertyReplacer.prototype.reset = function() {
+  for (var i = this.original_.length - 1; i >= 0; i--) {
+    var original = this.original_[i];
+    if (original.value == goog.testing.PropertyReplacer.NO_SUCH_KEY_) {
+      goog.testing.PropertyReplacer.deleteKey_(original.object, original.key);
+    } else {
+      original.object[original.key] = original.value;
+    }
+    delete this.original_[i];
+  }
+  this.original_.length = 0;
+};

data/third_party/closure-library/closure/goog/testing/propertyreplacer_test.html ADDED Viewed

@@ -0,0 +1,368 @@
+<!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.PropertyReplacer</title>
+<script src="../base.js"></script>
+<script>
+  goog.require('goog.testing.PropertyReplacer');
+  goog.require('goog.testing.asserts');
+  goog.require('goog.testing.jsunit');
+</script>
+</head>
+<body>
+<script>
+// Test PropertyReplacer with JavaScript objects.
+function testSetJsProperties() {
+  var stubs = new goog.testing.PropertyReplacer();
+  var x = {a: 1, b: undefined};
+  // Setting simple values.
+  stubs.set(x, 'num', 1);
+  assertEquals('x.num = 1', 1, x.num);
+  stubs.set(x, 'undef', undefined);
+  assertTrue('x.undef = undefined', 'undef' in x && x.undef === undefined);
+  stubs.set(x, 'null', null);
+  assertTrue('x["null"] = null', x['null'] === null);
+  // Setting a simple value that existed originally.
+  stubs.set(x, 'b', null);
+  assertTrue('x.b = null', x.b === null);
+  // Setting a complex value.
+  stubs.set(x, 'obj', {});
+  assertEquals('x.obj = {}', 'object', typeof x.obj);
+  stubs.set(x.obj, 'num', 2);
+  assertEquals('x.obj.num = 2', 2, x.obj.num);
+  // Overwriting a leaf.
+  stubs.set(x.obj, 'num', 3);
+  assertEquals('x.obj.num = 3', 3, x.obj.num);
+  // Overwriting a non-leaf.
+  stubs.set(x, 'obj', {});
+  assertFalse('x.obj = {} again', 'num' in x.obj);
+  // Setting a function.
+  stubs.set(x, 'func', function(n) { return n + 1; });
+  assertEquals('x.func = lambda n: n+1', 11, x.func(10));
+  // Setting a constructor and a prototype method.
+  stubs.set(x, 'Class', function(num) { this.num = num; });
+  stubs.set(x.Class.prototype, 'triple', function() { return this.num * 3; });
+  assertEquals('prototype method', 12, (new x.Class(4)).triple());
+  // Cleaning up with UnsetAll() twice. The second run should have no effect.
+  for (var i = 0; i < 2; i++) {
+    stubs.reset();
+    assertEquals('x.a preserved', 1, x.a);
+    assertTrue('x.b reset', 'b' in x && x.b === undefined);
+    assertFalse('x.num removed', 'num' in x);
+    assertFalse('x.undef removed', 'undef' in x);
+    assertFalse('x["null"] removed', 'null' in x);
+    assertFalse('x.obj removed', 'obj' in x);
+    assertFalse('x.func removed', 'func' in x);
+    assertFalse('x.Class removed', 'Class' in x);
+  }
+}
+// Test removing JavaScript object properties.
+function testRemoveJsProperties() {
+  var stubs = new goog.testing.PropertyReplacer();
+  var orig = {'a': 1, 'b': undefined};
+  var x = {'a': 1, 'b': undefined};
+  stubs.remove(x, 'a');
+  assertFalse('x.a removed', 'a' in x);
+  assertTrue('x.b not removed', 'b' in x);
+  stubs.reset();
+  assertObjectEquals('x.a reset', x, orig);
+  stubs.remove(x, 'b');
+  assertFalse('x.b removed', 'b' in x);
+  stubs.reset();
+  assertObjectEquals('x.b reset', x, orig);
+  stubs.set(x, 'c', 2);
+  stubs.remove(x, 'c');
+  assertObjectEquals('x.c added then removed', x, orig);
+  stubs.reset();
+  assertObjectEquals('x.c reset', x, orig);
+  stubs.remove(x, 'b');
+  stubs.set(x, 'b', undefined);
+  assertObjectEquals('x.b removed then added', x, orig);
+  stubs.reset();
+  assertObjectEquals('x.b reset', x, orig);
+  stubs.remove(x, 'd');
+  assertObjectEquals('removing non-existing key', x, orig);
+  stubs.reset();
+  assertObjectEquals('reset removing non-existing key', x, orig);
+}
+// Test PropertyReplacer with prototype chain.
+function testPrototype() {
+  var stubs = new goog.testing.PropertyReplacer();
+  // Simple inheritance.
+  var a = {a: 0};
+  function B() {};
+  B.prototype = a;
+  var b = new B();
+  stubs.set(a, 0, 1);
+  stubs.set(b, 0, 2);
+  stubs.reset();
+  assertEquals('a.a == 0', 0, a['a']);
+  assertEquals('b.a == 0', 0, b['a']);
+  // Inheritance with goog.inherits.
+  var c = {a: 0};
+  function C() {};
+  C.prototype = c;
+  function D() {};
+  goog.inherits(D, C);
+  var d = new D();
+  var stubs = new goog.testing.PropertyReplacer();
+  stubs.set(c, 'a', 1);
+  stubs.set(d, 'a', 2);
+  stubs.reset();
+  assertEquals('c.a == 0', 0, c['a']);
+  assertEquals('d.a == 0', 0, d['a']);
+  // Setting prototype fields.
+  stubs.set(B.prototype, 'c', 'z');
+  assertEquals('b.c=="z"', 'z', b.c);
+  stubs.reset();
+  assertFalse('b.c deleted', 'c' in b);
+  // Setting Object.prototype's fields.
+  stubs.set(Object.prototype, 'one', 1);
+  assertEquals('b.one==1', 1, b.one);
+  stubs.reset();
+  assertFalse('b.one deleted', 'one' in b);
+  stubs.set(Object.prototype, 'two', 2);
+  stubs.remove(b, 'two');
+  assertEquals('b.two==2', 2, b.two);
+  stubs.remove(Object.prototype, 'two');
+  assertFalse('b.two deleted', 'two' in b);
+  stubs.reset();
+  assertFalse('Object prototype reset', 'two' in b);
+}
+// Test replacing function properties.
+function testFunctionProperties() {
+  var stubs = new goog.testing.PropertyReplacer();
+  stubs.set(Array, 'x', 1);
+  assertEquals('Array.x==1', 1, Array.x);
+  stubs.reset();
+  assertFalse('Array.x deleted', 'x' in Array);
+  stubs.set(Math.random, 'x', 1);
+  assertEquals('Math.random.x==1', 1, Math.random.x);
+  stubs.reset();
+  assertFalse('Math.random.x deleted', 'x' in Math.random);
+}
+// Test the hasKey_ private method.
+function testHasKey() {
+  f = goog.testing.PropertyReplacer.hasKey_;
+  assertFalse('{}.a', f({}, 'a'));
+  assertTrue('{a:0}.a', f({a: 0}, 'a'));
+  function C() {};
+  C.prototype.a = 0;
+  assertFalse('C.prototype.a set, is C.a own?', f(C, 'a'));
+  assertTrue('C.prototype.a', f(C.prototype, 'a'));
+  assertFalse('C.a not set', f(C, 'a'));
+  C.a = 0;
+  assertTrue('C.a set', f(C, 'a'));
+  var c = new C();
+  assertFalse('C().a, inherited', f(c, 'a'));
+  c.a = 0;
+  assertTrue('C().a, own', f(c, 'a'));
+  assertFalse('window, invalid key', f(window, 'no such key'));
+  assertTrue('window, global variable', f(window, 'goog'));
+  assertTrue('window, build-in key', f(window, 'location'))
+  assertFalse('document, invalid key', f(document, 'no such key'));
+  assertTrue('document.body', f(document, 'body'));
+  var div = document.createElement('div');
+  assertFalse('div, invalid key', f(div, 'no such key'));
+  assertTrue('div.className', f(div, 'className'));
+  div['a'] = 0;
+  assertTrue('div, key added by JS', f(div, 'a'));
+  assertFalse('Date().getTime', f(new Date(), 'getTime'));
+  assertTrue('Date.prototype.getTime', f(Date.prototype, 'getTime'));
+  assertFalse('Math, invalid key', f(Math, 'no such key'));
+  assertTrue('Math.random', f(Math, 'random'));
+  function Parent() {};
+  Parent.prototype.a = 0;
+  function Child() {};
+  goog.inherits(Child, Parent);
+  assertFalse('goog.inherits, parent prototype', f(new Child, 'a'));
+  Child.prototype.a = 1;
+  assertFalse('goog.inherits, child prototype', f(new Child, 'a'));
+  function OverwrittenProto() {};
+  OverwrittenProto.prototype = {a: 0};
+  assertFalse(f(new OverwrittenProto, 'a'));
+}
+// Test PropertyReplacer with DOM objects' built in attributes.
+function testDomBuiltInAttributes() {
+  var div = document.createElement('div');
+  div.id = 'old-id';
+  var stubs = new goog.testing.PropertyReplacer();
+  stubs.set(div, 'id', 'new-id');
+  stubs.set(div, 'className', 'test-class');
+  assertEquals('div.id == "new-id"', 'new-id', div.id);
+  assertEquals('div.className == "test-class"', 'test-class', div.className);
+  stubs.remove(div, 'className');
+  // '' in Firefox, undefined in Chrome.
+  assertEvaluatesToFalse('div.className is empty', div.className);
+  stubs.reset();
+  assertEquals('div.id == "old-id"', 'old-id', div.id);
+  assertEquals('div.name == ""', '', div.className);
+}
+// Test PropertyReplacer with DOM objects' custom attributes.
+function testDomCustomAttributes() {
+  var div = document.createElement('div');
+  div.attr1 = 'old';
+  var stubs = new goog.testing.PropertyReplacer();
+  stubs.set(div, 'attr1', 'new');
+  stubs.set(div, 'attr2', 'new');
+  assertEquals('div.attr1 == "new"', 'new', div.attr1);
+  assertEquals('div.attr2 == "new"', 'new', div.attr2);
+  stubs.set(div, 'attr3', 'new');
+  stubs.remove(div, 'attr3');
+  assertEquals('div.attr3 == undefined', undefined, div.attr3);
+  stubs.reset();
+  assertEquals('div.attr1 == "old"', 'old', div.attr1);
+  assertEquals('div.attr2 == undefined', undefined, div.attr2);
+}
+// Test PropertyReplacer overriding Math.random.
+function testMathRandom() {
+  var stubs = new goog.testing.PropertyReplacer();
+  stubs.set(Math, 'random', function() { return -1; });
+  assertEquals('mocked Math.random', -1, Math.random());
+  stubs.reset();
+  assertNotEquals('original Math.random', -1, Math.random());
+}
+// Tests the replace method of PropertyReplacer.
+function testReplace() {
+  var stubs = new goog.testing.PropertyReplacer();
+  function C() {
+    this.a = 1;
+  };
+  C.prototype.b = 1;
+  C.prototype.toString = function() {
+    return 'obj';
+  };
+  var obj = new C();
+  stubs.replace(obj, 'a', 2);
+  assertEquals('successfully replaced the own property of an object', 2, obj.a);
+  stubs.replace(obj, 'b', 2);
+  assertEquals('successfully replaced the property in the prototype', 2, obj.b);
+  var error = assertThrows('cannot replace missing key',
+      goog.bind(stubs.replace, stubs, obj, 'unknown', 1));
+  // Using assertContains instead of assertEquals because Opera 10.0 adds
+  // the stack trace to the error message.
+  assertEquals('error message for missing key',
+      'Cannot replace missing property "unknown" in obj', error.message);
+  assertFalse('object not touched', 'unknown' in obj);
+  var error = assertThrows('cannot change value type',
+      goog.bind(stubs.replace, stubs, obj, 'a', '3'));
+  assertContains('error message for type mismatch',
+      'Cannot replace property "a" in obj with a value of different type',
+      error.message);
+}
+// Tests altering complete namespace paths.
+function testSetPath() {
+  goog.global.a = {b: {}};
+  var stubs = new goog.testing.PropertyReplacer();
+  stubs.setPath('a.b.c.d', 1);
+  assertObjectEquals('a.b.c.d=1', {b: {c: {d: 1}}}, goog.global.a);
+  stubs.setPath('a.b.e', 2);
+  assertObjectEquals('a.b.e=2', {b: {c: {d: 1}, e: 2}}, goog.global.a);
+  stubs.setPath('a.f', 3);
+  assertObjectEquals('a.f=3', {b: {c: {d: 1}, e: 2}, f: 3}, goog.global.a);
+  stubs.setPath('a.f.g', 4);
+  assertObjectEquals('a.f.g=4', {b: {c: {d: 1}, e: 2}, f: {g: 4}},
+                     goog.global.a);
+  stubs.setPath('a', 5);
+  assertEquals('a=5', 5, goog.global.a);
+  stubs.setPath('x.y.z', 5);
+  assertObjectEquals('x.y.z=5', {y: {z: 5}}, goog.global.x);
+  stubs.reset();
+  assertObjectEquals('a.* reset', {b: {}}, goog.global.a);
+  // NOTE: it's impossible to delete global variables in Internet Explorer,
+  // so ('x' in goog.global) would be true.
+  assertUndefined('x.* reset', goog.global.x);
+}
+// Tests altering paths with functions in them.
+function testSetPathWithFunction() {
+  var f = function() {};
+  goog.global.a = {b: f};
+  var stubs = new goog.testing.PropertyReplacer();
+  stubs.setPath('a.b.c', 1);
+  assertEquals('a.b.c=1, f kept', f, goog.global.a.b);
+  assertEquals('a.b.c=1, c set', 1, goog.global.a.b.c);
+  stubs.setPath('a.b.prototype.d', 2);
+  assertEquals('a.b.prototype.d=2, b kept', f, goog.global.a.b);
+  assertEquals('a.b.prototype.d=2, c kept', 1, goog.global.a.b.c);
+  assertFalse('a.b.prototype.d=2, a.b.d not set', 'd' in goog.global.a.b);
+  assertTrue('a.b.prototype.d=2, proto set', 'd' in goog.global.a.b.prototype);
+  assertEquals('a.b.prototype.d=2, d set', 2, new goog.global.a.b().d);
+  var invalidSetPath = function() {
+    stubs.setPath('a.prototype.e', 3);
+  };
+  assertThrows('setting the prototype of a non-function', invalidSetPath);
+  stubs.reset();
+  assertObjectEquals('a.b.c reset', {b: f}, goog.global.a);
+  assertObjectEquals('a.b.prototype reset', {}, goog.global.a.b.prototype);
+}
+</script>
+</body>
+</html>