@angular-wave/angular.ts 0.4.4 → 0.4.6

package/src/directive/attrs/src.spec.js

@@ -24,6 +24,7 @@ describe("ngSrc", () => {
     it("should not result empty string in img src", () => {
       $scope.image = {};
       element = $compile('<img ng-src="{{image.url}}">')($scope);
+      $scope.$digest();
       expect(element.attr("src")).not.toBe("");
       expect(element.attr("src")).toBeUndefined();
     });
@@ -31,17 +32,20 @@ describe("ngSrc", () => {
     it("should sanitize interpolated url", () => {
       $scope.imageUrl = "javascript:alert(1);";
       element = $compile('<img ng-src="{{imageUrl}}">')($scope);
+      $scope.$digest();
       expect(element.attr("src")).toBe("unsafe:javascript:alert(1);");
     });
 
     it("should sanitize non-interpolated url", () => {
       element = $compile('<img ng-src="javascript:alert(1);">')($scope);
+      $scope.$digest();
       expect(element.attr("src")).toBe("unsafe:javascript:alert(1);");
     });
 
     it("should interpolate the expression and bind to src with raw same-domain value", () => {
       element = $compile('<img ng-src="{{id}}"></img>')($scope);
 
+      $scope.$digest();
       expect(element.attr("src")).toBeUndefined();
 
       $scope.$apply(() => {
@@ -63,11 +67,13 @@ describe("ngSrc", () => {
       $scope.imageUrl = "dynamic";
       element = $compile('<img ng-src="{{imageUrl}}" src="static">')($scope);
       expect(element.attr("src")).toBe("static");
+      $scope.$digest();
       expect(element.attr("src")).toBe("dynamic");
       dealoc(element);
 
       element = $compile('<img src="static" ng-src="{{imageUrl}}">')($scope);
       expect(element.attr("src")).toBe("static");
+      $scope.$digest();
       expect(element.attr("src")).toBe("dynamic");
     });
   });
@@ -129,6 +135,7 @@ describe("ngSrc", () => {
     it("should interpolate the expression and bind to src with a trusted value", () => {
       element = $compile('<iframe ng-src="{{id}}"></iframe>')($scope);
 
+      $scope.$digest();
       expect(element.attr("src")).toBeUndefined();
 
       $scope.$apply(() => {

package/src/directive/bind/bind.spec.js

@@ -35,16 +35,20 @@ describe("ng-bind", () => {
       element = $compile('<div ng-bind="a"></div>')($rootScope);
       expect(element.text()).toEqual("");
       $rootScope.a = "misko";
+      $rootScope.$digest();
       expect(element.text()).toEqual("misko");
     });
 
     it("should set text to blank if undefined", () => {
       element = $compile('<div ng-bind="a"></div>')($rootScope);
       $rootScope.a = "misko";
+      $rootScope.$digest();
       expect(element.text()).toEqual("misko");
       $rootScope.a = undefined;
+      $rootScope.$digest();
       expect(element.text()).toEqual("");
       $rootScope.a = null;
+      $rootScope.$digest();
       expect(element.text()).toEqual("");
     });
 
@@ -57,6 +61,7 @@ describe("ng-bind", () => {
           '<span ng-bind="false"></span>' +
           "</div>",
       )($rootScope);
+      $rootScope.$digest();
       expect(element.text()).toEqual("-0false");
     });
 
@@ -69,6 +74,7 @@ describe("ng-bind", () => {
         () => {
           $rootScope.value = prop[0];
           element = $compile('<div ng-bind="value"></div>')($rootScope);
+          $rootScope.$digest();
           expect(element.text()).toEqual(prop[1]);
         };
       });
@@ -81,18 +87,21 @@ describe("ng-bind", () => {
         },
       };
       element = $compile('<div ng-bind="value"></div>')($rootScope);
+      $rootScope.$digest();
       expect(element.text()).toEqual("foo");
     });
 
     it("should NOT use toString on array objects", () => {
       $rootScope.value = [];
       element = $compile('<div ng-bind="value"></div>')($rootScope);
+      $rootScope.$digest();
       expect(element.text()).toEqual("[]");
     });
 
     it("should NOT use toString on Date objects", () => {
       $rootScope.value = new Date(2014, 10, 10, 0, 0, 0);
       element = $compile('<div ng-bind="value"></div>')($rootScope);
+      $rootScope.$digest();
       expect(element.text()).toBe(JSON.stringify($rootScope.value));
       expect(element.text()).not.toEqual($rootScope.value.toString());
     });
@@ -101,9 +110,11 @@ describe("ng-bind", () => {
       element = $compile('<div ng-bind="::a"></div>')($rootScope);
       $rootScope.a = "lucas";
       expect($rootScope.$$watchers.length).toEqual(1);
+      $rootScope.$digest();
       expect(element.text()).toEqual("lucas");
       expect($rootScope.$$watchers.length).toEqual(0);
       $rootScope.a = undefined;
+      $rootScope.$digest();
       expect(element.text()).toEqual("lucas");
     });
 
@@ -115,8 +126,10 @@ describe("ng-bind", () => {
         }
       });
       $rootScope.a = "foo";
+      $rootScope.$digest();
       expect(element.text()).toEqual("bar");
       $rootScope.a = undefined;
+      $rootScope.$digest();
       expect(element.text()).toEqual("bar");
     });
 
@@ -128,10 +141,13 @@ describe("ng-bind", () => {
         }
       });
       $rootScope.a = "foo";
+      $rootScope.$digest();
       expect(element.text()).toEqual("");
       $rootScope.a = "bar";
+      $rootScope.$digest();
       expect(element.text()).toEqual("bar");
       $rootScope.a = "man";
+      $rootScope.$digest();
       expect(element.text()).toEqual("bar");
     });
   });
@@ -142,6 +158,7 @@ describe("ng-bind", () => {
         $rootScope,
       );
       $rootScope.name = "Misko";
+      $rootScope.$digest();
       expect(element.text()).toEqual("Hello Misko!");
     });
 
