@angular-wave/angular.ts 0.0.9 → 0.0.11

package/test/ng/compile.spec.js

@@ -1112,15 +1112,16 @@ describe("$compile", () => {
   });
 
   describe("linking", () => {
-    it("takes a scope and attaches it to elements", () => {
-      registerDirectives("myDirective", () => {
-        return { compile: () => {} };
-      });
-      reloadModules();
-      var el = $("<div my-directive></div>");
-      $compile(el)($rootScope);
-      expect(el.data("$scope")).toBe($rootScope);
-    });
+    // THERE IS NO SCOPE ATTACHED TO ACTUAL ELEMENTS
+    // it("takes a scope and attaches it to elements", () => {
+    //   registerDirectives("myDirective", () => {
+    //     return { compile: () => {} };
+    //   });
+    //   reloadModules();
+    //   var el = $("<div my-directive></div>");
+    //   $compile(el)($rootScope);
+    //   expect(el.data("$scope")).toBe($rootScope);
+    // });
 
     it("calls directive link function with scope", () => {
       var givenScope, givenElement, givenAttrs;
@@ -1341,7 +1342,7 @@ describe("$compile", () => {
     expect(givenScope.$parent).toBe($rootScope);
   });
 
-  it("adds scope class and data for element with new scope", () => {
+  it("adds new scope", () => {
     var givenScope;
     registerDirectives("myDirective", () => {
       return {
@@ -1354,7 +1355,7 @@ describe("$compile", () => {
     reloadModules();
     var el = $("<div my-directive></div>");
     $compile(el)($rootScope);
-    expect(el.data("$scope")).toBe(givenScope);
+    expect($rootScope.$$childHead).toBe(givenScope);
   });
 
   it("creates an isolate scope when requested", () => {
@@ -1458,7 +1459,7 @@ describe("$compile", () => {
     }).toThrowError();
   });
 
-  it("adds isolate scope class and data for element with isolated scope", () => {
+  it("adds isolated scope", () => {
     var givenScope;
     registerDirectives("myDirective", () => {
       return {
@@ -1471,7 +1472,7 @@ describe("$compile", () => {
     reloadModules();
     var el = $("<div my-directive></div>");
     $compile(el)($rootScope);
-    expect(el.isolateScope()).toBe(givenScope);
+    expect($rootScope.$$childHead).toBe(givenScope);
   });
 
   it("allows observing attribute to the isolate scope", () => {
@@ -4969,10 +4970,11 @@ describe("$compile", () => {
   });
 
   describe("compile phase", () => {
-    it("should attach scope to the document node when it is compiled explicitly", () => {
-      $compile($document)($rootScope);
-      expect($document.scope()).toBe($rootScope);
-    });
+    // NO ELEMENT ATTACHMENTS
+    // it("should attach scope to the document node when it is compiled explicitly", () => {
+    //   $compile($document)($rootScope);
+    //   expect($document.scope()).toBe($rootScope);
+    // });
 
     it("should not wrap root text nodes in spans", () => {
       element = JQLite("<div>   <div>A</div>\n  <div>B</div>C\t\n  </div>");
@@ -4994,6 +4996,7 @@ describe("$compile", () => {
       // We compile the contents of element (i.e. not element itself)
       // Then delete these contents and check the cache has been reset to zero
       // Clear cache
+      // Update: THIS TEST IS IRRELEVANT IF WE DONT POLLUTE THE CACHE
       CACHE.clear();
       window.angular.module("test1", ["ng"]);
       createInjector(["test1"]).invoke(($compile) => {
@@ -5001,7 +5004,7 @@ describe("$compile", () => {
         // First with only elements at the top level
         element = JQLite("<div><div></div></div>");
         $compile(element[0].childNodes)($rootScope);
-        expect(CACHE.size).toEqual(2);
+        // expect(CACHE.size).toEqual(2);
         element.empty();
         expect(CACHE.size).toEqual(1);
 
@@ -5021,7 +5024,7 @@ describe("$compile", () => {
         // Finally with empty text nodes at the top level
         element = JQLite("<div>   \n<div></div>   </div>");
         $compile(element[0].childNodes)($rootScope);
-        expect(CACHE.size).toEqual(2);
+        //expect(CACHE.size).toEqual(2);
         element.empty();
         expect(CACHE.size).toEqual(1);
       });
@@ -6827,7 +6830,6 @@ describe("$compile", () => {
               return {
                 pre(scope, element) {
                   log.push(scope.$id);
-                  expect(element.data("$scope")).toBe(scope);
                 },
               };
             },
@@ -6839,7 +6841,6 @@ describe("$compile", () => {
               return function (scope, element) {
                 iscope = scope;
                 log.push(scope.$id);
-                expect(element.data("$isolateScopeNoTemplate")).toBe(scope);
               };
             },
           }));
@@ -6850,7 +6851,6 @@ describe("$compile", () => {
             compile() {
               return function (scope, element) {
                 log.push(scope.$id);
-                expect(element.data("$scope")).toBe(scope);
               };
             },
           }));
@@ -6861,7 +6861,6 @@ describe("$compile", () => {
             compile() {
               return function (scope, element) {
                 log.push(scope.$id);
-                expect(element.data("$scope")).toBe(scope);
               };
             },
           }));
@@ -6873,7 +6872,6 @@ describe("$compile", () => {
             compile() {
               return function (scope, element) {
                 log.push(scope.$id);
-                expect(element.data("$scope")).toBe(scope);
               };
             },
           }));
@@ -6885,7 +6883,6 @@ describe("$compile", () => {
               return function (scope, element) {
                 iscope = scope;
                 log.push(scope.$id);
-                expect(element.data("$isolateScope")).toBe(scope);
               };
             },
           }));
@@ -6897,7 +6894,6 @@ describe("$compile", () => {
               return function (scope, element) {
                 iscope = scope;
                 log.push(scope.$id);
-                expect(element.data("$isolateScope")).toBe(scope);
               };
             },
           }));
@@ -6990,7 +6986,6 @@ describe("$compile", () => {
         $rootScope.name = "Jozo";
         $rootScope.$apply();
         expect(element.text().match(/Jozo/)).toBeTruthy();
-        expect(element.find("span").scope().$id).toBeDefined();
       });
 
       it("should allow creation of new scopes for replace directives with templates", () => {
@@ -7004,7 +6999,6 @@ describe("$compile", () => {
         $rootScope.name = "Jozo";
         $rootScope.$apply();
         expect(element.text().match(/Jozo/)).toBeTruthy();
-        expect(element.find("a").scope().$id).toBeDefined();
       });
 
       it("should allow creation of new scopes for replace directives with templates in a repeater", () => {
@@ -7017,8 +7011,6 @@ describe("$compile", () => {
         $rootScope.name = "Jozo";
         $rootScope.$apply();
         expect(element.text()).toBe("Jozo|Jozo|Jozo|");
-        expect(element.find("p").scope().$id).toBeDefined();
-        expect(element.find("a").scope().$id).toBeDefined();
       });
 
       it("should allow creation of new isolated scopes for directives with templates", () => {
@@ -7075,69 +7067,55 @@ describe("$compile", () => {
       });
 
       describe("scope()/isolate() scope getters", () => {
-        describe("with no directives", () => {
-          it("should return the scope of the parent node", () => {
-            element = $compile("<div></div>")($rootScope);
-            expect(element.scope()).toBe($rootScope);
-          });
-        });
-
         describe("with new scope directives", () => {
           it("should return the new scope at the directive element", () => {
             element = $compile("<div scope></div>")($rootScope);
-            expect(element.scope().$parent).toBe($rootScope);
+            expect($rootScope.$$childHead.$parent).toBe($rootScope);
           });
 
           it("should return the new scope for children in the original template", () => {
             element = $compile("<div scope><a></a></div>")($rootScope);
-            expect(element.find("a").scope().$parent).toBe($rootScope);
+            expect($rootScope.$$childHead.$parent).toBe($rootScope);
           });
 
           it("should return the new scope for children in the directive template", () => {
             $templateCache.put("tscope.html", "<a></a>");
             element = $compile("<div tscope></div>")($rootScope);
             $rootScope.$digest();
-            expect(element.find("a").scope().$parent).toBe($rootScope);
+            expect($rootScope.$$childHead.$parent).toBe($rootScope);
           });
 
           it("should return the new scope for children in the directive sync template", () => {
             element = $compile("<div stscope></div>")($rootScope);
-            expect(element.find("span").scope().$parent).toBe($rootScope);
+            expect($rootScope.$$childHead.$parent).toBe($rootScope);
           });
         });
 
         describe("with isolate scope directives", () => {
-          it("should return the root scope for directives at the root element", () => {
-            element = $compile("<div iscope></div>")($rootScope);
-            expect(element.scope()).toBe($rootScope);
-          });
-
           it("should return the non-isolate scope at the directive element", () => {
+            expect($rootScope.$$childHead).toBeNull();
             let directiveElement;
             element = $compile("<div><div iscope></div></div>")($rootScope);
             directiveElement = element.children();
-            expect(directiveElement.scope()).toBe($rootScope);
-            expect(directiveElement.isolateScope().$parent).toBe($rootScope);
+            expect($rootScope.$$childHead.$parent).toBe($rootScope);
           });
 
           it("should return the isolate scope for children in the original template", () => {
             element = $compile("<div iscope><a></a></div>")($rootScope);
-            expect(element.find("a").scope()).toBe($rootScope); // xx
+            expect($rootScope.$$childHead.$parent).toBe($rootScope); // xx
           });
 
           it("should return the isolate scope for children in directive template", () => {
             $templateCache.put("tiscope.html", "<a></a>");
             element = $compile("<div tiscope></div>")($rootScope);
-            expect(element.isolateScope()).toBeUndefined(); // this is the current behavior, not desired feature
+            expect($rootScope.$$childHead).toBeDefined(); // ??? this is the current behavior, not desired feature
             $rootScope.$digest();
-            expect(element.find("a").scope()).toBe(element.isolateScope());
-            expect(element.isolateScope()).not.toBe($rootScope);
+            expect($rootScope.$$childHead).not.toBe($rootScope);
           });
 
           it("should return the isolate scope for children in directive sync template", () => {
             element = $compile("<div stiscope></div>")($rootScope);
-            expect(element.find("span").scope()).toBe(element.isolateScope());
-            expect(element.isolateScope()).not.toBe($rootScope);
+            expect($rootScope.$$childHead).not.toBe($rootScope);
           });
 
           it('should handle "=" bindings with same method names in Object.prototype correctly when not present', () => {
@@ -7148,8 +7126,7 @@ describe("$compile", () => {
             };
 
             expect(func).not.toThrow();
-            const scope = element.isolateScope();
-            expect(element.find("span").scope()).toBe(scope);
+            const scope = $rootScope.$$childHead;
             expect(scope).not.toBe($rootScope);
 
             // Not shadowed because optional
@@ -7171,8 +7148,7 @@ describe("$compile", () => {
             };
 
             expect(func).not.toThrow();
-            const scope = element.isolateScope();
-            expect(element.find("span").scope()).toBe(scope);
+            const scope = $rootScope.$$childHead;
             expect(scope).not.toBe($rootScope);
             expect(scope.constructor).toBe("constructor");
             expect(scope.hasOwnProperty("constructor")).toBe(true);
@@ -7342,8 +7318,7 @@ describe("$compile", () => {
           };
 
           expect(func).not.toThrow();
-          const scope = element.isolateScope();
-          expect(element.find("span").scope()).toBe(scope);
+          const scope = $rootScope.$$childHead;
           expect(scope).not.toBe($rootScope);
 
           // Does not shadow value because optional
@@ -7363,10 +7338,10 @@ describe("$compile", () => {
           };
 
           expect(func).not.toThrow();
-          expect(element.find("span").scope()).toBe(element.isolateScope());
-          expect(element.isolateScope()).not.toBe($rootScope);
-          expect(element.isolateScope().constructor).toBe("constructor");
-          expect(element.isolateScope().valueOf).toBe("valueOf");
+          const scope = $rootScope.$$childHead;
+          expect(scope).not.toBe($rootScope);
+          expect(scope.constructor).toBe("constructor");
+          expect(scope.valueOf).toBe("valueOf");
         });
 
         it('should handle "&" bindings with same method names in Object.prototype correctly when not present', () => {
@@ -7377,12 +7352,10 @@ describe("$compile", () => {
           };
 
           expect(func).not.toThrow();
-          expect(element.find("span").scope()).toBe(element.isolateScope());
-          expect(element.isolateScope()).not.toBe($rootScope);
-          expect(element.isolateScope().constructor).toBe(
-            $rootScope.constructor,
-          );
-          expect(element.isolateScope().valueOf()).toBeUndefined();
+          const scope = $rootScope.$$childHead;
+          expect(scope).not.toBe($rootScope);
+          expect(scope.constructor).toBe($rootScope.constructor);
+          expect(scope.valueOf()).toBeUndefined();
         });
 
         it('should handle "&" bindings with same method names in Object.prototype correctly when present', () => {
@@ -7399,10 +7372,10 @@ describe("$compile", () => {
           };
 
           expect(func).not.toThrow();
-          expect(element.find("span").scope()).toBe(element.isolateScope());
-          expect(element.isolateScope()).not.toBe($rootScope);
-          expect(element.isolateScope().constructor()).toBe("constructor");
-          expect(element.isolateScope().valueOf()).toBe("valueOf");
+          const scope = $rootScope.$$childHead;
+          expect(scope).not.toBe($rootScope);
+          expect(scope.constructor()).toBe("constructor");
+          expect(scope.valueOf()).toBe("valueOf");
         });
 
         it("should handle @ bindings on BOOLEAN attributes", () => {
@@ -8892,7 +8865,7 @@ describe("$compile", () => {
             }),
           });
 
-          element.isolateScope().$ctrl.prop1 = 2;
+          $rootScope.$$childHead.$ctrl.prop1 = 2;
           $rootScope.$apply("val = 2");
           expect(log.pop()).toEqual({
             prop1: jasmine.objectContaining({
@@ -9656,7 +9629,7 @@ describe("$compile", () => {
         element = $compile('<div my-component reference="num"></div>')(
           $rootScope,
         );
-        const isolateScope = element.isolateScope();
+        const isolateScope = $rootScope.$$childHead;
         expect(isolateScope.reference).toBeNaN();
 
         isolateScope.$apply((scope) => {
@@ -9670,7 +9643,7 @@ describe("$compile", () => {
         element = $compile('<div my-component reference="num"></div>')(
           $rootScope,
         );
-        const isolateScope = element.isolateScope();
+        const isolateScope = $rootScope.$$childHead;
         expect(isolateScope.reference).toBeNaN();
 
         $rootScope.$apply((scope) => {
@@ -9706,7 +9679,7 @@ describe("$compile", () => {
               'to-string="value = !value"></div>',
           )($rootScope);
         }).not.toThrow();
-        const isolateScope = element.isolateScope();
+        const isolateScope = $rootScope.$$childHead;
 
         expect(typeof isolateScope.constructor).toBe("string");
         expect(isArray(isolateScope.watch)).toBe(true);
@@ -9739,13 +9712,13 @@ describe("$compile", () => {
 
       it("should not initialize scope value if optional expression binding is not passed", () => {
         element = $compile("<div my-component></div>")($rootScope);
-        const isolateScope = element.isolateScope();
+        const isolateScope = $rootScope.$$childHead;
         expect(isolateScope.optExpr).toBeUndefined();
       });
 
       it("should not initialize scope value if optional expression binding with Object.prototype name is not passed", () => {
         element = $compile("<div my-component></div>")($rootScope);
-        const isolateScope = element.isolateScope();
+        const isolateScope = $rootScope.$$childHead;
         expect(isolateScope.constructor).toBe($rootScope.constructor);
       });
 
@@ -9753,7 +9726,7 @@ describe("$compile", () => {
         element = $compile(
           "<div my-component opt-expr=\"value = 'did!'\"></div>",
         )($rootScope);
-        const isolateScope = element.isolateScope();
+        const isolateScope = $rootScope.$$childHead;
         expect(typeof isolateScope.optExpr).toBe("function");
         expect(isolateScope.optExpr()).toBe("did!");
         expect($rootScope.value).toBe("did!");
@@ -9763,7 +9736,7 @@ describe("$compile", () => {
         element = $compile(
           "<div my-component constructor=\"value = 'did!'\"></div>",
         )($rootScope);
-        const isolateScope = element.isolateScope();
+        const isolateScope = $rootScope.$$childHead;
         expect(typeof isolateScope.constructor).toBe("function");
         expect(isolateScope.constructor()).toBe("did!");
         expect($rootScope.value).toBe("did!");
@@ -9791,7 +9764,7 @@ describe("$compile", () => {
         });
 
         element = $compile("<div test-dir></div>")($rootScope);
-        const scope = element.isolateScope();
+        const scope = $rootScope.$$childHead;
         expect(scope.ctrl.getProp()).toBe("default");
 
         $rootScope.$digest();
@@ -9820,7 +9793,7 @@ describe("$compile", () => {
         });
 
         element = $compile("<div test-dir></div>")($rootScope);
-        const scope = element.isolateScope();
+        const scope = $rootScope.$$childHead;
         expect(scope.ctrl.getProp()).toBe("default");
         $rootScope.$digest();
         expect(scope.ctrl.getProp()).toBe("default");
@@ -10696,7 +10669,7 @@ describe("$compile", () => {
               $rootScope,
             );
 
-            const isolateScope = element.isolateScope();
+            const isolateScope = $rootScope.$$childHead;
             expect(isolateScope.owRef).toBeNaN();
 
             $rootScope.num = 64;
@@ -11877,7 +11850,7 @@ describe("$compile", () => {
         element = $compile("<div foo-dir>")($rootScope);
         $rootScope.$digest();
         expect(controllerCalled).toBe(true);
-        const childScope = element.children().scope();
+        const childScope = $rootScope.$$childHead;
         expect(childScope).not.toBe($rootScope);
         expect(childScope.theCtrl).toBe(myCtrl);
       });
@@ -11935,7 +11908,7 @@ describe("$compile", () => {
         )($rootScope);
         $rootScope.$digest();
         expect(controllerCalled).toBe(true);
-        const childScope = element.children().scope();
+        const childScope = $rootScope.$$childHead;
         expect(childScope).not.toBe($rootScope);
         expect(childScope.theCtrl).not.toBe(myCtrl);
         expect(childScope.theCtrl.constructor).toBe(MyCtrl);
@@ -11995,7 +11968,7 @@ describe("$compile", () => {
         )($rootScope);
         $rootScope.$digest();
         expect(controllerCalled).toBe(true);
-        const childScope = element.children().scope();
+        const childScope = $rootScope.$$childHead;
         expect(childScope).not.toBe($rootScope);
         expect(childScope.theCtrl).not.toBe(myCtrl);
         expect(childScope.theCtrl.constructor).toBe(MyCtrl);
@@ -12026,7 +11999,7 @@ describe("$compile", () => {
           );
           initInjector("test1");
           element = $compile("<div test-dir></div>")($rootScope);
-          const scope = element.scope();
+          const scope = $rootScope.$$childHead;
           expect(scope.ctrl.getProp()).toBe("default");
 
           $rootScope.$digest();
@@ -12056,7 +12029,7 @@ describe("$compile", () => {
           );
           initInjector("test1");
           element = $compile("<div test-dir></div>")($rootScope);
-          const scope = element.isolateScope();
+          const scope = $rootScope.$$childHead;
           expect(scope.ctrl.getProp()).toBe("default");
 
           $rootScope.$digest();
@@ -12647,7 +12620,7 @@ describe("$compile", () => {
 
         element = element.children().eq(0);
         expect(element[0].checked).toBe(false);
-        element.isolateScope().model = true;
+        $rootScope.$$childHead.model = true;
         $rootScope.$digest();
         expect(element[0].checked).toBe(true);
       });
@@ -13541,19 +13514,19 @@ describe("$compile", () => {
           element = $compile(
             '<div><div ng-repeat="x in xs" ng-if="x==1">{{x}}</div></div>',
           )($rootScope);
-          expect(CACHE.size).toEqual(cacheSize + 1);
+          expect(CACHE.size).toEqual(cacheSize);
 
           $rootScope.$apply("xs = [0,1]");
-          expect(CACHE.size).toEqual(cacheSize + 2);
+          expect(CACHE.size).toEqual(cacheSize);
 
           $rootScope.$apply("xs = [0]");
-          expect(CACHE.size).toEqual(cacheSize + 1);
+          expect(CACHE.size).toEqual(cacheSize);
 
           $rootScope.$apply("xs = []");
-          expect(CACHE.size).toEqual(cacheSize + 1);
+          expect(CACHE.size).toEqual(cacheSize);
 
           element.remove();
-          expect(CACHE.size).toEqual(cacheSize + 0);
+          expect(CACHE.size).toEqual(cacheSize);
         });
 
         it('should not leak if two "element" transclusions are on the same element', () => {
@@ -13565,20 +13538,20 @@ describe("$compile", () => {
           $rootScope.$apply("xs = [0,1]");
           // At this point we have a bunch of comment placeholders but no real transcluded elements
           // So the cache only contains the root element's data
-          expect(CACHE.size).toEqual(cacheSize + 1);
+          expect(CACHE.size).toEqual(cacheSize);
 
           $rootScope.$apply("val = true");
           // Now we have two concrete transcluded elements plus some comments so two more cache items
-          expect(CACHE.size).toEqual(cacheSize + 3);
+          expect(CACHE.size).toEqual(cacheSize);
 
           $rootScope.$apply("val = false");
           // Once again we only have comments so no transcluded elements and the cache is back to just
           // the root element
-          expect(CACHE.size).toEqual(cacheSize + 1);
+          expect(CACHE.size).toEqual(cacheSize);
 
           element.remove();
           // Now we've even removed the root element along with its cache
-          expect(CACHE.size).toEqual(cacheSize + 0);
+          expect(CACHE.size).toEqual(cacheSize);
         });
 
         // it("should not leak when continuing the compilation of elements on a scope that was destroyed", () => {
@@ -13647,7 +13620,6 @@ describe("$compile", () => {
             $rootScope.$apply(`xs = [${xs}]`);
             firstRepeatedElem = element.children(".ng-scope").eq(0);
 
-            expect(firstRepeatedElem.data("$scope")).toBeDefined();
             privateData = CACHE.get(firstRepeatedElem[0][EXPANDO]);
             expect(privateData.events).toBeDefined();
 
@@ -17026,40 +16998,39 @@ describe("$compile", () => {
           "</div>",
       )($rootScope);
       $rootScope.$apply("val0 = true; val1 = true; val2 = true");
-
+      expect($rootScope.$$childHead).toBeTruthy();
+      expect($rootScope.$$childHead.$$childHead).toBeTruthy();
       // At this point we should have something like:
       //
       // <div>
       //
-      //   <!-- ngIf: val0 -->
-      //
+      //   <!---->
       //   <div ng-if-start="val0">
-      //     <!-- ngIf: val1 -->
+      //     <!---->
       //     <span ng-if="val1"></span>
-      //     <!-- end ngIf: val1 -->
+      //     <!---->
       //   </div>
       //
       //   <div ng-if-end="">
-      //     <!-- ngIf: val2 -->
+      //     <!---->
       //     <span ng-if="val2"></span>
-      //     <!-- end ngIf: val2 -->
+      //     <!---->
       //   </div>
       //
-      //   <!-- end ngIf: val0 -->
+      //   <!---->
       // </div>
-      const ngIfStartScope = element.find("div").eq(0).scope();
-      const ngIfEndScope = element.find("div").eq(1).scope();
+      // const ngIfStartScope = element.find("div").eq(0).scope();
+      // const ngIfEndScope = element.find("div").eq(1).scope();
 
-      expect(ngIfStartScope.$id).toEqual(ngIfEndScope.$id);
+      // expect(ngIfStartScope.$id).toEqual(ngIfEndScope.$id);
 
-      const ngIf1Scope = element.find("span").eq(0).scope();
-      const ngIf2Scope = element.find("span").eq(1).scope();
+      // const ngIf1Scope = element.find("span").eq(0).scope();
+      // const ngIf2Scope = element.find("span").eq(1).scope();
 
-      expect(ngIf1Scope.$id).not.toEqual(ngIf2Scope.$id);
-      expect(ngIf1Scope.$parent.$id).toEqual(ngIf2Scope.$parent.$id);
+      // expect(ngIf1Scope.$id).not.toEqual(ngIf2Scope.$id);
+      // expect(ngIf1Scope.$parent.$id).toEqual(ngIf2Scope.$parent.$id);
 
       $rootScope.$apply("val1 = false");
-
       // Now we should have something like:
       //
       // <div>
@@ -17075,9 +17046,9 @@ describe("$compile", () => {
       //   <!-- end ngIf: val0 -->
       // </div>
 
-      expect(ngIfStartScope.$$destroyed).not.toEqual(true);
-      expect(ngIf1Scope.$$destroyed).toEqual(true);
-      expect(ngIf2Scope.$$destroyed).not.toEqual(true);
+      // expect(ngIfStartScope.$$destroyed).not.toEqual(true);
+      // expect(ngIf1Scope.$$destroyed).toEqual(true);
+      // expect(ngIf2Scope.$$destroyed).not.toEqual(true);
 
       $rootScope.$apply("val0 = false");
 
@@ -17086,10 +17057,11 @@ describe("$compile", () => {
       // <div>
       //   <!-- ngIf: val0 -->
       // </div>
-
-      expect(ngIfStartScope.$$destroyed).toEqual(true);
-      expect(ngIf1Scope.$$destroyed).toEqual(true);
-      expect(ngIf2Scope.$$destroyed).toEqual(true);
+      // TODO: Until we figure out a better way of testing this
+      expect($rootScope.$$childHead).toBeNull();
+      // expect(ngIfStartScope.$$destroyed).toEqual(true);
+      // expect(ngIf1Scope.$$destroyed).toEqual(true);
+      // expect(ngIf2Scope.$$destroyed).toEqual(true);
     });
 
     it("should set up and destroy the transclusion scopes correctly", () => {
@@ -17105,7 +17077,7 @@ describe("$compile", () => {
       //   <!-- ngRepeat: val in val0 -->
       // </div>
 
-      expect(element.scope().$id).toEqual($rootScope.$id);
+      //expect(element.scope().$id).toEqual($rootScope.$id);
 
       // Now we create all the elements
       $rootScope.$apply("val0 = [1]; val1 = true; val2 = true");
@@ -17126,17 +17098,17 @@ describe("$compile", () => {
       //   <!-- end ngIf: val2 -->
       //   <!-- end ngRepeat: val in val0 -->
       // </div>
-      const ngIf1Scope = element.find("div").eq(0).scope();
-      const ngIf2Scope = element.find("div").eq(1).scope();
-      const ngRepeatScope = ngIf1Scope.$parent;
+      // const ngIf1Scope = element.find("div").eq(0).scope();
+      // const ngIf2Scope = element.find("div").eq(1).scope();
+      // const ngRepeatScope = ngIf1Scope.$parent;
 
-      expect(ngIf1Scope.$id).not.toEqual(ngIf2Scope.$id);
-      expect(ngIf1Scope.$parent.$id).toEqual(ngRepeatScope.$id);
-      expect(ngIf2Scope.$parent.$id).toEqual(ngRepeatScope.$id);
+      // expect(ngIf1Scope.$id).not.toEqual(ngIf2Scope.$id);
+      // expect(ngIf1Scope.$parent.$id).toEqual(ngRepeatScope.$id);
+      // expect(ngIf2Scope.$parent.$id).toEqual(ngRepeatScope.$id);
 
-      // What is happening here??
-      // We seem to have a repeater scope which doesn't actually match to any element
-      expect(ngRepeatScope.$parent.$id).toEqual($rootScope.$id);
+      // // What is happening here??
+      // // We seem to have a repeater scope which doesn't actually match to any element
+      // expect(ngRepeatScope.$parent.$id).toEqual($rootScope.$id);
 
       // Now remove the first ngIf element from the first item in the repeater
       $rootScope.$apply("val1 = false");
@@ -17155,9 +17127,9 @@ describe("$compile", () => {
       //   <!-- end ngRepeat: val in val0 -->
       // </div>
       //
-      expect(ngRepeatScope.$$destroyed).toEqual(false);
-      expect(ngIf1Scope.$$destroyed).toEqual(true);
-      expect(ngIf2Scope.$$destroyed).toEqual(false);
+      // expect(ngRepeatScope.$$destroyed).toEqual(false);
+      // expect(ngIf1Scope.$$destroyed).toEqual(true);
+      // expect(ngIf2Scope.$$destroyed).toEqual(false);
 
       // Now remove the second ngIf element from the first item in the repeater
       $rootScope.$apply("val2 = false");
@@ -17171,17 +17143,18 @@ describe("$compile", () => {
       //   <!-- end ngRepeat: val in val0 -->
       // </div>
 
-      expect(ngRepeatScope.$$destroyed).toEqual(false);
-      expect(ngIf1Scope.$$destroyed).toEqual(true);
-      expect(ngIf2Scope.$$destroyed).toEqual(true);
+      // expect(ngRepeatScope.$$destroyed).toEqual(false);
+      // expect(ngIf1Scope.$$destroyed).toEqual(true);
+      // expect(ngIf2Scope.$$destroyed).toEqual(true);
 
       // Finally remove the repeat items
       $rootScope.$apply("val0 = []");
 
       // Somehow this ngRepeat scope knows how to destroy itself...
-      expect(ngRepeatScope.$$destroyed).toEqual(true);
-      expect(ngIf1Scope.$$destroyed).toEqual(true);
-      expect(ngIf2Scope.$$destroyed).toEqual(true);
+      expect($rootScope.$$childHead).toBeNull();
+      // expect(ngRepeatScope.$$destroyed).toEqual(true);
+      // expect(ngIf1Scope.$$destroyed).toEqual(true);
+      // expect(ngIf2Scope.$$destroyed).toEqual(true);
     });
 
     it("should throw error if unterminated", () => {