@angular-wave/angular.ts 0.4.4 → 0.4.6

package/src/core/scope/scope.spec.js

@@ -1,4 +1,4 @@
-import { $$asyncQueue, Scope, ScopePhase } from "./scope";
+import { $$asyncQueue, Scope } from "./scope";
 import { extend, sliceArgs } from "../../shared/utils";
 import { Angular } from "../../loader";
 import { createInjector } from "../di/injector";
@@ -9,7 +9,6 @@ describe("Scope", function () {
   let $browser;
   let logs;
   let scope;
-  let injector;
 
   beforeEach(() => {
     logs = [];
@@ -24,7 +23,7 @@ describe("Scope", function () {
         };
       });
 
-    injector = createInjector(["myModule"]);
+    let injector = createInjector(["myModule"]);
     $parse = injector.get("$parse");
     $browser = injector.get("$browser");
 
@@ -197,6 +196,822 @@ describe("Scope", function () {
   });
 
   describe("$watch/$digest", () => {
+    it("calls the listener function of a watch on first $digest", function () {
+      var watchFn = function () {
+        return "wat";
+      };
+      var listenerFn = jasmine.createSpy();
+      $rootScope.$watch(watchFn, listenerFn);
+      $rootScope.$digest();
+      expect(listenerFn).toHaveBeenCalled();
+    });
+
+    it("calls the watch function with the scope as the argument", function () {
+      var watchFn = jasmine.createSpy();
+      var listenerFn = function () {};
+      $rootScope.$watch(watchFn, listenerFn);
+      $rootScope.$digest();
+      expect(watchFn).toHaveBeenCalledWith($rootScope);
+    });
+
+    it("calls the listener function when the watched value changes", function () {
+      scope.someValue = "a";
+      scope.counter = 0;
+      scope.$watch(
+        function (scope) {
+          return scope.someValue;
+        },
+        function (newValue, oldValue, scope) {
+          scope.counter++;
+        },
+      );
+      expect(scope.counter).toBe(0);
+      scope.$digest();
+      expect(scope.counter).toBe(1);
+      scope.$digest();
+      expect(scope.counter).toBe(1);
+      scope.someValue = "b";
+      expect(scope.counter).toBe(1);
+      scope.$digest();
+      expect(scope.counter).toBe(2);
+    });
+
+    it("should watch and fire on simple property change", () => {
+      const spy = jasmine.createSpy();
+      $rootScope.$watch("name", spy);
+      $rootScope.$digest();
+      spy.calls.reset();
+
+      expect(spy).not.toHaveBeenCalled();
+      $rootScope.$digest();
+      expect(spy).not.toHaveBeenCalled();
+      $rootScope.name = "misko";
+      $rootScope.$digest();
+      expect(spy).toHaveBeenCalledWith("misko", undefined, $rootScope);
+    });
+
+    it("should not expose the `inner working of watch", () => {
+      function Getter() {
+        expect(this).toBeUndefined();
+        return "foo";
+      }
+      function Listener() {
+        expect(this).toBeUndefined();
+      }
+
+      $rootScope.$watch(Getter, Listener);
+      $rootScope.$digest();
+    });
+
+    it("should watch and fire on expression change", () => {
+      const spy = jasmine.createSpy();
+      $rootScope.$watch("name.first", spy);
+      $rootScope.$digest();
+      spy.calls.reset();
+
+      $rootScope.name = {};
+      expect(spy).not.toHaveBeenCalled();
+      $rootScope.$digest();
+      expect(spy).not.toHaveBeenCalled();
+      $rootScope.name.first = "misko";
+      $rootScope.$digest();
+      expect(spy).toHaveBeenCalled();
+    });
+
+    it("should decrement the watcherCount when destroying a child scope", () => {
+      const child1 = $rootScope.$new();
+      const child2 = $rootScope.$new();
+      const grandChild1 = child1.$new();
+      const grandChild2 = child2.$new();
+      child1.$watch("a", () => {});
+      child2.$watch("a", () => {});
+      grandChild1.$watch("a", () => {});
+      grandChild2.$watch("a", () => {});
+
+      expect($rootScope.$$watchersCount).toBe(4);
+      expect(child1.$$watchersCount).toBe(2);
+      expect(child2.$$watchersCount).toBe(2);
+      expect(grandChild1.$$watchersCount).toBe(1);
+      expect(grandChild2.$$watchersCount).toBe(1);
+
+      grandChild2.$destroy();
+      expect(child2.$$watchersCount).toBe(1);
+      expect($rootScope.$$watchersCount).toBe(3);
+      child1.$destroy();
+      expect($rootScope.$$watchersCount).toBe(1);
+    });
+
+    it("should decrement the watcherCount when calling the remove function", () => {
+      const child1 = $rootScope.$new();
+      const child2 = $rootScope.$new();
+      const grandChild1 = child1.$new();
+      const grandChild2 = child2.$new();
+      let remove1;
+      let remove2;
+
+      remove1 = child1.$watch("a", () => {});
+      child2.$watch("a", () => {});
+      grandChild1.$watch("a", () => {});
+      remove2 = grandChild2.$watch("a", () => {});
+
+      remove2();
+      expect(grandChild2.$$watchersCount).toBe(0);
+      expect(child2.$$watchersCount).toBe(1);
+      expect($rootScope.$$watchersCount).toBe(3);
+      remove1();
+      expect(grandChild1.$$watchersCount).toBe(1);
+      expect(child1.$$watchersCount).toBe(1);
+      expect($rootScope.$$watchersCount).toBe(2);
+
+      // Execute everything a second time to be sure that calling the remove function
+      // several times, it only decrements the counter once
+      remove2();
+      expect(child2.$$watchersCount).toBe(1);
+      expect($rootScope.$$watchersCount).toBe(2);
+      remove1();
+      expect(child1.$$watchersCount).toBe(1);
+      expect($rootScope.$$watchersCount).toBe(2);
+    });
+
+    describe("constants cleanup", () => {
+      beforeEach(() => (logs = []));
+      it("should remove $watch of constant literals after initial digest", () => {
+        $rootScope.$watch("[]", () => {});
+        $rootScope.$watch("{}", () => {});
+        $rootScope.$watch("1", () => {});
+        $rootScope.$watch('"foo"', () => {});
+        expect($rootScope.$$watchers.length).not.toEqual(0);
+        $rootScope.$digest();
+
+        expect($rootScope.$$watchers.length).toEqual(0);
+      });
+
+      it("should remove $watchCollection of constant literals after initial digest", () => {
+        $rootScope.$watchCollection("[]", () => {});
+        $rootScope.$watchCollection("{}", () => {});
+        $rootScope.$watchCollection("1", () => {});
+        $rootScope.$watchCollection('"foo"', () => {});
+        expect($rootScope.$$watchers.length).not.toEqual(0);
+        $rootScope.$digest();
+
+        expect($rootScope.$$watchers.length).toEqual(0);
+      });
+
+      it("should remove $watchGroup of constant literals after initial digest", () => {
+        $rootScope.$watchGroup(["[]", "{}", "1", '"foo"'], () => {});
+        expect($rootScope.$$watchers.length).not.toEqual(0);
+        $rootScope.$digest();
+
+        expect($rootScope.$$watchers.length).toEqual(0);
+      });
+
+      it("should remove $watch of filtered constant literals after initial digest", () => {
+        $rootScope.$watch('[1] | filter:"x"', () => {});
+        $rootScope.$watch("1 | limitTo:2", () => {});
+        expect($rootScope.$$watchers.length).not.toEqual(0);
+        $rootScope.$digest();
+
+        expect($rootScope.$$watchers.length).toEqual(0);
+      });
+
+      it("should remove $watchCollection of filtered constant literals after initial digest", () => {
+        $rootScope.$watchCollection('[1] | filter:"x"', () => {});
+        expect($rootScope.$$watchers.length).not.toEqual(0);
+        $rootScope.$digest();
+
+        expect($rootScope.$$watchers.length).toEqual(0);
+      });
+
+      it("should remove $watchGroup of filtered constant literals after initial digest", () => {
+        $rootScope.$watchGroup(['[1] | filter:"x"', "1 | limitTo:2"], () => {});
+        expect($rootScope.$$watchers.length).not.toEqual(0);
+        $rootScope.$digest();
+
+        expect($rootScope.$$watchers.length).toEqual(0);
+      });
+
+      it("should remove $watch of constant expressions after initial digest", () => {
+        $rootScope.$watch("1 + 1", () => {});
+        $rootScope.$watch('"a" + "b"', () => {});
+        $rootScope.$watch('"ab".length', () => {});
+        $rootScope.$watch("[].length", () => {});
+        $rootScope.$watch("(1 + 1) | limitTo:2", () => {});
+        expect($rootScope.$$watchers.length).not.toEqual(0);
+        $rootScope.$digest();
+
+        expect($rootScope.$$watchers.length).toEqual(0);
+      });
+    });
+
+    describe("onetime cleanup", () => {
+      it("should clean up stable watches on the watch queue", () => {
+        $rootScope.$watch("::foo", () => {});
+        expect($rootScope.$$watchers.length).toEqual(1);
+        $rootScope.$digest();
+        expect($rootScope.$$watchers.length).toEqual(1);
+
+        $rootScope.foo = "foo";
+        $rootScope.$digest();
+        expect($rootScope.$$watchers.length).toEqual(0);
+      });
+
+      it("should clean up stable watches from $watchCollection", () => {
+        $rootScope.$watchCollection("::foo", () => {});
+        expect($rootScope.$$watchers.length).toEqual(1);
+
+        $rootScope.$digest();
+        expect($rootScope.$$watchers.length).toEqual(1);
+
+        $rootScope.foo = [];
+        $rootScope.$digest();
+        expect($rootScope.$$watchers.length).toEqual(0);
+      });
+
+      it("should clean up stable watches from $watchCollection literals", () => {
+        $rootScope.$watchCollection("::[foo, bar]", () => {});
+        expect($rootScope.$$watchers.length).toEqual(1);
+
+        $rootScope.$digest();
+        expect($rootScope.$$watchers.length).toEqual(1);
+
+        $rootScope.foo = 1;
+        $rootScope.$digest();
+        expect($rootScope.$$watchers.length).toEqual(1);
+
+        $rootScope.foo = 2;
+        $rootScope.$digest();
+        expect($rootScope.$$watchers.length).toEqual(1);
+
+        $rootScope.bar = 3;
+        $rootScope.$digest();
+        expect($rootScope.$$watchers.length).toEqual(0);
+      });
+
+      it("should clean up stable watches from $watchGroup", () => {
+        $rootScope.$watchGroup(["::foo", "::bar"], () => {});
+        expect($rootScope.$$watchers.length).toEqual(2);
+
+        $rootScope.$digest();
+        expect($rootScope.$$watchers.length).toEqual(2);
+
+        $rootScope.foo = "foo";
+        $rootScope.$digest();
+        expect($rootScope.$$watchers.length).toEqual(1);
+
+        $rootScope.bar = "bar";
+        $rootScope.$digest();
+        expect($rootScope.$$watchers.length).toEqual(0);
+      });
+    });
+
+    it("should delegate exceptions", () => {
+      $rootScope.$watch("a", () => {
+        throw new Error("abc");
+      });
+      $rootScope.a = 1;
+      $rootScope.$digest();
+      expect(logs[0]).toMatch(/abc/);
+    });
+
+    it("should fire watches in order of addition", () => {
+      // this is not an external guarantee, just our own sanity
+      logs = "";
+      $rootScope.$watch("a", () => {
+        logs += "a";
+      });
+      $rootScope.$watch("b", () => {
+        logs += "b";
+      });
+      // constant expressions have slightly different handling,
+      // let's ensure they are kept in the same list as others
+      $rootScope.$watch("1", () => {
+        logs += "1";
+      });
+      $rootScope.$watch("c", () => {
+        logs += "c";
+      });
+      $rootScope.$watch("2", () => {
+        logs += "2";
+      });
+      $rootScope.a = $rootScope.b = $rootScope.c = 1;
+      $rootScope.$digest();
+      expect(logs).toEqual("ab1c2");
+    });
+
+    it("should call child $watchers in addition order", () => {
+      // this is not an external guarantee, just our own sanity
+      logs = "";
+      const childA = $rootScope.$new();
+      const childB = $rootScope.$new();
+      const childC = $rootScope.$new();
+      childA.$watch("a", () => {
+        logs += "a";
+      });
+      childB.$watch("b", () => {
+        logs += "b";
+      });
+      childC.$watch("c", () => {
+        logs += "c";
+      });
+      childA.a = childB.b = childC.c = 1;
+      $rootScope.$digest();
+      expect(logs).toEqual("abc");
+    });
+
+    it("should allow $digest on a child scope with and without a right sibling", () => {
+      // tests a traversal edge case which we originally missed
+      logs = "";
+      const childA = $rootScope.$new();
+      const childB = $rootScope.$new();
+
+      $rootScope.$watch(() => {
+        logs += "r";
+      });
+      childA.$watch(() => {
+        logs += "a";
+      });
+      childB.$watch(() => {
+        logs += "b";
+      });
+
+      // init
+      $rootScope.$digest();
+      expect(logs).toBe("rabrab");
+
+      logs = "";
+      childA.$digest();
+      expect(logs).toBe("a");
+
+      logs = "";
+      childB.$digest();
+      expect(logs).toBe("b");
+    });
+
+    it("should repeat watch cycle while model changes are identified", () => {
+      logs = "";
+      $rootScope.$watch("c", (v) => {
+        $rootScope.d = v;
+        logs += "c";
+      });
+      $rootScope.$watch("b", (v) => {
+        $rootScope.c = v;
+        logs += "b";
+      });
+      $rootScope.$watch("a", (v) => {
+        $rootScope.b = v;
+        logs += "a";
+      });
+      $rootScope.$digest();
+      logs = "";
+      $rootScope.a = 1;
+      $rootScope.$digest();
+      expect($rootScope.b).toEqual(1);
+      expect($rootScope.c).toEqual(1);
+      expect($rootScope.d).toEqual(1);
+      expect(logs).toEqual("abc");
+    });
+
+    it("should repeat watch cycle from the root element", () => {
+      logs = "";
+      const child = $rootScope.$new();
+      $rootScope.$watch(() => {
+        logs += "a";
+      });
+      child.$watch(() => {
+        logs += "b";
+      });
+      $rootScope.$digest();
+      expect(logs).toEqual("abab");
+    });
+
+    it("should prevent infinite recursion and print watcher expression", () => {
+      $rootScope.$watch("a", function () {
+        $rootScope.b++;
+      });
+      $rootScope.$watch("b", function () {
+        $rootScope.a++;
+      });
+      $rootScope.a = $rootScope.b = 0;
+      expect(function () {
+        $rootScope.$digest();
+      }).toThrow();
+
+      expect($rootScope.$$phase).toBe(0);
+    });
+
+    it("should prevent infinite recursion and print watcher function name or body", () => {
+      $rootScope.$watch(
+        () => $rootScope.a,
+        () => {
+          $rootScope.b++;
+        },
+      );
+      $rootScope.$watch(
+        () => $rootScope.b,
+        () => {
+          $rootScope.a++;
+        },
+      );
+      $rootScope.a = $rootScope.b = 0;
+
+      try {
+        $rootScope.$digest();
+        throw new Error("Should have thrown exception");
+      } catch (e) {
+        console.error(e);
+        expect(e.message.match(/rootScope.a/g).length).toBeTruthy();
+        expect(e.message.match(/rootScope.b/g).length).toBeTruthy();
+      }
+    });
+
+    // it("should prevent infinite loop when creating and resolving a promise in a watched expression", () => {
+    //   module(($rootScopeProvider) => {
+    //     $rootScopeProvider.digestTtl(10);
+    //   });
+    //   () => {
+    //     const d = $q.defer();
+
+    //     d.resolve("Hello, world.");
+    //     $rootScope.$watch(
+    //       () => {
+    //         const $d2 = $q.defer();
+    //         $d2.resolve("Goodbye.");
+    //         $d2.promise.then(() => {});
+    //         return d.promise;
+    //       },
+    //       () => 0,
+    //     );
+
+    //     expect(() => {
+    //       $rootScope.$digest();
+    //     }).toThrow(
+    //       "$rootScope",
+    //       "infdig",
+    //       "10 $digest() iterations reached. Aborting!\n" +
+    //         "Watchers fired in the last 5 iterations: []",
+    //     );
+
+    //     expect($rootScope.$$phase).toBeNull();
+    //   });
+    // });
+
+    it("should not fire upon $watch registration on initial $digest", () => {
+      logs = "";
+      $rootScope.a = 1;
+      $rootScope.$watch("a", () => {
+        logs += "a";
+      });
+      $rootScope.$watch("b", () => {
+        logs += "b";
+      });
+      $rootScope.$digest();
+      logs = "";
+      $rootScope.$digest();
+      expect(logs).toEqual("");
+    });
+
+    it("should watch objects", () => {
+      logs = "";
+      $rootScope.a = [];
+      $rootScope.b = {};
+      $rootScope.$watch(
+        "a",
+        (value) => {
+          logs += ".";
+          expect(value).toBe($rootScope.a);
+        },
+        true,
+      );
+      $rootScope.$watch(
+        "b",
+        (value) => {
+          logs += "!";
+          expect(value).toBe($rootScope.b);
+        },
+        true,
+      );
+      $rootScope.$digest();
+      logs = "";
+
+      $rootScope.a.push({});
+      $rootScope.b.name = "";
+
+      $rootScope.$digest();
+      expect(logs).toEqual(".!");
+    });
+
+    it("should watch functions", () => {
+      $rootScope.fn = function () {
+        return "a";
+      };
+      $rootScope.$watch("fn", (fn) => {
+        logs.push(fn());
+      });
+      $rootScope.$digest();
+      expect(logs).toEqual(["a"]);
+      $rootScope.fn = function () {
+        return "b";
+      };
+      $rootScope.$digest();
+      expect(logs).toEqual(["a", "b"]);
+    });
+
+    it("should prevent $digest recursion", () => {
+      let callCount = 0;
+      $rootScope.$watch("name", () => {
+        expect(() => {
+          $rootScope.$digest();
+        }).toThrowError(/digest already in progress/);
+        callCount++;
+      });
+      $rootScope.name = "a";
+      $rootScope.$digest();
+      expect(callCount).toEqual(1);
+    });
+
+    it("should allow a watch to be added while in a digest", () => {
+      const watch1 = jasmine.createSpy("watch1");
+      const watch2 = jasmine.createSpy("watch2");
+      $rootScope.$watch("foo", () => {
+        $rootScope.$watch("foo", watch1);
+        $rootScope.$watch("foo", watch2);
+      });
+      $rootScope.$apply("foo = true");
+      expect(watch1).toHaveBeenCalled();
+      expect(watch2).toHaveBeenCalled();
+    });
+
+    it("should not skip watchers when adding new watchers during digest", () => {
+      const watchFn1 = function () {
+        logs.push(1);
+      };
+      const watchFn2 = function () {
+        logs.push(2);
+      };
+      const watchFn3 = function () {
+        logs.push(3);
+      };
+      const addWatcherOnce = function (newValue, oldValue) {
+        if (newValue === oldValue) {
+          $rootScope.$watch(watchFn3);
+        }
+      };
+
+      $rootScope.$watch(watchFn1, addWatcherOnce);
+      $rootScope.$watch(watchFn2);
+
+      $rootScope.$digest();
+
+      expect(logs).toEqual([1, 2, 3, 1, 2, 3]);
+    });
+
+    it("should not run the current watcher twice when removing a watcher during digest", () => {
+      let removeWatcher3;
+
+      const watchFn3 = function () {
+        logs.push(3);
+      };
+      const watchFn2 = function () {
+        logs.push(2);
+      };
+      const watchFn1 = function () {
+        logs.push(1);
+      };
+      const removeWatcherOnce = function (newValue, oldValue) {
+        if (newValue === oldValue) {
+          removeWatcher3();
+        }
+      };
+
+      $rootScope.$watch(watchFn1, removeWatcherOnce);
+      $rootScope.$watch(watchFn2);
+      removeWatcher3 = $rootScope.$watch(watchFn3);
+
+      $rootScope.$digest();
+
+      expect(logs).toEqual([1, 2, 1, 2]);
+    });
+
+    it("should not skip watchers when removing itself during digest", () => {
+      let removeWatcher1;
+
+      const watchFn3 = function () {
+        logs.push(3);
+      };
+      const watchFn2 = function () {
+        logs.push(2);
+      };
+      const watchFn1 = function () {
+        logs.push(1);
+      };
+      const removeItself = function () {
+        removeWatcher1();
+      };
+
+      removeWatcher1 = $rootScope.$watch(watchFn1, removeItself);
+      $rootScope.$watch(watchFn2);
+      $rootScope.$watch(watchFn3);
+
+      $rootScope.$digest();
+
+      expect(logs).toEqual([1, 2, 3, 2, 3]);
+    });
+
+    it("should not infinitely digest when current value is NaN", () => {
+      $rootScope.$watch(() => NaN);
+
+      expect(() => {
+        $rootScope.$digest();
+      }).not.toThrow();
+    });
+
+    it("should always call the watcher with newVal and oldVal equal on the first run", () => {
+      function logger(scope, newVal, oldVal) {
+        const val =
+          newVal === oldVal || (newVal !== oldVal && oldVal !== newVal)
+            ? newVal
+            : "xxx";
+        logs.push(val);
+      }
+
+      $rootScope.$watch(() => NaN, logger);
+      $rootScope.$watch(() => undefined, logger);
+      $rootScope.$watch(() => "", logger);
+      $rootScope.$watch(() => false, logger);
+      $rootScope.$watch(() => ({}), logger, true);
+      $rootScope.$watch(() => 23, logger);
+
+      $rootScope.$digest();
+      expect(isNaN(logs.shift())).toBe(true); // jasmine's toBe and toEqual don't work well with NaNs
+      expect(logs).toEqual([undefined, "", false, {}, 23]);
+      logs = [];
+      $rootScope.$digest();
+      expect(logs).toEqual([]);
+    });
+
+    describe("$watch deregistration", () => {
+      beforeEach(() => (logs = []));
+      it("should return a function that allows listeners to be deregistered", () => {
+        const listener = jasmine.createSpy("watch listener");
+        let listenerRemove;
+
+        listenerRemove = $rootScope.$watch("foo", listener);
+        $rootScope.$digest(); // init
+        expect(listener).toHaveBeenCalled();
+        expect(listenerRemove).toBeDefined();
+
+        listener.calls.reset();
+        $rootScope.foo = "bar";
+        $rootScope.$digest(); // trigger
+        expect(listener).toHaveBeenCalled();
+
+        listener.calls.reset();
+        $rootScope.foo = "baz";
+        listenerRemove();
+        $rootScope.$digest(); // trigger
+        expect(listener).not.toHaveBeenCalled();
+      });
+
+      it("should allow a watch to be deregistered while in a digest", () => {
+        let remove1;
+        let remove2;
+        $rootScope.$watch("remove", () => {
+          remove1();
+          remove2();
+        });
+        remove1 = $rootScope.$watch("thing", () => {});
+        remove2 = $rootScope.$watch("thing", () => {});
+        expect(() => {
+          $rootScope.$apply("remove = true");
+        }).not.toThrow();
+      });
+
+      it("should not mess up the digest loop if deregistration happens during digest", () => {
+        // we are testing this due to regression #5525 which is related to how the digest loops lastDirtyWatch short-circuiting optimization works
+        // scenario: watch1 deregistering watch1
+        let scope = $rootScope.$new();
+        let deregWatch1 = scope.$watch(
+          () => {
+            logs.push("watch1");
+            return "watch1";
+          },
+          () => {
+            deregWatch1();
+            logs.push("watchAction1");
+          },
+        );
+        scope.$watch(
+          () => {
+            logs.push("watch2");
+            return "watch2";
+          },
+          () => logs.push("watchAction2"),
+        );
+        scope.$watch(
+          () => {
+            logs.push("watch3");
+            return "watch3";
+          },
+          () => logs.push("watchAction3"),
+        );
+
+        $rootScope.$digest();
+
+        expect(logs).toEqual([
+          "watch1",
+          "watchAction1",
+          "watch2",
+          "watchAction2",
+          "watch3",
+          "watchAction3",
+          "watch2",
+          "watch3",
+        ]);
+        scope.$destroy();
+        logs = [];
+
+        // scenario: watch1 deregistering watch2
+        scope = $rootScope.$new();
+        scope.$watch(
+          () => {
+            logs.push("watch1");
+            return "watch1";
+          },
+          () => {
+            deregWatch2();
+            logs.push("watchAction1");
+          },
+        );
+        let deregWatch2 = scope.$watch(
+          () => {
+            logs.push("watch2");
+            return "watch2";
+          },
+          () => logs.push("watchAction2"),
+        );
+        scope.$watch(
+          () => {
+            logs.push("watch3");
+            return "watch3";
+          },
+          () => logs.push("watchAction3"),
+        );
+
+        $rootScope.$digest();
+
+        expect(logs).toEqual([
+          "watch1",
+          "watchAction1",
+          "watch3",
+          "watchAction3",
+          "watch1",
+          "watch3",
+        ]);
+        scope.$destroy();
+        logs = [];
+
+        // scenario: watch2 deregistering watch1
+        scope = $rootScope.$new();
+        deregWatch1 = scope.$watch(
+          () => {
+            logs.push("watch1");
+            return "watch1";
+          },
+          () => logs.push("watchAction1"),
+        );
+        scope.$watch(
+          () => {
+            logs.push("watch2");
+            return "watch2";
+          },
+          () => {
+            deregWatch1();
+            logs.push("watchAction2");
+          },
+        );
+        scope.$watch(
+          () => {
+            logs.push("watch3");
+            return "watch3";
+          },
+          () => logs.push("watchAction3"),
+        );
+
+        $rootScope.$digest();
+
+        expect(logs).toEqual([
+          "watch1",
+          "watchAction1",
+          "watch2",
+          "watchAction2",
+          "watch3",
+          "watchAction3",
+          "watch2",
+          "watch3",
+        ]);
+      });
+    });
+
     describe("$watchCollection", () => {
       describe("constiable", () => {
         let deregister;
@@ -214,21 +1029,25 @@ describe("Scope", function () {
         });
 
         it("should not trigger if nothing change", () => {
+          $rootScope.$digest();
           expect(logs).toEqual([
             { newVal: undefined, oldVal: undefined, identical: true },
           ]);
           logs = [];
+          $rootScope.$digest();
           expect(logs).toEqual([]);
         });
 
         it("should allow deregistration", () => {
           $rootScope.obj = [];
+          $rootScope.$digest();
           expect(logs.length).toBe(1);
           logs = [];
 
           $rootScope.obj.push("a");
           deregister();
 
+          $rootScope.$digest();
           expect(logs).toEqual([]);
         });
 
@@ -236,6 +1055,7 @@ describe("Scope", function () {
           it("should return oldCollection === newCollection only on the first listener call", () => {
             // first time should be identical
             $rootScope.obj = ["a", "b"];
+            $rootScope.$digest();
             expect(logs).toEqual([
               { newVal: ["a", "b"], oldVal: ["a", "b"], identical: true },
             ]);
@@ -243,58 +1063,99 @@ describe("Scope", function () {
 
             // second time should be different
             $rootScope.obj[1] = "c";
+            $rootScope.$digest();
             expect(logs).toEqual([{ newVal: ["a", "c"], oldVal: ["a", "b"] }]);
           });
 
+          it("should trigger when property changes into array", () => {
+            $rootScope.obj = "test";
+            $rootScope.$digest();
+            expect(logs).toEqual([
+              { newVal: "test", oldVal: "test", identical: true },
+            ]);
+
+            logs = [];
+            $rootScope.obj = [];
+            $rootScope.$digest();
+            expect(logs).toEqual([{ newVal: [], oldVal: "test" }]);
+
+            logs = [];
+            $rootScope.obj = {};
+            $rootScope.$digest();
+            expect(logs).toEqual([{ newVal: {}, oldVal: [] }]);
+
+            logs = [];
+            $rootScope.obj = [];
+            $rootScope.$digest();
+            expect(logs).toEqual([{ newVal: [], oldVal: {} }]);
+
+            logs = [];
+            $rootScope.obj = undefined;
+            $rootScope.$digest();
+            expect(logs).toEqual([{ newVal: undefined, oldVal: [] }]);
+          });
+
           it("should not trigger change when object in collection changes", () => {
             $rootScope.obj = [{}];
+            $rootScope.$digest();
             expect(logs).toEqual([
               { newVal: [{}], oldVal: [{}], identical: true },
             ]);
 
             logs = [];
             $rootScope.obj[0].name = "foo";
+            $rootScope.$digest();
             expect(logs).toEqual([]);
           });
 
           it("should watch array properties", () => {
             $rootScope.obj = [];
+            $rootScope.$digest();
             expect(logs).toEqual([{ newVal: [], oldVal: [], identical: true }]);
 
             logs = [];
             $rootScope.obj.push("a");
+            $rootScope.$digest();
             expect(logs).toEqual([{ newVal: ["a"], oldVal: [] }]);
 
             logs = [];
             $rootScope.obj[0] = "b";
+            $rootScope.$digest();
             expect(logs).toEqual([{ newVal: ["b"], oldVal: ["a"] }]);
 
             logs = [];
             $rootScope.obj.push([]);
             $rootScope.obj.push({});
+            $rootScope.$digest();
             expect(logs).toEqual([{ newVal: ["b", [], {}], oldVal: ["b"] }]);
 
             logs = [];
             const temp = $rootScope.obj[1];
             $rootScope.obj[1] = $rootScope.obj[2];
             $rootScope.obj[2] = temp;
+            $rootScope.$digest();
             expect(logs).toEqual([
               { newVal: ["b", {}, []], oldVal: ["b", [], {}] },
             ]);
 
             logs = [];
             $rootScope.obj.shift();
+            $rootScope.$digest();
             expect(logs).toEqual([{ newVal: [{}, []], oldVal: ["b", {}, []] }]);
           });
 
           it("should not infinitely digest when current value is NaN", () => {
             $rootScope.obj = [NaN];
-            expect(() => {}).not.toThrow();
+            expect(() => {
+              $rootScope.$digest();
+            }).not.toThrow();
           });
 
           it("should watch array-like objects like arrays", () => {
             logs = [];
             $rootScope.obj = document.getElementsByTagName("src");
+            $rootScope.$digest();
+
             expect(logs.length).toBeTruthy();
           });
         });
@@ -303,6 +1164,7 @@ describe("Scope", function () {
           it("should return oldCollection === newCollection only on the first listener call", () => {
             $rootScope.obj = { a: "b" };
             // first time should be identical
+            $rootScope.$digest();
             expect(logs).toEqual([
               { newVal: { a: "b" }, oldVal: { a: "b" }, identical: true },
             ]);
@@ -310,45 +1172,54 @@ describe("Scope", function () {
 
             // second time not identical
             $rootScope.obj.a = "c";
+            $rootScope.$digest();
             expect(logs).toEqual([{ newVal: { a: "c" }, oldVal: { a: "b" } }]);
           });
 
           it("should trigger when property changes into object", () => {
             $rootScope.obj = "test";
+            $rootScope.$digest();
             expect(logs).toEqual([
               { newVal: "test", oldVal: "test", identical: true },
             ]);
             logs = [];
 
             $rootScope.obj = {};
+            $rootScope.$digest();
             expect(logs).toEqual([{ newVal: {}, oldVal: "test" }]);
           });
 
           it("should not trigger change when object in collection changes", () => {
             $rootScope.obj = { name: {} };
+            $rootScope.$digest();
             expect(logs).toEqual([
               { newVal: { name: {} }, oldVal: { name: {} }, identical: true },
             ]);
             logs = [];
 
             $rootScope.obj.name.bar = "foo";
+            $rootScope.$digest();
             expect(logs).toEqual([]);
           });
 
           it("should watch object properties", () => {
             $rootScope.obj = {};
+            $rootScope.$digest();
             expect(logs).toEqual([{ newVal: {}, oldVal: {}, identical: true }]);
             logs = [];
             $rootScope.obj.a = "A";
+            $rootScope.$digest();
             expect(logs).toEqual([{ newVal: { a: "A" }, oldVal: {} }]);
 
             logs = [];
             $rootScope.obj.a = "B";
+            $rootScope.$digest();
             expect(logs).toEqual([{ newVal: { a: "B" }, oldVal: { a: "A" } }]);
 
             logs = [];
             $rootScope.obj.b = [];
             $rootScope.obj.c = {};
+            $rootScope.$digest();
             expect(logs).toEqual([
               { newVal: { a: "B", b: [], c: {} }, oldVal: { a: "B" } },
             ]);
@@ -357,6 +1228,7 @@ describe("Scope", function () {
             const temp = $rootScope.obj.a;
             $rootScope.obj.a = $rootScope.obj.b;
             $rootScope.obj.c = temp;
+            $rootScope.$digest();
             expect(logs).toEqual([
               {
                 newVal: { a: [], b: [], c: "B" },
@@ -366,6 +1238,7 @@ describe("Scope", function () {
 
             logs = [];
             delete $rootScope.obj.a;
+            $rootScope.$digest();
             expect(logs).toEqual([
               { newVal: { b: [], c: "B" }, oldVal: { a: [], b: [], c: "B" } },
             ]);
@@ -373,18 +1246,22 @@ describe("Scope", function () {
 
           it("should not infinitely digest when current value is NaN", () => {
             $rootScope.obj = { a: NaN };
-            expect(() => {}).not.toThrow();
+            expect(() => {
+              $rootScope.$digest();
+            }).not.toThrow();
           });
 
           it("should handle objects created using `Object.create(null)`", () => {
             $rootScope.obj = Object.create(null);
             $rootScope.obj.a = "a";
             $rootScope.obj.b = "b";
+            $rootScope.$digest();
             expect(logs[0].newVal).toEqual(
               extend(Object.create(null), { a: "a", b: "b" }),
             );
 
             delete $rootScope.obj.b;
+            $rootScope.$digest();
             expect(logs[0].newVal).toEqual(
               extend(Object.create(null), { a: "a" }),
             );
@@ -410,6 +1287,7 @@ describe("Scope", function () {
           it("should return oldCollection === newCollection only on the first listener call", () => {
             // first time should be identical
             $rootScope.obj = "a";
+            $rootScope.$digest();
             expect(logs).toEqual([
               { newVal: ["a"], oldVal: ["a"], identical: true },
             ]);
@@ -417,46 +1295,56 @@ describe("Scope", function () {
 
             // second time should be different
             $rootScope.obj = "b";
+            $rootScope.$digest();
             expect(logs).toEqual([{ newVal: ["b"], oldVal: ["a"] }]);
           });
 
           it("should trigger when property changes into array", () => {
             $rootScope.obj = "test";
+            $rootScope.$digest();
             expect(logs).toEqual([
               { newVal: ["test"], oldVal: ["test"], identical: true },
             ]);
 
             logs = [];
             $rootScope.obj = [];
+            $rootScope.$digest();
             expect(logs).toEqual([{ newVal: [[]], oldVal: ["test"] }]);
 
             logs = [];
             $rootScope.obj = {};
+            $rootScope.$digest();
             expect(logs).toEqual([{ newVal: [{}], oldVal: [[]] }]);
 
             logs = [];
             $rootScope.obj = [];
+            $rootScope.$digest();
             expect(logs).toEqual([{ newVal: [[]], oldVal: [{}] }]);
 
             logs = [];
             $rootScope.obj = undefined;
+            $rootScope.$digest();
             expect(logs).toEqual([{ newVal: [undefined], oldVal: [[]] }]);
           });
 
           it("should not trigger change when object in collection changes", () => {
             $rootScope.obj = {};
+            $rootScope.$digest();
             expect(logs).toEqual([
               { newVal: [{}], oldVal: [{}], identical: true },
             ]);
 
             logs = [];
             $rootScope.obj.name = "foo";
+            $rootScope.$digest();
             expect(logs).toEqual([]);
           });
 
           it("should not infinitely digest when current value is NaN", () => {
             $rootScope.obj = NaN;
-            expect(() => {}).not.toThrow();
+            expect(() => {
+              $rootScope.$digest();
+            }).not.toThrow();
           });
         });
 
@@ -477,6 +1365,7 @@ describe("Scope", function () {
           it("should return oldCollection === newCollection only on the first listener call", () => {
             $rootScope.obj = "b";
             // first time should be identical
+            $rootScope.$digest();
             expect(logs).toEqual([
               { newVal: { a: "b" }, oldVal: { a: "b" }, identical: true },
             ]);
@@ -484,17 +1373,20 @@ describe("Scope", function () {
             // second time not identical
             logs = [];
             $rootScope.obj = "c";
+            $rootScope.$digest();
             expect(logs).toEqual([{ newVal: { a: "c" }, oldVal: { a: "b" } }]);
           });
 
           it("should trigger when property changes into object", () => {
             $rootScope.obj = "test";
+            $rootScope.$digest();
             expect(logs).toEqual([
               { newVal: { a: "test" }, oldVal: { a: "test" }, identical: true },
             ]);
 
             logs = [];
             $rootScope.obj = {};
+            $rootScope.$digest();
             expect(logs).toEqual([
               { newVal: { a: {} }, oldVal: { a: "test" } },
             ]);
@@ -502,6 +1394,7 @@ describe("Scope", function () {
 
           it("should not trigger change when object in collection changes", () => {
             $rootScope.obj = { name: "foo" };
+            $rootScope.$digest();
             expect(logs).toEqual([
               {
                 newVal: { a: { name: "foo" } },
@@ -512,29 +1405,35 @@ describe("Scope", function () {
 
             logs = [];
             $rootScope.obj.name = "bar";
+            $rootScope.$digest();
             expect(logs).toEqual([]);
           });
 
           it("should watch object properties", () => {
             $rootScope.obj = {};
+            $rootScope.$digest();
             expect(logs).toEqual([
               { newVal: { a: {} }, oldVal: { a: {} }, identical: true },
             ]);
 
             logs = [];
             $rootScope.obj = "A";
+            $rootScope.$digest();
             expect(logs).toEqual([{ newVal: { a: "A" }, oldVal: { a: {} } }]);
 
             logs = [];
             $rootScope.obj = "B";
+            $rootScope.$digest();
             expect(logs).toEqual([{ newVal: { a: "B" }, oldVal: { a: "A" } }]);
 
             logs = [];
             $rootScope.obj = [];
+            $rootScope.$digest();
             expect(logs).toEqual([{ newVal: { a: [] }, oldVal: { a: "B" } }]);
 
             logs = [];
             delete $rootScope.obj;
+            $rootScope.$digest();
             expect(logs).toEqual([
               { newVal: { a: undefined }, oldVal: { a: [] } },
             ]);
@@ -542,7 +1441,9 @@ describe("Scope", function () {
 
           it("should not infinitely digest when current value is NaN", () => {
             $rootScope.obj = NaN;
-            expect(() => {}).not.toThrow();
+            expect(() => {
+              $rootScope.$digest();
+            }).not.toThrow();
           });
         });
 
@@ -562,6 +1463,7 @@ describe("Scope", function () {
 
           it('should default to "undefined" key', () => {
             $rootScope.obj = "test";
+            $rootScope.$digest();
             expect(logs).toEqual([
               {
                 newVal: { undefined: "test" },
@@ -574,18 +1476,21 @@ describe("Scope", function () {
           it("should trigger when key changes", () => {
             $rootScope.key = "a";
             $rootScope.obj = "test";
+            $rootScope.$digest();
             expect(logs).toEqual([
               { newVal: { a: "test" }, oldVal: { a: "test" }, identical: true },
             ]);
 
             logs = [];
             $rootScope.key = "b";
+            $rootScope.$digest();
             expect(logs).toEqual([
               { newVal: { b: "test" }, oldVal: { a: "test" } },
             ]);
 
             logs = [];
             $rootScope.key = true;
+            $rootScope.$digest();
             expect(logs).toEqual([
               { newVal: { true: "test" }, oldVal: { b: "test" } },
             ]);
@@ -594,25 +1499,30 @@ describe("Scope", function () {
           it("should not trigger when key changes but stringified key does not", () => {
             $rootScope.key = 1;
             $rootScope.obj = "test";
+            $rootScope.$digest();
             expect(logs).toEqual([
               { newVal: { 1: "test" }, oldVal: { 1: "test" }, identical: true },
             ]);
 
             logs = [];
             $rootScope.key = "1";
+            $rootScope.$digest();
             expect(logs).toEqual([]);
 
             $rootScope.key = true;
+            $rootScope.$digest();
             expect(logs).toEqual([
               { newVal: { true: "test" }, oldVal: { 1: "test" } },
             ]);
 
             logs = [];
             $rootScope.key = "true";
+            $rootScope.$digest();
             expect(logs).toEqual([]);
 
             logs = [];
             $rootScope.key = {};
+            $rootScope.$digest();
             expect(logs).toEqual([
               {
                 newVal: { "[object Object]": "test" },
@@ -622,12 +1532,14 @@ describe("Scope", function () {
 
             logs = [];
             $rootScope.key = {};
+            $rootScope.$digest();
             expect(logs).toEqual([]);
           });
 
           it("should not trigger change when object in collection changes", () => {
             $rootScope.key = "a";
             $rootScope.obj = { name: "foo" };
+            $rootScope.$digest();
             expect(logs).toEqual([
               {
                 newVal: { a: { name: "foo" } },
@@ -638,13 +1550,16 @@ describe("Scope", function () {
             logs = [];
 
             $rootScope.obj.name = "bar";
+            $rootScope.$digest();
             expect(logs).toEqual([]);
           });
 
           it("should not infinitely digest when key value is NaN", () => {
             $rootScope.key = NaN;
             $rootScope.obj = NaN;
-            expect(() => {}).not.toThrow();
+            expect(() => {
+              $rootScope.$digest();
+            }).not.toThrow();
           });
         });
       });
@@ -655,6 +1570,7 @@ describe("Scope", function () {
         const watchSpy = jasmine.createSpy("watchSpy");
         $rootScope.$watch(watchSpy);
         $rootScope.$suspend();
+        $rootScope.$digest();
         expect(watchSpy).not.toHaveBeenCalled();
       });
 
@@ -663,6 +1579,7 @@ describe("Scope", function () {
         $rootScope.$watch(watchSpy);
         $rootScope.$suspend();
         $rootScope.$resume();
+        $rootScope.$digest();
         expect(watchSpy).toHaveBeenCalled();
       });
 
@@ -671,6 +1588,7 @@ describe("Scope", function () {
         const scope = $rootScope.$new(true);
         scope.$watch(watchSpy);
         $rootScope.$suspend();
+        $rootScope.$digest();
         expect(watchSpy).not.toHaveBeenCalled();
       });
 
@@ -680,6 +1598,7 @@ describe("Scope", function () {
         scope.$watch(watchSpy);
         $rootScope.$suspend();
         $rootScope.$resume();
+        $rootScope.$digest();
         expect(watchSpy).toHaveBeenCalled();
       });
 
@@ -746,6 +1665,7 @@ describe("Scope", function () {
         sibling.$watch(watchSpySibling);
 
         child.$suspend();
+        $rootScope.$digest();
         expect(watchSpyParent).toHaveBeenCalled();
         expect(watchSpyChild).not.toHaveBeenCalled();
         expect(watchSpySibling).toHaveBeenCalled();
@@ -786,8 +1706,123 @@ describe("Scope", function () {
         return scope.w3;
       }, log("w3action"));
       console.error(logs.length);
+      scope.$digest();
       logs = [];
     }
+
+    describe("optimizations", () => {
+      beforeEach(() => (logs = []));
+      it("should check watches only once during an empty digest", () => {
+        setupWatches($rootScope, console.log);
+        $rootScope.$digest();
+        expect(logs).toEqual(["w1", "w2", "w3"]);
+      });
+
+      it("should quit digest early after we check the last watch that was previously dirty", () => {
+        setupWatches($rootScope, console.log);
+        $rootScope.w1 = "x";
+        $rootScope.$digest();
+        expect(logs).toEqual(["w1", "w2", "w3", "w1"]);
+      });
+
+      it("should not quit digest early if a new watch was added from an existing watch action", () => {
+        setupWatches($rootScope, console.log);
+        $rootScope.$watch(
+          () => {
+            logs.push("w4");
+            return "w4";
+          },
+          () => {
+            logs.push("w4action");
+            $rootScope.$watch(
+              () => {
+                logs.push("w5");
+                return "w5";
+              },
+              () => logs.push("w5action"),
+            );
+          },
+        );
+        $rootScope.$digest();
+        expect(logs).toEqual([
+          "w1",
+          "w2",
+          "w3",
+          "w4",
+          "w4action",
+          "w5",
+          "w5action",
+          "w1",
+          "w2",
+          "w3",
+          "w4",
+          "w5",
+        ]);
+      });
+
+      it("should not quit digest early if an evalAsync task was scheduled from a watch action", () => {
+        setupWatches($rootScope, console.log);
+        $rootScope.$watch(
+          () => {
+            logs.push("w4");
+            return "w4";
+          },
+          () => {
+            logs.push("w4action");
+            $rootScope.$evalAsync(() => {
+              logs.push("evalAsync");
+            });
+          },
+        );
+        $rootScope.$digest();
+        expect(logs).toEqual([
+          "w1",
+          "w2",
+          "w3",
+          "w4",
+          "w4action",
+          "evalAsync",
+          "w1",
+          "w2",
+          "w3",
+          "w4",
+        ]);
+      });
+
+      it("should quit digest early but not too early when constious watches fire", () => {
+        setupWatches($rootScope, console.log);
+        $rootScope.$watch(
+          () => {
+            logs.push("w4");
+            return $rootScope.w4;
+          },
+          (newVal) => {
+            logs.push("w4action");
+            $rootScope.w2 = newVal;
+          },
+        );
+
+        $rootScope.$digest();
+        logs = [];
+
+        $rootScope.w1 = "x";
+        $rootScope.w4 = "x";
+        $rootScope.$digest();
+        expect(logs).toEqual([
+          "w1",
+          "w2",
+          "w3",
+          "w4",
+          "w4action",
+          "w1",
+          "w2",
+          "w3",
+          "w4",
+          "w1",
+          "w2",
+        ]);
+      });
+    });
   });
 
   describe("$watchGroup", () => {
@@ -848,17 +1883,21 @@ describe("Scope", function () {
 
       scope.a = "foo";
       scope.b = "bar";
+      scope.$digest();
       expect(logs[0]).toEqual("foo,bar >>> foo,bar");
 
       logs = [];
+      scope.$digest();
       expect(logs).toEqual([]);
 
       scope.a = "a";
+      scope.$digest();
       expect(logs[0]).toEqual("foo,bar >>> a,bar");
 
       logs = [];
       scope.a = "A";
       scope.b = "B";
+      scope.$digest();
       expect(logs[0]).toEqual("a,bar >>> A,B");
     });
 
@@ -870,12 +1909,15 @@ describe("Scope", function () {
       });
 
       scope.a = "foo";
+      scope.$digest();
       expect(logs[0]).toEqual("foo >>> foo");
 
       logs = [];
+      scope.$digest();
       expect(logs).toEqual([]);
 
       scope.a = "bar";
+      scope.$digest();
       expect(logs[0]).toEqual("foo >>> bar");
     });
 
@@ -886,9 +1928,11 @@ describe("Scope", function () {
       });
 
       expect(logs).toEqual([]);
+      scope.$digest();
       expect(logs[0]).toEqual(" >>> ");
 
       logs = [];
+      scope.$digest();
       expect(logs).toEqual([]);
     });
 
@@ -912,6 +1956,7 @@ describe("Scope", function () {
       deregisterNone();
       scope.a = "xxx";
       scope.b = "yyy";
+      scope.$digest();
       expect(logs).toEqual([]);
     });
 
@@ -1093,6 +2138,7 @@ describe("Scope", function () {
         log += "3";
       });
 
+      $rootScope.$digest();
       log = "";
     });
 
@@ -1116,6 +2162,7 @@ describe("Scope", function () {
       const spy = jasmine.createSpy("$watch spy");
       $rootScope.$watch(spy);
       $rootScope.$destroy();
+      $rootScope.$digest();
       expect(spy).not.toHaveBeenCalled();
     });
 
@@ -1127,16 +2174,19 @@ describe("Scope", function () {
 
     it("should remove first", () => {
       first.$destroy();
+      $rootScope.$digest();
       expect(log).toEqual("23");
     });
 
     it("should remove middle", () => {
       middle.$destroy();
+      $rootScope.$digest();
       expect(log).toEqual("13");
     });
 
     it("should remove last", () => {
       last.$destroy();
+      $rootScope.$digest();
       expect(log).toEqual("12");
     });
 
@@ -1150,6 +2200,7 @@ describe("Scope", function () {
     });
 
     it("should $destroy a scope only once and ignore any further destroy calls", () => {
+      $rootScope.$digest();
       expect(log).toBe("123");
 
       first.$destroy();
@@ -1173,6 +2224,27 @@ describe("Scope", function () {
       expect(logs).toEqual(["event"]);
     });
 
+    it("should decrement ancestor $$listenerCount entries", () => {
+      const EVENT = "fooEvent";
+      const spy = jasmine.createSpy("listener");
+      const firstSecond = first.$new();
+
+      firstSecond.$on(EVENT, spy);
+      firstSecond.$on(EVENT, spy);
+      middle.$on(EVENT, spy);
+
+      expect($rootScope.$$listenerCount[EVENT]).toBe(3);
+      expect(first.$$listenerCount[EVENT]).toBe(2);
+
+      firstSecond.$destroy();
+
+      expect($rootScope.$$listenerCount[EVENT]).toBe(1);
+      expect(first.$$listenerCount[EVENT]).toBeUndefined();
+
+      $rootScope.$broadcast(EVENT);
+      expect(spy).toHaveBeenCalledTimes(1);
+    });
+
     it("should do nothing when a child event listener is registered after parent's destruction", () => {
       const parent = $rootScope.$new();
       const child = parent.$new();
@@ -1215,6 +2287,20 @@ describe("Scope", function () {
       expect(called).toBe(false);
     });
 
+    it("should do nothing when $evalAsync()ing after parent's destruction", () => {
+      const parent = $rootScope.$new();
+      const child = parent.$new();
+
+      parent.$destroy();
+
+      let called = false;
+      function applyFunc() {
+        called = true;
+      }
+      child.$evalAsync(applyFunc);
+      expect(called).toBe(false);
+    });
+
     it("should preserve all (own and inherited) model properties on a destroyed scope", () => {
       // This test simulates an async task (xhr response) interacting with the scope after the scope
       // was destroyed. Since we can't abort the request, we should ensure that the task doesn't
@@ -1233,6 +2319,238 @@ describe("Scope", function () {
     });
   });
 
+  describe("$eval", () => {
+    it("should eval an expression", () => {
+      expect($rootScope.$eval("a=1")).toEqual(1);
+      expect($rootScope.a).toEqual(1);
+
+      $rootScope.$eval((self) => {
+        self.b = 2;
+      });
+      expect($rootScope.b).toEqual(2);
+    });
+
+    it("should allow passing locals to the expression", () => {
+      expect($rootScope.$eval("a+1", { a: 2 })).toBe(3);
+
+      $rootScope.$eval(
+        (scope, locals) => {
+          scope.c = locals.b + 4;
+        },
+        { b: 3 },
+      );
+      expect($rootScope.c).toBe(7);
+    });
+  });
+
+  describe("$evalAsync", () => {
+    it("should run callback before $watch", () => {
+      let log = "";
+      const child = $rootScope.$new();
+      $rootScope.$evalAsync((scope) => {
+        log += "parent.async;";
+      });
+      $rootScope.$watch("value", () => {
+        log += "parent.$digest;";
+      });
+      child.$evalAsync((scope) => {
+        log += "child.async;";
+      });
+      child.$watch("value", () => {
+        log += "child.$digest;";
+      });
+      $rootScope.$digest();
+      expect(log).toEqual(
+        "parent.async;child.async;parent.$digest;child.$digest;",
+      );
+    });
+
+    it("should not run another digest for an $$postDigest call", () => {
+      let internalWatchCount = 0;
+      let externalWatchCount = 0;
+
+      $rootScope.internalCount = 0;
+      $rootScope.externalCount = 0;
+
+      $rootScope.$evalAsync((scope) => {
+        $rootScope.internalCount++;
+      });
+
+      $rootScope.$$postDigest((scope) => {
+        $rootScope.externalCount++;
+      });
+
+      $rootScope.$watch("internalCount", (value) => {
+        internalWatchCount = value;
+      });
+      $rootScope.$watch("externalCount", (value) => {
+        externalWatchCount = value;
+      });
+
+      $rootScope.$digest();
+
+      expect(internalWatchCount).toEqual(1);
+      expect(externalWatchCount).toEqual(0);
+    });
+
+    it("should cause a $digest rerun", () => {
+      $rootScope.log = "";
+      $rootScope.value = 0;
+      $rootScope.$watch("value", () => {
+        $rootScope.log += ".";
+      });
+      $rootScope.$watch("init", () => {
+        $rootScope.$evalAsync('value = 123; log = log + "=" ');
+        expect($rootScope.value).toEqual(0);
+      });
+      $rootScope.$digest();
+      expect($rootScope.log).toEqual(".=.");
+    });
+
+    it("should run async in the same order as added", () => {
+      $rootScope.log = "";
+      $rootScope.$evalAsync("log = log + 1");
+      $rootScope.$evalAsync("log = log + 2");
+      $rootScope.$digest();
+      expect($rootScope.log).toBe("12");
+    });
+
+    it("should allow passing locals to the expression", () => {
+      $rootScope.log = "";
+      $rootScope.$evalAsync("log = log + a", { a: 1 });
+      $rootScope.$digest();
+      expect($rootScope.log).toBe("1");
+    });
+
+    it("should run async expressions in their proper context", () => {
+      const child = $rootScope.$new();
+      $rootScope.ctx = "root context";
+      $rootScope.log = "";
+      child.ctx = "child context";
+      child.log = "";
+      child.$evalAsync("log=ctx");
+      $rootScope.$digest();
+      expect($rootScope.log).toBe("");
+      expect(child.log).toBe("child context");
+    });
+
+    it("should operate only with a single queue across all child and isolate scopes", () => {
+      const childScope = $rootScope.$new();
+      const isolateScope = $rootScope.$new(true);
+
+      $rootScope.$evalAsync("rootExpression");
+      childScope.$evalAsync("childExpression");
+      isolateScope.$evalAsync("isolateExpression");
+      expect($$asyncQueue).toEqual([
+        {
+          scope: $rootScope,
+          fn: $parse("rootExpression"),
+          locals: undefined,
+        },
+        {
+          scope: childScope,
+          fn: $parse("childExpression"),
+          locals: undefined,
+        },
+        {
+          scope: isolateScope,
+          fn: $parse("isolateExpression"),
+          locals: undefined,
+        },
+      ]);
+    });
+
+    describe("auto-flushing when queueing outside of an $apply", () => {
+      it("should auto-flush the queue asynchronously and trigger digest", () => {
+        logs = [];
+        $rootScope.$evalAsync(() => {
+          logs.push("eval-ed!");
+          return "eval-ed!";
+        });
+        $rootScope.$watch(() => {
+          logs.push("digesting");
+          return "digesting";
+        });
+        expect(logs).toEqual([]);
+        setTimeout(() => {
+          expect(logs).toEqual(["eval-ed!", "digesting", "digesting"]);
+        });
+      });
+
+      it("should not trigger digest asynchronously if the queue is empty in the next tick", () => {
+        logs = [];
+        $rootScope.$evalAsync(() => {
+          logs.push("eval-ed!");
+          return "eval-ed!";
+        });
+        $rootScope.$watch(() => {
+          logs.push("digesting");
+          return "digesting";
+        });
+        expect(logs).toEqual([]);
+
+        $rootScope.$digest();
+
+        expect(logs).toEqual(["eval-ed!", "digesting", "digesting"]);
+        logs = [];
+
+        setTimeout(() => {
+          expect(logs).toEqual([]);
+        });
+      });
+
+      it("should not schedule more than one auto-flush task", () => {
+        logs = [];
+        $rootScope.$evalAsync(() => {
+          logs.push("eval-ed 1!");
+          return "eval-ed 1!";
+        });
+        $rootScope.$evalAsync(() => {
+          logs.push("eval-ed 2!");
+          return "eval-ed 2!";
+        });
+        expect(logs).toEqual([]);
+        setTimeout(() => {
+          expect(logs).toEqual(["eval-ed 1!", "eval-ed 2!"]);
+        });
+
+        setTimeout(() => {
+          expect(logs).toEqual(["eval-ed 1!", "eval-ed 2!"]);
+        });
+      });
+
+      it("should not have execution affected by an explicit $digest call", () => {
+        const scope1 = $rootScope.$new();
+        const scope2 = $rootScope.$new();
+
+        scope1.$watch("value", (value) => {
+          scope1.result = value;
+        });
+
+        scope1.$evalAsync(() => {
+          scope1.value = "bar";
+        });
+
+        expect(scope1.result).toBe(undefined);
+        scope2.$digest();
+
+        setTimeout(() => expect(scope1.result).toBe("bar"));
+      });
+    });
+
+    it("should not pass anything as `this` to scheduled functions", () => {
+      let this1 = {};
+      const this2 = (function () {
+        return this;
+      })();
+      $rootScope.$evalAsync(function () {
+        this1 = this;
+      });
+      $rootScope.$digest();
+      expect(this1).toEqual(this2);
+    });
+  });
+
   describe("$apply", () => {
     beforeEach(() => (logs = []));
 
@@ -1287,6 +2605,7 @@ describe("Scope", function () {
         $rootScope.$watch(() => {
           log += "$digest;";
         });
+        $rootScope.$digest();
         log = "";
       });
 
@@ -1436,98 +2755,714 @@ describe("Scope", function () {
       const expression = jasmine.createSpy("expr");
 
       $rootScope.$applyAsync(expression);
+      $rootScope.$digest();
       expect(expression).toHaveBeenCalled();
       expect(cancel).toHaveBeenCalled();
       expression.calls.reset();
       cancel.calls.reset();
 
       // assert that another digest won't call the function again
+      $rootScope.$digest();
       expect(expression).not.toHaveBeenCalled();
       expect(cancel).not.toHaveBeenCalled();
     });
   });
 
-  describe("$postUpdate", () => {
+  describe("$$postDigest", () => {
     beforeEach(() => (logs = []));
     it("should process callbacks as a queue (FIFO) when the scope is digested", () => {
       let signature = "";
 
-      $rootScope.$postUpdate(() => {
+      $rootScope.$$postDigest(() => {
         signature += "A";
-        $rootScope.$postUpdate(() => {
+        $rootScope.$$postDigest(() => {
           signature += "D";
         });
       });
 
-      $rootScope.$postUpdate(() => {
+      $rootScope.$$postDigest(() => {
         signature += "B";
       });
 
-      $rootScope.$postUpdate(() => {
+      $rootScope.$$postDigest(() => {
         signature += "C";
       });
 
       expect(signature).toBe("");
+      $rootScope.$digest();
       expect(signature).toBe("ABCD");
     });
 
-    it("should support $apply calls nested in $postUpdate callbacks", () => {
+    it("should support $apply calls nested in $$postDigest callbacks", () => {
       let signature = "";
 
-      $rootScope.$postUpdate(() => {
+      $rootScope.$$postDigest(() => {
         signature += "A";
       });
 
-      $rootScope.$postUpdate(() => {
+      $rootScope.$$postDigest(() => {
         signature += "B";
         $rootScope.$apply();
         signature += "D";
       });
 
-      $rootScope.$postUpdate(() => {
+      $rootScope.$$postDigest(() => {
         signature += "C";
       });
 
       expect(signature).toBe("");
+      $rootScope.$digest();
       expect(signature).toBe("ABCD");
     });
 
-    it("should run a $postUpdate call on all child scopes when a parent scope is digested", () => {
+    it("should run a $$postDigest call on all child scopes when a parent scope is digested", () => {
       const parent = $rootScope.$new();
       const child = parent.$new();
       let count = 0;
 
-      $rootScope.$postUpdate(() => {
+      $rootScope.$$postDigest(() => {
         count++;
       });
 
-      parent.$postUpdate(() => {
+      parent.$$postDigest(() => {
         count++;
       });
 
-      child.$postUpdate(() => {
+      child.$$postDigest(() => {
         count++;
       });
 
       expect(count).toBe(0);
+      $rootScope.$digest();
       expect(count).toBe(3);
     });
 
-    it("should run a $postUpdate call even if the child scope is isolated", () => {
+    it("should run a $$postDigest call even if the child scope is isolated", () => {
       const parent = $rootScope.$new();
       const child = parent.$new(true);
       let signature = "";
 
-      parent.$postUpdate(() => {
+      parent.$$postDigest(() => {
         signature += "A";
       });
 
-      child.$postUpdate(() => {
+      child.$$postDigest(() => {
         signature += "B";
       });
 
       expect(signature).toBe("");
+      $rootScope.$digest();
       expect(signature).toBe("AB");
     });
   });
+
+  describe("events", () => {
+    describe("$on", () => {
+      it("should add listener for both $emit and $broadcast events", () => {
+        logs = "";
+        const child = $rootScope.$new();
+
+        function eventFn() {
+          logs += "X";
+        }
+
+        child.$on("abc", eventFn);
+        expect(logs).toEqual("");
+
+        child.$emit("abc");
+        expect(logs).toEqual("X");
+
+        child.$broadcast("abc");
+        expect(logs).toEqual("XX");
+      });
+
+      it("should increment ancestor $$listenerCount entries", () => {
+        const child1 = $rootScope.$new();
+        const child2 = child1.$new();
+        const spy = jasmine.createSpy();
+
+        $rootScope.$on("event1", spy);
+        expect($rootScope.$$listenerCount.event1).toEqual(1);
+
+        child1.$on("event1", spy);
+        expect($rootScope.$$listenerCount.event1).toEqual(2);
+        expect(child1.$$listenerCount.event1).toEqual(1);
+
+        child2.$on("event2", spy);
+        expect($rootScope.$$listenerCount.event1).toEqual(2);
+        expect($rootScope.$$listenerCount.event2).toEqual(1);
+        expect(child1.$$listenerCount.event1).toEqual(1);
+        expect(child1.$$listenerCount.event2).toEqual(1);
+        expect(child2.$$listenerCount.event2).toEqual(1);
+      });
+
+      describe("deregistration", () => {
+        it("should return a function that deregisters the listener", () => {
+          let log = "";
+          const child = $rootScope.$new();
+          let listenerRemove;
+
+          function eventFn() {
+            log += "X";
+          }
+
+          listenerRemove = child.$on("abc", eventFn);
+          expect(log).toEqual("");
+          expect(listenerRemove).toBeDefined();
+
+          child.$emit("abc");
+          child.$broadcast("abc");
+          expect(log).toEqual("XX");
+          expect($rootScope.$$listenerCount.abc).toBe(1);
+
+          log = "";
+          listenerRemove();
+          child.$emit("abc");
+          child.$broadcast("abc");
+          expect(log).toEqual("");
+          expect($rootScope.$$listenerCount.abc).toBeUndefined();
+        });
+
+        // See issue https://github.com/angular/angular.js/issues/16135
+        it("should deallocate the listener array entry", () => {
+          const remove1 = $rootScope.$on("abc", () => {});
+          $rootScope.$on("abc", () => {});
+
+          expect($rootScope.$$listeners.get("abc").length).toBe(2);
+          expect(0 in $rootScope.$$listeners.get("abc")).toBe(true);
+
+          remove1();
+
+          expect($rootScope.$$listeners.get("abc").length).toBe(2);
+          expect(0 in $rootScope.$$listeners.get("abc")).toBe(false);
+        });
+
+        it("should call next listener after removing the current listener via its own handler", () => {
+          const listener1 = jasmine.createSpy("listener1").and.callFake(() => {
+            remove1();
+          });
+          let remove1 = $rootScope.$on("abc", listener1);
+
+          const listener2 = jasmine.createSpy("listener2");
+          const remove2 = $rootScope.$on("abc", listener2);
+
+          const listener3 = jasmine.createSpy("listener3");
+          const remove3 = $rootScope.$on("abc", listener3);
+
+          $rootScope.$broadcast("abc");
+          expect(listener1).toHaveBeenCalled();
+          expect(listener2).toHaveBeenCalled();
+          expect(listener3).toHaveBeenCalled();
+
+          listener1.calls.reset();
+          listener2.calls.reset();
+          listener3.calls.reset();
+
+          $rootScope.$broadcast("abc");
+          expect(listener1).not.toHaveBeenCalled();
+          expect(listener2).toHaveBeenCalled();
+          expect(listener3).toHaveBeenCalled();
+        });
+
+        it("should call all subsequent listeners when a previous listener is removed via a handler", () => {
+          const listener1 = jasmine.createSpy();
+          const remove1 = $rootScope.$on("abc", listener1);
+
+          const listener2 = jasmine.createSpy().and.callFake(remove1);
+          const remove2 = $rootScope.$on("abc", listener2);
+
+          const listener3 = jasmine.createSpy();
+          const remove3 = $rootScope.$on("abc", listener3);
+
+          $rootScope.$broadcast("abc");
+          expect(listener1).toHaveBeenCalled();
+          expect(listener2).toHaveBeenCalled();
+          expect(listener3).toHaveBeenCalled();
+
+          listener1.calls.reset();
+          listener2.calls.reset();
+          listener3.calls.reset();
+
+          $rootScope.$broadcast("abc");
+          expect(listener1).not.toHaveBeenCalled();
+          expect(listener2).toHaveBeenCalled();
+          expect(listener3).toHaveBeenCalled();
+        });
+
+        it("should not call listener when removed by previous", () => {
+          const listener1 = jasmine.createSpy("listener1");
+          const remove1 = $rootScope.$on("abc", listener1);
+
+          const listener2 = jasmine.createSpy("listener2").and.callFake(() => {
+            remove3();
+          });
+          const remove2 = $rootScope.$on("abc", listener2);
+
+          const listener3 = jasmine.createSpy("listener3");
+          let remove3 = $rootScope.$on("abc", listener3);
+
+          const listener4 = jasmine.createSpy("listener4");
+          const remove4 = $rootScope.$on("abc", listener4);
+
+          $rootScope.$broadcast("abc");
+          expect(listener1).toHaveBeenCalled();
+          expect(listener2).toHaveBeenCalled();
+          expect(listener3).not.toHaveBeenCalled();
+          expect(listener4).toHaveBeenCalled();
+
+          listener1.calls.reset();
+          listener2.calls.reset();
+          listener3.calls.reset();
+          listener4.calls.reset();
+
+          $rootScope.$broadcast("abc");
+          expect(listener1).toHaveBeenCalled();
+          expect(listener2).toHaveBeenCalled();
+          expect(listener3).not.toHaveBeenCalled();
+          expect(listener4).toHaveBeenCalled();
+        });
+
+        it("should decrement ancestor $$listenerCount entries", () => {
+          const child1 = $rootScope.$new();
+          const child2 = child1.$new();
+          const spy = jasmine.createSpy();
+
+          $rootScope.$on("event1", spy);
+          expect($rootScope.$$listenerCount.event1).toEqual(1);
+
+          child1.$on("event1", spy);
+          expect($rootScope.$$listenerCount.event1).toEqual(2);
+          expect(child1.$$listenerCount.event1).toEqual(1);
+
+          const deregisterEvent2Listener = child2.$on("event2", spy);
+          expect($rootScope.$$listenerCount.event1).toEqual(2);
+          expect($rootScope.$$listenerCount.event2).toEqual(1);
+          expect(child1.$$listenerCount.event1).toEqual(1);
+          expect(child1.$$listenerCount.event2).toEqual(1);
+          expect(child2.$$listenerCount.event2).toEqual(1);
+
+          deregisterEvent2Listener();
+
+          expect($rootScope.$$listenerCount.event1).toEqual(2);
+          expect(child1.$$listenerCount.event1).toEqual(1);
+          expect(child2.$$listenerCount).toBeTruthy();
+        });
+
+        it("should not decrement $$listenerCount when called second time", () => {
+          const child = $rootScope.$new();
+          const listener1Spy = jasmine.createSpy();
+          const listener2Spy = jasmine.createSpy();
+
+          child.$on("abc", listener1Spy);
+          expect($rootScope.$$listenerCount.abc).toEqual(1);
+          expect(child.$$listenerCount.abc).toEqual(1);
+
+          const deregisterEventListener = child.$on("abc", listener2Spy);
+          expect($rootScope.$$listenerCount.abc).toEqual(2);
+          expect(child.$$listenerCount.abc).toEqual(2);
+
+          deregisterEventListener();
+
+          expect($rootScope.$$listenerCount.abc).toEqual(1);
+          expect(child.$$listenerCount.abc).toEqual(1);
+
+          deregisterEventListener();
+
+          expect($rootScope.$$listenerCount.abc).toEqual(1);
+          expect(child.$$listenerCount.abc).toEqual(1);
+        });
+      });
+    });
+
+    describe("$emit", () => {
+      let log;
+      let child;
+      let grandChild;
+      let greatGrandChild;
+
+      function logger(event) {
+        log += `${event.currentScope.id}>`;
+      }
+
+      beforeEach(() => {
+        log = "";
+        logs = [];
+        child = $rootScope.$new();
+        grandChild = child.$new();
+        greatGrandChild = grandChild.$new();
+
+        $rootScope.id = 0;
+        child.id = 1;
+        grandChild.id = 2;
+        greatGrandChild.id = 3;
+
+        $rootScope.$on("myEvent", logger);
+        child.$on("myEvent", logger);
+        grandChild.$on("myEvent", logger);
+        greatGrandChild.$on("myEvent", logger);
+      });
+
+      it("should bubble event up to the root scope", () => {
+        grandChild.$emit("myEvent");
+        expect(log).toEqual("2>1>0>");
+      });
+
+      it("should allow all events on the same scope to run even if stopPropagation is called", () => {
+        child.$on("myEvent", logger);
+        grandChild.$on("myEvent", (e) => {
+          e.stopPropagation();
+        });
+        grandChild.$on("myEvent", logger);
+        grandChild.$on("myEvent", logger);
+        grandChild.$emit("myEvent");
+        expect(log).toEqual("2>2>2>");
+      });
+
+      it("should dispatch exceptions to the $exceptionHandler", () => {
+        child.$on("myEvent", () => {
+          throw "bubbleException";
+        });
+        grandChild.$emit("myEvent");
+        expect(log).toEqual("2>1>0>");
+        expect(logs).toEqual(["bubbleException"]);
+      });
+
+      it("should allow stopping event propagation", () => {
+        child.$on("myEvent", (event) => {
+          event.stopPropagation();
+        });
+        grandChild.$emit("myEvent");
+        expect(log).toEqual("2>1>");
+      });
+
+      it("should forward method arguments", () => {
+        child.$on("abc", (event, arg1, arg2) => {
+          expect(event.name).toBe("abc");
+          expect(arg1).toBe("arg1");
+          expect(arg2).toBe("arg2");
+        });
+        child.$emit("abc", "arg1", "arg2");
+      });
+
+      it("should allow removing event listener inside a listener on $emit", () => {
+        const spy1 = jasmine.createSpy("1st listener");
+        const spy2 = jasmine.createSpy("2nd listener");
+        const spy3 = jasmine.createSpy("3rd listener");
+
+        const remove1 = child.$on("evt", spy1);
+        const remove2 = child.$on("evt", spy2);
+        const remove3 = child.$on("evt", spy3);
+
+        spy1.and.callFake(remove1);
+
+        expect(child.$$listeners.get("evt").length).toBe(3);
+
+        // should call all listeners and remove 1st
+        child.$emit("evt");
+        expect(spy1).toHaveBeenCalled();
+        expect(spy2).toHaveBeenCalled();
+        expect(spy3).toHaveBeenCalled();
+        expect(child.$$listeners.get("evt").length).toBe(3); // cleanup will happen on next $emit
+
+        spy1.calls.reset();
+        spy2.calls.reset();
+        spy3.calls.reset();
+
+        // should call only 2nd because 1st was already removed and 2nd removes 3rd
+        spy2.and.callFake(remove3);
+        child.$emit("evt");
+        expect(spy1).not.toHaveBeenCalled();
+        expect(spy2).toHaveBeenCalled();
+        expect(spy3).not.toHaveBeenCalled();
+        expect(child.$$listeners.get("evt").length).toBe(1);
+      });
+
+      it("should allow removing event listener inside a listener on $broadcast", () => {
+        const spy1 = jasmine.createSpy("1st listener");
+        const spy2 = jasmine.createSpy("2nd listener");
+        const spy3 = jasmine.createSpy("3rd listener");
+
+        const remove1 = child.$on("evt", spy1);
+        const remove2 = child.$on("evt", spy2);
+        const remove3 = child.$on("evt", spy3);
+
+        spy1.and.callFake(remove1);
+
+        expect(child.$$listeners.get("evt").length).toBe(3);
+
+        // should call all listeners and remove 1st
+        child.$broadcast("evt");
+        expect(spy1).toHaveBeenCalled();
+        expect(spy2).toHaveBeenCalled();
+        expect(spy3).toHaveBeenCalled();
+        expect(child.$$listeners.get("evt").length).toBe(3); // cleanup will happen on next $broadcast
+
+        spy1.calls.reset();
+        spy2.calls.reset();
+        spy3.calls.reset();
+
+        // should call only 2nd because 1st was already removed and 2nd removes 3rd
+        spy2.and.callFake(remove3);
+        child.$broadcast("evt");
+        expect(spy1).not.toHaveBeenCalled();
+        expect(spy2).toHaveBeenCalled();
+        expect(spy3).not.toHaveBeenCalled();
+        expect(child.$$listeners.get("evt").length).toBe(1);
+      });
+
+      describe("event object", () => {
+        it("should have methods/properties", () => {
+          let eventFired = false;
+
+          child.$on("myEvent", (e) => {
+            expect(e.targetScope).toBe(grandChild);
+            expect(e.currentScope).toBe(child);
+            expect(e.name).toBe("myEvent");
+            eventFired = true;
+          });
+          grandChild.$emit("myEvent");
+          expect(eventFired).toBe(true);
+        });
+
+        it("should have its `currentScope` property set to null after emit", () => {
+          let event;
+
+          child.$on("myEvent", (e) => {
+            event = e;
+          });
+          grandChild.$emit("myEvent");
+
+          expect(event.currentScope).toBe(null);
+          expect(event.targetScope).toBe(grandChild);
+          expect(event.name).toBe("myEvent");
+        });
+
+        it("should have preventDefault method and defaultPrevented property", () => {
+          let event = grandChild.$emit("myEvent");
+          expect(event.defaultPrevented).toBe(false);
+
+          child.$on("myEvent", (event) => {
+            event.preventDefault();
+          });
+          event = grandChild.$emit("myEvent");
+          expect(event.defaultPrevented).toBe(true);
+          expect(event.currentScope).toBe(null);
+        });
+      });
+    });
+
+    describe("$broadcast", () => {
+      describe("event propagation", () => {
+        let log;
+        let child1;
+        let child2;
+        let child3;
+        let grandChild11;
+        let grandChild21;
+        let grandChild22;
+        let grandChild23;
+        let greatGrandChild211;
+
+        function logger(event) {
+          log += `${event.currentScope.id}>`;
+        }
+
+        beforeEach(() => {
+          log = "";
+          child1 = $rootScope.$new();
+          child2 = $rootScope.$new();
+          child3 = $rootScope.$new();
+          grandChild11 = child1.$new();
+          grandChild21 = child2.$new();
+          grandChild22 = child2.$new();
+          grandChild23 = child2.$new();
+          greatGrandChild211 = grandChild21.$new();
+
+          $rootScope.id = 0;
+          child1.id = 1;
+          child2.id = 2;
+          child3.id = 3;
+          grandChild11.id = 11;
+          grandChild21.id = 21;
+          grandChild22.id = 22;
+          grandChild23.id = 23;
+          greatGrandChild211.id = 211;
+
+          $rootScope.$on("myEvent", logger);
+          child1.$on("myEvent", logger);
+          child2.$on("myEvent", logger);
+          child3.$on("myEvent", logger);
+          grandChild11.$on("myEvent", logger);
+          grandChild21.$on("myEvent", logger);
+          grandChild22.$on("myEvent", logger);
+          grandChild23.$on("myEvent", logger);
+          greatGrandChild211.$on("myEvent", logger);
+
+          //          R
+          //       /  |   \
+          //     1    2    3
+          //    /   / | \
+          //   11  21 22 23
+          //       |
+          //      211
+        });
+
+        it("should broadcast an event from the root scope", () => {
+          $rootScope.$broadcast("myEvent");
+          expect(log).toBe("0>1>11>2>21>211>22>23>3>");
+        });
+
+        it("should broadcast an event from a child scope", () => {
+          child2.$broadcast("myEvent");
+          expect(log).toBe("2>21>211>22>23>");
+        });
+
+        it("should broadcast an event from a leaf scope with a sibling", () => {
+          grandChild22.$broadcast("myEvent");
+          expect(log).toBe("22>");
+        });
+
+        it("should broadcast an event from a leaf scope without a sibling", () => {
+          grandChild23.$broadcast("myEvent");
+          expect(log).toBe("23>");
+        });
+
+        it("should not not fire any listeners for other events", () => {
+          $rootScope.$broadcast("fooEvent");
+          expect(log).toBe("");
+        });
+
+        it("should not descend past scopes with a $$listerCount of 0 or undefined", () => {
+          const EVENT = "fooEvent";
+          const spy = jasmine.createSpy("listener");
+
+          // Precondition: There should be no listeners for fooEvent.
+          expect($rootScope.$$listenerCount[EVENT]).toBeUndefined();
+
+          // Add a spy listener to a child scope.
+          $rootScope.$$childHead.$$listeners[EVENT] = [spy];
+
+          // $rootScope's count for 'fooEvent' is undefined, so spy should not be called.
+          $rootScope.$broadcast(EVENT);
+          expect(spy).not.toHaveBeenCalled();
+        });
+
+        it("should return event object", () => {
+          const result = child1.$broadcast("some");
+
+          expect(result).toBeDefined();
+          expect(result.name).toBe("some");
+          expect(result.targetScope).toBe(child1);
+        });
+      });
+
+      describe("listener", () => {
+        it("should receive event object", () => {
+          const scope = $rootScope;
+          const child = scope.$new();
+          let eventFired = false;
+
+          child.$on("fooEvent", (event) => {
+            eventFired = true;
+            expect(event.name).toBe("fooEvent");
+            expect(event.targetScope).toBe(scope);
+            expect(event.currentScope).toBe(child);
+          });
+          scope.$broadcast("fooEvent");
+
+          expect(eventFired).toBe(true);
+        });
+
+        it("should have the event's `currentScope` property set to null after broadcast", () => {
+          const scope = $rootScope;
+          const child = scope.$new();
+          let event;
+
+          child.$on("fooEvent", (e) => {
+            event = e;
+          });
+          scope.$broadcast("fooEvent");
+
+          expect(event.name).toBe("fooEvent");
+          expect(event.targetScope).toBe(scope);
+          expect(event.currentScope).toBe(null);
+        });
+
+        it("should support passing messages as constargs", () => {
+          const scope = $rootScope;
+          const child = scope.$new();
+          let args;
+
+          child.$on("fooEvent", function () {
+            args = arguments;
+          });
+          scope.$broadcast("fooEvent", "do", "re", "me", "fa");
+
+          expect(args.length).toBe(5);
+          expect(sliceArgs(args, 1)).toEqual(["do", "re", "me", "fa"]);
+        });
+      });
+    });
+
+    it("should allow recursive $emit/$broadcast", () => {
+      let callCount = 0;
+      $rootScope.$on("evt", ($event, arg0) => {
+        callCount++;
+        if (arg0 !== 1234) {
+          $rootScope.$emit("evt", 1234);
+          $rootScope.$broadcast("evt", 1234);
+        }
+      });
+
+      $rootScope.$emit("evt");
+      $rootScope.$broadcast("evt");
+      expect(callCount).toBe(6);
+    });
+
+    it("should allow recursive $emit/$broadcast between parent/child", () => {
+      const child = $rootScope.$new();
+      let calls = "";
+
+      $rootScope.$on("evt", ($event, arg0) => {
+        calls += "r"; // For "root".
+        if (arg0 === "fromChild") {
+          $rootScope.$broadcast("evt", "fromRoot2");
+        }
+      });
+
+      child.$on("evt", ($event, arg0) => {
+        calls += "c"; // For "child".
+        if (arg0 === "fromRoot1") {
+          child.$emit("evt", "fromChild");
+        }
+      });
+
+      $rootScope.$broadcast("evt", "fromRoot1");
+      expect(calls).toBe("rccrrc");
+    });
+  });
+
+  describe("doc examples", () => {
+    it("should properly fire off watch listeners upon scope changes", () => {
+      // <docs tag="docs1">
+      const scope = $rootScope.$new();
+      scope.salutation = "Hello";
+      scope.name = "World";
+
+      expect(scope.greeting).toEqual(undefined);
+
+      scope.$watch("name", () => {
+        scope.greeting = `${scope.salutation} ${scope.name}!`;
+      }); // initialize the watch
+
+      expect(scope.greeting).toEqual(undefined);
+      scope.name = "Misko";
+      // still old value, since watches have not been called yet
+      expect(scope.greeting).toEqual(undefined);
+
+      scope.$digest(); // fire all  the watches
+      expect(scope.greeting).toEqual("Hello Misko!");
+      // </docs>
+    });
+  });
 });