@@ -151,10 +168,12 @@ describe("ng-bind", () => {
       )($rootScope);
       $rootScope.name = "Misko";
       expect($rootScope.$$watchers.length).toEqual(2);
+      $rootScope.$digest();
       expect(element.text()).toEqual(" Misko!");
       expect($rootScope.$$watchers.length).toEqual(1);
       $rootScope.hello = "Hello";
       $rootScope.name = "Lucas";
+      $rootScope.$digest();
       expect(element.text()).toEqual("Hello Misko!");
       expect($rootScope.$$watchers.length).toEqual(0);
     });
@@ -163,6 +182,8 @@ describe("ng-bind", () => {
       element = $compile('<pre>{{ {key:"value", $$key:"hide"}  }}</pre>')(
         $rootScope,
       );
+      $rootScope.$digest();
+
       expect(JSON.parse(element.text())).toEqual({ key: "value" });
     });
   });
@@ -171,6 +192,7 @@ describe("ng-bind", () => {
     it("should complain about accidental use of interpolation", () => {
       expect(() => {
         $compile('<div ng-bind-html="{{myHtml}}"></div>');
+        $rootScope.$digest();
       }).toThrowError(/syntax/);
     });
 
@@ -203,14 +225,17 @@ describe("ng-bind", () => {
       it("should set html", () => {
         element = $compile('<div ng-bind-html="html"></div>')($rootScope);
         $rootScope.html = '<div onclick="">hello</div>';
+        $rootScope.$digest();
         expect(element.html()).toEqual('<div onclick="">hello</div>');
       });
 
       it("should update html", () => {
         element = $compile('<div ng-bind-html="html"></div>')($rootScope);
         $rootScope.html = "hello";
+        $rootScope.$digest();
         expect(element.html()).toEqual("hello");
         $rootScope.html = "goodbye";
+        $rootScope.$digest();
         expect(element.html()).toEqual("goodbye");
       });
 
@@ -218,9 +243,11 @@ describe("ng-bind", () => {
         element = $compile('<div ng-bind-html="::html"></div>')($rootScope);
         $rootScope.html = '<div onclick="">hello</div>';
         expect($rootScope.$$watchers.length).toEqual(1);
+        $rootScope.$digest();
         expect(element.text()).toEqual("hello");
         expect($rootScope.$$watchers.length).toEqual(0);
         $rootScope.html = '<div onclick="">hello</div>';
+        $rootScope.$digest();
         expect(element.text()).toEqual("hello");
       });
     });
@@ -255,14 +282,17 @@ describe("ng-bind", () => {
       it("should set html for trusted values", () => {
         element = $compile('<div ng-bind-html="html"></div>')($rootScope);
         $rootScope.html = $sce.trustAsHtml('<div onclick="">hello</div>');
+        $rootScope.$digest();
         expect(element.html()).toEqual('<div onclick="">hello</div>');
       });
 
       it("should update html", () => {
         element = $compile('<div ng-bind-html="html"></div>')(scope);
         scope.html = $sce.trustAsHtml("hello");
+        scope.$digest();
         expect(element.html()).toEqual("hello");
         scope.html = $sce.trustAsHtml("goodbye");
+        scope.$digest();
         expect(element.html()).toEqual("goodbye");
       });
 
@@ -274,6 +304,7 @@ describe("ng-bind", () => {
         $rootScope.getHtml = function () {
           return $sce.trustAsHtml('<div onclick="">hello</div>');
         };
+        $rootScope.$digest();
         expect(element.html()).toEqual('<div onclick="">hello</div>');
       });
 
@@ -330,8 +361,10 @@ describe("ng-bind", () => {
           $rootScope.getHtml = function () {
             return $sce.trustAsHtml(html);
           };
+          $rootScope.$digest();
           expect(element.html()).toEqual("hello");
           html = "goodbye";
+          $rootScope.$digest();
           expect(element.html()).toEqual("goodbye");
         };
       });

package/src/directive/bind/bing-html.spec.js

@@ -16,6 +16,7 @@ describe("ngBindHtml", () => {
   it("should set html", () => {
     const element = $compile('<div ng-bind-html="html"></div>')($rootScope);
     $rootScope.html = "<div>hello</div>";
+    $rootScope.$digest();
     expect(element.html()).toEqual("<div>hello</div>");
   });
 
@@ -24,9 +25,11 @@ describe("ngBindHtml", () => {
 
     [null, undefined, ""].forEach((val) => {
       $rootScope.html = "some val";
+      $rootScope.$digest();
       expect(element.html()).toEqual("some val");
 
       $rootScope.html = val;
+      $rootScope.$digest();
       expect(element.html()).toEqual("");
     });
   });

package/src/directive/class/class.js

@@ -47,7 +47,7 @@ function classDirective(name, selector) {
           if (hasAnimate(element[0])) {
             attr.$addClass(classString);
           } else {
-            scope.$postUpdate(() => {
+            scope.$$postDigest(() => {
               if (classString !== "") {
                 element[0].classList.add(...classString.trim().split(" "));
               }
@@ -60,7 +60,7 @@ function classDirective(name, selector) {
           if (hasAnimate(element[0])) {
             attr.$removeClass(classString);
           } else {
-            scope.$postUpdate(() => {
+            scope.$$postDigest(() => {
               if (classString !== "") {
                 element[0].classList.remove(...classString.trim().split(" "));
               }
@@ -82,7 +82,7 @@ function classDirective(name, selector) {
             attr.$addClass(toAddString);
             attr.$removeClass(toRemoveString);
           } else {
-            scope.$postUpdate(() => {
+            scope.$$postDigest(() => {
               if (toAddString !== "") {
                 element[0].classList.add(...toAddString.trim().split(" "));
               }

package/src/directive/class/class.spec.js

@@ -27,15 +27,18 @@ describe("ngClass", () => {
       $rootScope,
     );
     $rootScope.dynClass = "A";
+    $rootScope.$digest();
     expect(element[0].classList.contains("existing")).toBe(true);
     expect(element[0].classList.contains("A")).toBe(true);
 
     $rootScope.dynClass = "B";
+    $rootScope.$digest();
     expect(element[0].classList.contains("existing")).toBe(true);
     expect(element[0].classList.contains("A")).toBe(false);
     expect(element[0].classList.contains("B")).toBe(true);
 
     delete $rootScope.dynClass;
+    $rootScope.$digest();
     expect(element[0].classList.contains("existing")).toBe(true);
     expect(element[0].classList.contains("A")).toBe(false);
     expect(element[0].classList.contains("B")).toBe(false);
@@ -50,18 +53,21 @@ describe("ngClass", () => {
       hasOwnProperty: true,
       isPrototypeOf: true,
     };
+    $rootScope.$digest();
     expect(element[0].classList.contains("existing")).toBe(true);
     expect(element[0].classList.contains("watch")).toBe(true);
     expect(element[0].classList.contains("hasOwnProperty")).toBe(true);
     expect(element[0].classList.contains("isPrototypeOf")).toBe(true);
 
     $rootScope.dynClass.watch = false;
+    $rootScope.$digest();
     expect(element[0].classList.contains("existing")).toBe(true);
     expect(element[0].classList.contains("watch")).toBe(false);
     expect(element[0].classList.contains("hasOwnProperty")).toBe(true);
     expect(element[0].classList.contains("isPrototypeOf")).toBe(true);
 
     delete $rootScope.dynClass;
+    $rootScope.$digest();
     expect(element[0].classList.contains("existing")).toBe(true);
     expect(element[0].classList.contains("watch")).toBe(false);
     expect(element[0].classList.contains("hasOwnProperty")).toBe(false);
@@ -72,6 +78,7 @@ describe("ngClass", () => {
     element = $compile(
       "<div class=\"existing\" ng-class=\"['A', 'B']\"></div>",
     )($rootScope);
+    $rootScope.$digest();
     expect(element[0].classList.contains("existing")).toBeTruthy();
     expect(element[0].classList.contains("A")).toBeTruthy();
     expect(element[0].classList.contains("B")).toBeTruthy();
@@ -87,6 +94,7 @@ describe("ngClass", () => {
           "</div>",
       )($rootScope);
       $rootScope.conditionA = true;
+      $rootScope.$digest();
       expect(element[0].classList.contains("existing")).toBeTruthy();
       expect(element[0].classList.contains("A")).toBeTruthy();
       expect(element[0].classList.contains("B")).toBeFalsy();
@@ -95,6 +103,7 @@ describe("ngClass", () => {
       $rootScope.conditionB = function () {
         return true;
       };
+      $rootScope.$digest();
       expect(element[0].classList.contains("existing")).toBeTruthy();
       expect(element[0].classList.contains("A")).toBeTruthy();
       expect(element[0].classList.contains("B")).toBeTruthy();
@@ -104,6 +113,7 @@ describe("ngClass", () => {
 
   it("should not break when passed non-string/array/object, truthy values", () => {
     element = $compile('<div ng-class="42"></div>')($rootScope);
+    $rootScope.$digest();
     expect(element[0].classList.contains("42")).toBeTruthy();
   });
 
@@ -111,19 +121,23 @@ describe("ngClass", () => {
     element = $compile(
       "<div class=\"existing\" ng-class=\"['A', {'B': condition}]\"></div>",
     )($rootScope);
+    $rootScope.$digest();
     expect(element[0].classList.contains("existing")).toBeTruthy();
     expect(element[0].classList.contains("A")).toBeTruthy();
     expect(element[0].classList.contains("B")).toBeFalsy();
     $rootScope.condition = true;
+    $rootScope.$digest();
     expect(element[0].classList.contains("B")).toBeTruthy();
   });
 
   it("should remove classes when the referenced object is the same but its property is changed", () => {
     element = $compile('<div ng-class="classes"></div>')($rootScope);
     $rootScope.classes = { A: true, B: true };
+    $rootScope.$digest();
     expect(element[0].classList.contains("A")).toBeTruthy();
     expect(element[0].classList.contains("B")).toBeTruthy();
     $rootScope.classes.A = false;
+    $rootScope.$digest();
     expect(element[0].classList.contains("A")).toBeFalsy();
     expect(element[0].classList.contains("B")).toBeTruthy();
   });
@@ -132,6 +146,7 @@ describe("ngClass", () => {
     element = $compile('<div class="existing" ng-class="\'A B\'"></div>')(
       $rootScope,
     );
+    $rootScope.$digest();
     expect(element[0].classList.contains("existing")).toBeTruthy();
     expect(element[0].classList.contains("A")).toBeTruthy();
     expect(element[0].classList.contains("B")).toBeTruthy();
@@ -141,6 +156,7 @@ describe("ngClass", () => {
     element = $compile(
       "<div class=\"existing\" ng-class=\"['A B', 'C']\"></div>",
     )($rootScope);
+    $rootScope.$digest();
     expect(element[0].classList.contains("existing")).toBeTruthy();
     expect(element[0].classList.contains("A")).toBeTruthy();
     expect(element[0].classList.contains("B")).toBeTruthy();
@@ -152,11 +168,14 @@ describe("ngClass", () => {
       $rootScope,
     );
     $rootScope.dynClass = "A";
+    $rootScope.$digest();
     expect(element[0].classList.contains("existing")).toBe(true);
 
     // add extra class, change model and eval
     element[0].classList.add("newClass");
     $rootScope.dynClass = "B";
+    $rootScope.$digest();
+
     expect(element[0].classList.contains("existing")).toBe(true);
     expect(element[0].classList.contains("B")).toBe(true);
     expect(element[0].classList.contains("newClass")).toBe(true);
@@ -165,11 +184,14 @@ describe("ngClass", () => {
   it('should preserve class added post compilation without pre-existing classes"', () => {
     element = $compile('<div ng-class="dynClass"></div>')($rootScope);
     $rootScope.dynClass = "A";
+    $rootScope.$digest();
     expect(element[0].classList.contains("A")).toBe(true);
 
     // add extra class, change model and eval
     element[0].classList.add("newClass");
     $rootScope.dynClass = "B";
+    $rootScope.$digest();
+
     expect(element[0].classList.contains("B")).toBe(true);
     expect(element[0].classList.contains("newClass")).toBe(true);
   });
@@ -179,7 +201,9 @@ describe("ngClass", () => {
       '<div class="ui-panel ui-selected" ng-class="dynCls"></div>',
     )($rootScope);
     $rootScope.dynCls = "panel";
+    $rootScope.$digest();
     $rootScope.dynCls = "foo";
+    $rootScope.$digest();
     expect(element[0].className).toBe("ui-panel ui-selected foo");
   });
 
@@ -188,6 +212,7 @@ describe("ngClass", () => {
       $rootScope,
     );
     $rootScope.dynCls = "panel";
+    $rootScope.$digest();
     expect(element[0].className).toBe("panel bar");
   });
 
@@ -196,26 +221,32 @@ describe("ngClass", () => {
       $rootScope,
     );
     $rootScope.dynCls = "panel";
+    $rootScope.$digest();
     $rootScope.dynCls = "window";
+    $rootScope.$digest();
     expect(element[0].className).toBe("bar window");
   });
 
   it("should remove classes even if they were added by another code", () => {
     element = $compile('<div ng-class="dynCls"></div>')($rootScope);
     $rootScope.dynCls = "foo";
+    $rootScope.$digest();
     element[0].classList.add("foo");
     $rootScope.dynCls = "";
+    $rootScope.$digest();
   });
 
   it("should convert undefined and null values to an empty string", () => {
     element = $compile('<div ng-class="dynCls"></div>')($rootScope);
     $rootScope.dynCls = [undefined, null];
+    $rootScope.$digest();
   });
 
   it("should ngClass odd/even", () => {
     element = $compile(
       '<ul><li ng-repeat="i in [0,1]" class="existing" ng-class-odd="\'odd\'" ng-class-even="\'even\'"></li><ul>',
     )($rootScope);
+    $rootScope.$digest();
     const e1 = JQLite(element[0].childNodes[1]);
     const e2 = JQLite(element[0].childNodes[3]);
     expect(e1[0].classList.contains("existing")).toBeTruthy();
@@ -252,6 +283,8 @@ describe("ngClass", () => {
         "</li>" +
         "<ul>",
     )($rootScope);
+    $rootScope.$digest();
+
     const e1 = element.children().eq(0)[0];
     const e2 = element.children().eq(1)[0];
     const e3 = element.children().eq(2)[0];
@@ -271,6 +304,8 @@ describe("ngClass", () => {
     element = $compile(
       "<div ng-class=\"{'same yes': test, 'same no': !test}\"></div>",
     )($rootScope)[0];
+    $rootScope.$digest();
+
     expect(element).toHaveClass("same");
     expect(element).not.toHaveClass("yes");
     expect(element).toHaveClass("no");
@@ -387,6 +422,7 @@ describe("ngClass", () => {
       $rootScope.foo = false;
     });
     element = $compile('<div ng-class="{foo:foo}"></div>')($rootScope);
+    $rootScope.$digest();
     expect(element[0].classList.contains("foo")).toBe(false);
   });
 
@@ -398,7 +434,11 @@ describe("ngClass", () => {
         "<ul>",
     )($rootScope);
     $rootScope.items = ["b", "c", "d"];
+    $rootScope.$digest();
+
     $rootScope.items.unshift("a");
+    $rootScope.$digest();
+
     const e1 = JQLite(element[0].childNodes[1]);
     const e4 = JQLite(element[0].childNodes[3]);
 
@@ -417,7 +457,11 @@ describe("ngClass", () => {
         "<ul>",
     )($rootScope);
     $rootScope.items = ["a", "b", "a"];
+    $rootScope.$digest();
+
     $rootScope.items = ["a", "a"];
+    $rootScope.$digest();
+
     const e1 = JQLite(element[0].childNodes[1]);
     const e2 = JQLite(element[0].childNodes[3]);
 
@@ -436,7 +480,11 @@ describe("ngClass", () => {
         "<ul>",
     )($rootScope);
     $rootScope.items = ["a", "b"];
+    $rootScope.$digest();
+
     $rootScope.items = ["b", "a"];
+    $rootScope.$digest();
+
     const e1 = JQLite(element[0].childNodes[1]);
     const e2 = JQLite(element[0].childNodes[3]);
 
@@ -490,9 +538,12 @@ describe("ngClass", () => {
     element = $compile('<div ng-class="classVar"></div>')($rootScope);
 
     $rootScope.classVar = [{ orange: true }];
+    $rootScope.$digest();
     expect(element[0]).toHaveClass("orange");
 
     $rootScope.classVar[0].orange = false;
+    $rootScope.$digest();
+
     expect(element[0]).not.toHaveClass("orange");
   });
 
@@ -501,9 +552,12 @@ describe("ngClass", () => {
     element = $compile('<div ng-class="[classVar]"></div>')($rootScope);
 
     $rootScope.classVar = { orange: true };
+    $rootScope.$digest();
     expect(element[0]).toHaveClass("orange");
 
     $rootScope.classVar.orange = false;
+    $rootScope.$digest();
+
     expect(element[0]).not.toHaveClass("orange");
   });
 
@@ -513,9 +567,12 @@ describe("ngClass", () => {
     );
 
     $rootScope.classVar1 = { orange: true };
+    $rootScope.$digest();
     expect(element[0]).toHaveClass("orange");
 
     $rootScope.classVar1.orange = false;
+    $rootScope.$digest();
+
     expect(element[0]).not.toHaveClass("orange");
   });
 
@@ -556,6 +613,7 @@ describe("ngClass", () => {
     $rootScope.classVar = [{ orange: true }];
     element = $compile('<div ng-class="classVar"></div>')($rootScope);
 
+    $rootScope.$digest();
     expect(element[0]).toHaveClass("orange");
 
     $rootScope.$apply("classVar[0].orange = false");
@@ -606,6 +664,8 @@ describe("ngClass", () => {
     it("should not be copied when using an expression", () => {
       element = $compile('<div ng-class="fooClass"></div>')($rootScope)[0];
       $rootScope.fooClass = { foo: veryLargeObj };
+      $rootScope.$digest();
+
       expect(element).toHaveClass("foo");
       expect(getProp).not.toHaveBeenCalled();
     });
@@ -615,6 +675,8 @@ describe("ngClass", () => {
         $rootScope,
       )[0];
       $rootScope.veryLargeObj = veryLargeObj;
+      $rootScope.$digest();
+
       expect(element).toHaveClass("foo");
       expect(getProp).not.toHaveBeenCalled();
     });
@@ -624,6 +686,8 @@ describe("ngClass", () => {
         $rootScope,
       )[0];
       $rootScope.veryLargeObj = veryLargeObj;
+      $rootScope.$digest();
+
       expect(element).toHaveClass("foo");
       expect(getProp).not.toHaveBeenCalled();
     });
@@ -633,6 +697,8 @@ describe("ngClass", () => {
         '<div ng-class="::{foo: veryLargeObj, bar: bar}"></div>',
       )($rootScope)[0];
       $rootScope.veryLargeObj = veryLargeObj;
+      $rootScope.$digest();
+
       expect(element).toHaveClass("foo");
       expect(element).not.toHaveClass("bar");
       expect(getProp).not.toHaveBeenCalled();
@@ -678,22 +744,22 @@ describe("ngClass", () => {
 //       expect($animate.queue.length).toBe(0);
 
 //       $rootScope.val = "one";
-//       ;
+//       $rootScope.$digest();
 //       expect($animate.queue.shift().event).toBe("addClass");
 //       expect($animate.queue.length).toBe(0);
 
 //       $rootScope.val = "";
-//       ;
+//       $rootScope.$digest();
 //       expect($animate.queue.shift().event).toBe("removeClass"); // only removeClass is called
 //       expect($animate.queue.length).toBe(0);
 
 //       $rootScope.val = "one";
-//       ;
+//       $rootScope.$digest();
 //       expect($animate.queue.shift().event).toBe("addClass");
 //       expect($animate.queue.length).toBe(0);
 
 //       $rootScope.val = "two";
-//       ;
+//       $rootScope.$digest();
 //       expect($animate.queue.shift().event).toBe("addClass");
 //       expect($animate.queue.shift().event).toBe("removeClass");
 //       expect($animate.queue.length).toBe(0);
@@ -734,9 +800,9 @@ describe("ngClass", () => {
 //         expect(element[0].classList.contains("crazy")).toBe(false);
 //         expect(enterComplete).toBe(false);
 
-//         ;
+//         $rootScope.$digest();
 //         $animate.flush();
-//         ;
+//         $rootScope.$digest();
 
 //         expect(element[0].classList.contains("crazy")).toBe(true);
 //         expect(enterComplete).toBe(true);
@@ -759,7 +825,7 @@ describe("ngClass", () => {
 //         '<div ng-class="{one:one, two:two, three:three}"></div>',
 //       );
 //       $compile(element)($rootScope);
-//       ;
+//       $rootScope.$digest();
 
 //       // this fires twice due to the class observer firing
 //       let item = $animate.queue.shift();
@@ -769,7 +835,7 @@ describe("ngClass", () => {
 //       expect($animate.queue.length).toBe(0);
 
 //       $rootScope.three = false;
-//       ;
+//       $rootScope.$digest();
 
 //       item = $animate.queue.shift();
 //       expect(item.event).toBe("removeClass");
@@ -779,7 +845,7 @@ describe("ngClass", () => {
 
 //       $rootScope.two = false;
 //       $rootScope.three = true;
-//       ;
+//       $rootScope.$digest();
 
 //       item = $animate.queue.shift();
 //       expect(item.event).toBe("addClass");