diff --git a/src/ng/compile.js b/src/ng/compile.js
index 950c036ecd4d..2dd246cecc2c 100644
--- a/src/ng/compile.js
+++ b/src/ng/compile.js
@@ -185,9 +185,18 @@
  * * `$scope` - Current scope associated with the element
  * * `$element` - Current element
  * * `$attrs` - Current attributes object for the element
- * * `$transclude` - A transclude linking function pre-bound to the correct transclusion scope.
- *    The scope can be overridden by an optional first argument.
- *   `function([scope], cloneLinkingFn)`.
+ * * `$transclude` - A transclude linking function pre-bound to the correct transclusion scope:
+ *   `function([scope], cloneLinkingFn, futureParentElement)`.
+ *    * `scope`: optional argument to override the scope.
+ *    * `cloneLinkingFn`: optional argument to create clones of the original translcuded content.
+ *    * `futureParentElement`:
+ *        * defines the parent to which the `cloneLinkingFn` will add the cloned elements.
+ *        * default: `$element.parent()` resp. `$element` for `transclude:'element'` resp. `transclude:true`.
+ *        * only needed for transcludes that are allowed to contain non html elements (e.g. SVG elements)
+ *          and when the `cloneLinkinFn` is passed,
+ *          as those elements need to created and cloned in a special way when they are defined outside their
+ *          usual containers (e.g. like `<svg>`).
+ *        * See also the `directive.templateNamespace` property.
  *
  *
  * #### `require`
@@ -219,18 +228,17 @@
  * * `M` - Comment: `<!-- directive: my-directive exp -->`
  *
  *
- * #### `type`
- * String representing the document type used by the markup. This is useful for templates where the root
- * node is non-HTML content (such as SVG or MathML). The default value is "html".
+ * #### `templateNamespace`
+ * String representing the document type used by the markup in the template.
+ * AngularJS needs this information as those elements need to be created and cloned
+ * in a special way when they are defined outside their usual containers like `<svg>` and `<math>`.
  *
- * * `html` - All root template nodes are HTML, and don't need to be wrapped. Root nodes may also be
+ * * `html` - All root nodes in the template are HTML. Root nodes may also be
  *   top-level elements such as `<svg>` or `<math>`.
- * * `svg` - The template contains only SVG content, and must be wrapped in an `<svg>` node prior to
- *   processing.
- * * `math` - The template contains only MathML content, and must be wrapped in an `<math>` node prior to
- *   processing.
+ * * `svg` - The root nodes in the template are SVG elements (excluding `<math>`).
+ * * `math` - The root nodes in the template are MathML elements (excluding `<svg>`).
  *
- * If no `type` is specified, then the type is considered to be html.
+ * If no `templateNamespace` is specified, then the namespace is considered to be `html`.
  *
  * #### `template`
  * HTML markup that may:
@@ -266,6 +274,10 @@
  * one. See the {@link guide/directive#creating-custom-directives_creating-directives_template-expanding-directive
  * Directives Guide} for an example.
  *
+ * There very few scenarios were element replacement is required for the application function,
+ * the main one being reusable custom components that are used within SVG contexts
+ * (because SVG doesn't work with custom elements in the DOM tree).
+ *
  * #### `transclude`
  * compile the content of the element and make it available to the directive.
  * Typically used with {@link ng.directive:ngTransclude
@@ -360,10 +372,9 @@
  *     the directives to use the controllers as a communication channel.
  *
  *   * `transcludeFn` - A transclude linking function pre-bound to the correct transclusion scope.
- *     The scope can be overridden by an optional first argument. This is the same as the `$transclude`
- *     parameter of directive controllers.
- *     `function([scope], cloneLinkingFn)`.
- *
+ *     This is the same as the `$transclude`
+ *     parameter of directive controllers, see there for details.
+ *     `function([scope], cloneLinkingFn, futureParentElement)`.
  *
  * #### Pre-linking function
  *
@@ -880,8 +891,18 @@ function $CompileProvider($provide, $$sanitizeUriProvider) {
               compileNodes($compileNodes, transcludeFn, $compileNodes,
                            maxPriority, ignoreDirective, previousCompileContext);
       safeAddClass($compileNodes, 'ng-scope');
-      return function publicLinkFn(scope, cloneConnectFn, transcludeControllers, parentBoundTranscludeFn){
+      var namespace = null;
+      return function publicLinkFn(scope, cloneConnectFn, transcludeControllers, parentBoundTranscludeFn, futureParentElement){
         assertArg(scope, 'scope');
+        if (!namespace) {
+          namespace = detectNamespaceForChildElements(futureParentElement);
+          if (namespace !== 'html') {
+            $compileNodes = jqLite(
+              wrapTemplate(namespace, jqLite('<div>').append($compileNodes).html())
+            );
+          }
+        }
+
         // important!!: we must call our jqLite.clone() since the jQuery one is trying to be smart
         // and sometimes changes the structure of the DOM.
         var $linkNode = cloneConnectFn
@@ -902,6 +923,16 @@ function $CompileProvider($provide, $$sanitizeUriProvider) {
       };
     }
 
+    function detectNamespaceForChildElements(parentElement) {
+      // TODO: Make this detect MathML as well...
+      var node = parentElement && parentElement[0];
+      if (!node) {
+        return 'html';
+      } else {
+        return nodeName_(node) !== 'foreignobject' && node.toString().match(/SVG/) ? 'svg': 'html';
+      }
+    }
+
     function safeAddClass($element, className) {
       try {
         $element.addClass(className);
@@ -1025,7 +1056,7 @@ function $CompileProvider($provide, $$sanitizeUriProvider) {
 
     function createBoundTranscludeFn(scope, transcludeFn, previousBoundTranscludeFn, elementTransclusion) {
 
-      var boundTranscludeFn = function(transcludedScope, cloneFn, controllers) {
+      var boundTranscludeFn = function(transcludedScope, cloneFn, controllers, futureParentElement) {
         var scopeCreated = false;
 
         if (!transcludedScope) {
@@ -1034,7 +1065,7 @@ function $CompileProvider($provide, $$sanitizeUriProvider) {
           scopeCreated = true;
         }
 
-        var clone = transcludeFn(transcludedScope, cloneFn, controllers, previousBoundTranscludeFn);
+        var clone = transcludeFn(transcludedScope, cloneFn, controllers, previousBoundTranscludeFn, futureParentElement);
         if (scopeCreated && !elementTransclusion) {
           clone.on('$destroy', function() { transcludedScope.$destroy(); });
         }
@@ -1339,7 +1370,7 @@ function $CompileProvider($provide, $$sanitizeUriProvider) {
             if (jqLiteIsTextNode(directiveValue)) {
               $template = [];
             } else {
-              $template = jqLite(wrapTemplate(directive.type, trim(directiveValue)));
+              $template = jqLite(wrapTemplate(directive.templateNamespace, trim(directiveValue)));
             }
             compileNode = $template[0];
 
@@ -1646,11 +1677,13 @@ function $CompileProvider($provide, $$sanitizeUriProvider) {
         }
 
         // This is the function that is injected as `$transclude`.
-        function controllersBoundTransclude(scope, cloneAttachFn) {
+        // Note: all arguments are optional!
+        function controllersBoundTransclude(scope, cloneAttachFn, futureParentElement) {
           var transcludeControllers;
 
-          // no scope passed
-          if (!cloneAttachFn) {
+          // No scope passed in:
+          if (!isScope(scope)) {
+            futureParentElement = cloneAttachFn;
             cloneAttachFn = scope;
             scope = undefined;
           }
@@ -1658,8 +1691,10 @@ function $CompileProvider($provide, $$sanitizeUriProvider) {
           if (hasElementTranscludeDirective) {
             transcludeControllers = elementControllers;
           }
-
-          return boundTranscludeFn(scope, cloneAttachFn, transcludeControllers);
+          if (!futureParentElement) {
+            futureParentElement = hasElementTranscludeDirective ? $element.parent() : $element;
+          }
+          return boundTranscludeFn(scope, cloneAttachFn, transcludeControllers, futureParentElement);
         }
       }
     }
@@ -1786,7 +1821,7 @@ function $CompileProvider($provide, $$sanitizeUriProvider) {
           templateUrl = (isFunction(origAsyncDirective.templateUrl))
               ? origAsyncDirective.templateUrl($compileNode, tAttrs)
               : origAsyncDirective.templateUrl,
-          type = origAsyncDirective.type;
+          templateNamespace = origAsyncDirective.templateNamespace;
 
       $compileNode.empty();
 
@@ -1800,7 +1835,7 @@ function $CompileProvider($provide, $$sanitizeUriProvider) {
             if (jqLiteIsTextNode(content)) {
               $template = [];
             } else {
-              $template = jqLite(wrapTemplate(type, trim(content)));
+              $template = jqLite(wrapTemplate(templateNamespace, trim(content)));
             }
             compileNode = $template[0];
 
diff --git a/test/ng/compileSpec.js b/test/ng/compileSpec.js
index 2ebe15c013ca..5a41397aefcd 100755
--- a/test/ng/compileSpec.js
+++ b/test/ng/compileSpec.js
@@ -7,8 +7,31 @@ function calcCacheSize() {
   return size;
 }
 
-
 describe('$compile', function() {
+  function isUnknownElement(el) {
+    return !!el.toString().match(/Unknown/);
+  }
+
+  function isSVGElement(el) {
+    return !!el.toString().match(/SVG/);
+  }
+
+  function isHTMLElement(el) {
+    return !!el.toString().match(/HTML/);
+  }
+
+  function supportsMathML() {
+    var d = document.createElement('div');
+    d.innerHTML = '<math></math>';
+    return !isUnknownElement(d.firstChild);
+  }
+
+  // IE9-11 do not support foreignObject in svg...
+  function supportsForeignObject() {
+    var d = document.createElementNS('http://www.w3.org/2000/svg', 'foreignObject');
+    return !!d.toString().match(/SVGForeignObject/);
+  }
+
   var element, directive, $compile, $rootScope;
 
   beforeEach(module(provideLog, function($provide, $compileProvider){
@@ -63,6 +86,45 @@ describe('$compile', function() {
       terminal: true
     }));
 
+    directive('svgContainer', function() {
+      return {
+        template: '<svg width="400" height="400" ng-transclude></svg>',
+        replace: true,
+        transclude: true
+      };
+    });
+
+    directive('svgCustomTranscludeContainer', function() {
+      return {
+        template: '<svg width="400" height="400"></svg>',
+        transclude: true,
+        link: function(scope, element, attr, ctrls, $transclude) {
+          var futureParent = element.children().eq(0);
+          $transclude(function(clone) {
+            futureParent.append(clone);
+          }, futureParent);
+        }
+      };
+    });
+
+    directive('svgCircle', function(){
+      return {
+        template: '<circle cx="2" cy="2" r="1"></circle>',
+        templateNamespace: 'svg',
+        replace: true
+      };
+    });
+
+    directive('myForeignObject', function(){
+      return {
+        template: '<foreignObject width="100" height="100" ng-transclude></foreignObject>',
+        templateNamespace: 'svg',
+        replace: true,
+        transclude: true
+      };
+    });
+
+
     return function(_$compile_, _$rootScope_) {
       $rootScope = _$rootScope_;
       $compile = _$compile_;
@@ -137,6 +199,105 @@ describe('$compile', function() {
   });
 
 
+  describe('svg namespace transcludes', function() {
+    // this method assumes some sort of sized SVG element is being inspected.
+    function assertIsValidSvgCircle(elem) {
+      expect(isUnknownElement(elem)).toBe(false);
+      expect(isSVGElement(elem)).toBe(true);
+      var box = elem.getBoundingClientRect();
+      expect(box.width === 0 && box.height === 0).toBe(false);
+    }
+
+    it('should handle transcluded svg elements', inject(function($compile){
+      element = jqLite('<div><svg-container>' +
+          '<circle cx="4" cy="4" r="2"></circle>' +
+          '</svg-container></div>');
+      $compile(element.contents())($rootScope);
+      document.body.appendChild(element[0]);
+
+      var circle = element.find('circle');
+
+      assertIsValidSvgCircle(circle[0]);
+    }));
+
+    it('should handle custom svg elements inside svg tag', inject(function(){
+      element = jqLite('<div><svg width="300" height="300">' +
+          '<svg-circle></svg-circle>' +
+          '</svg></div>');
+      $compile(element.contents())($rootScope);
+      document.body.appendChild(element[0]);
+
+      var circle = element.find('circle');
+      assertIsValidSvgCircle(circle[0]);
+    }));
+
+    it('should handle transcluded custom svg elements', inject(function(){
+      element = jqLite('<div><svg-container>' +
+          '<svg-circle></svg-circle>' +
+          '</svg-container></div>');
+      $compile(element.contents())($rootScope);
+      document.body.appendChild(element[0]);
+
+      var circle = element.find('circle');
+      assertIsValidSvgCircle(circle[0]);
+    }));
+
+    if (supportsForeignObject()) {
+      it('should handle foreignObject', inject(function(){
+        element = jqLite('<div><svg-container>' +
+            '<foreignObject width="100" height="100"><div class="test" style="position:absolute;width:20px;height:20px">test</div></foreignObject>' +
+            '</svg-container></div>');
+        $compile(element.contents())($rootScope);
+        document.body.appendChild(element[0]);
+
+        var testElem = element.find('div');
+        expect(isHTMLElement(testElem[0])).toBe(true);
+        var bounds = testElem[0].getBoundingClientRect();
+        expect(bounds.width === 20 && bounds.height === 20).toBe(true);
+      }));
+
+      it('should handle custom svg containers that transclude to foreignObject that transclude html', inject(function(){
+        element = jqLite('<div><svg-container>' +
+            '<my-foreign-object><div class="test" style="width:20px;height:20px">test</div></my-foreign-object>' +
+            '</svg-container></div>');
+        $compile(element.contents())($rootScope);
+        document.body.appendChild(element[0]);
+
+        var testElem = element.find('div');
+        expect(isHTMLElement(testElem[0])).toBe(true);
+        var bounds = testElem[0].getBoundingClientRect();
+        expect(bounds.width === 20 && bounds.height === 20).toBe(true);
+      }));
+
+      // NOTE: This test may be redundant.
+      it('should handle custom svg containers that transclude to foreignObject'+
+         ' that transclude to custom svg containers that transclude to custom elements', inject(function(){
+        element = jqLite('<div><svg-container>' +
+            '<my-foreign-object><svg-container><svg-circle></svg-circle></svg-container></my-foreign-object>' +
+            '</svg-container></div>');
+        $compile(element.contents())($rootScope);
+        document.body.appendChild(element[0]);
+
+        var circle = element.find('circle');
+        assertIsValidSvgCircle(circle[0]);
+      }));
+    }
+
+    it('should handle directives with templates that manually add the transclude further down', inject(function() {
+      element = jqLite('<div><svg-custom-transclude-container>' +
+          '<circle cx="2" cy="2" r="1"></circle></svg-custom-transclude-container>' +
+          '</div>');
+      $compile(element.contents())($rootScope);
+      document.body.appendChild(element[0]);
+
+      var circle = element.find('circle');
+      assertIsValidSvgCircle(circle[0]);
+
+    }));
+
+  });
+
+
   describe('compile phase', function() {
 
     it('should attach scope to the document node when it is compiled explicitly', inject(function($document){
@@ -838,58 +999,58 @@ describe('$compile', function() {
           expect(nodeName_(element)).toMatch(/optgroup/i);
         }));
 
-        if (window.SVGAElement) {
-          it('should support SVG templates using directive.type=svg', function() {
+        it('should support SVG templates using directive.templateNamespace=svg', function() {
+          module(function() {
+            directive('svgAnchor', valueFn({
+              replace: true,
+              template: '<a xlink:href="{{linkurl}}">{{text}}</a>',
+              templateNamespace: 'SVG',
+              scope: {
+                linkurl: '@svgAnchor',
+                text: '@?'
+              }
+            }));
+          });
+          inject(function($compile, $rootScope) {
+            element = $compile('<svg><g svg-anchor="/foo/bar" text="foo/bar!"></g></svg>')($rootScope);
+            var child = element.children().eq(0);
+            $rootScope.$digest();
+            expect(nodeName_(child)).toMatch(/a/i);
+            expect(isSVGElement(child[0])).toBe(true);
+            expect(child[0].href.baseVal).toBe("/foo/bar");
+          });
+        });
+
+        if (supportsMathML()) {
+          // MathML is only natively supported in Firefox at the time of this test's writing,
+          // and even there, the browser does not export MathML element constructors globally.
+          it('should support MathML templates using directive.templateNamespace=math', function() {
             module(function() {
-              directive('svgAnchor', valueFn({
+              directive('pow', valueFn({
                 replace: true,
-                template: '<a xlink:href="{{linkurl}}">{{text}}</a>',
-                type: 'SVG',
+                transclude: true,
+                template: '<msup><mn>{{pow}}</mn></msup>',
+                templateNamespace: 'MATH',
                 scope: {
-                  linkurl: '@svgAnchor',
-                  text: '@?'
+                  pow: '@pow',
+                },
+                link: function(scope, elm, attr, ctrl, transclude) {
+                  transclude(function(node) {
+                    elm.prepend(node[0]);
+                  });
                 }
               }));
             });
             inject(function($compile, $rootScope) {
-              element = $compile('<svg><g svg-anchor="/foo/bar" text="foo/bar!"></g></svg>')($rootScope);
-              var child = element.children().eq(0);
+              element = $compile('<math><mn pow="2"><mn>8</mn></mn></math>')($rootScope);
               $rootScope.$digest();
-              expect(nodeName_(child)).toMatch(/a/i);
-              expect(child[0].constructor).toBe(window.SVGAElement);
-              expect(child[0].href.baseVal).toBe("/foo/bar");
+              var child = element.children().eq(0);
+              expect(nodeName_(child)).toMatch(/msup/i);
+              expect(isUnknownElement(child[0])).toBe(false);
+              expect(isHTMLElement(child[0])).toBe(false);
             });
           });
         }
-
-        // MathML is only natively supported in Firefox at the time of this test's writing,
-        // and even there, the browser does not export MathML element constructors globally.
-        // So the test is slightly limited in what it does. But as browsers begin to
-        // implement MathML natively, this can be tightened up to be more meaningful.
-        it('should support MathML templates using directive.type=math', function() {
-          module(function() {
-            directive('pow', valueFn({
-              replace: true,
-              transclude: true,
-              template: '<msup><mn>{{pow}}</mn></msup>',
-              type: 'MATH',
-              scope: {
-                pow: '@pow',
-              },
-              link: function(scope, elm, attr, ctrl, transclude) {
-                transclude(function(node) {
-                  elm.prepend(node[0]);
-                });
-              }
-            }));
-          });
-          inject(function($compile, $rootScope) {
-            element = $compile('<math><mn pow="2"><mn>8</mn></mn></math>')($rootScope);
-            $rootScope.$digest();
-            var child = element.children().eq(0);
-            expect(nodeName_(child)).toMatch(/msup/i);
-          });
-        });
       });
 
 
@@ -1735,60 +1896,60 @@ describe('$compile', function() {
           expect(nodeName_(element)).toMatch(/optgroup/i);
         }));
 
-        if (window.SVGAElement) {
-          it('should support SVG templates using directive.type=svg', function() {
+        it('should support SVG templates using directive.templateNamespace=svg', function() {
+          module(function() {
+            directive('svgAnchor', valueFn({
+              replace: true,
+              templateUrl: 'template.html',
+              templateNamespace: 'SVG',
+              scope: {
+                linkurl: '@svgAnchor',
+                text: '@?'
+              }
+            }));
+          });
+          inject(function($compile, $rootScope, $templateCache) {
+            $templateCache.put('template.html', '<a xlink:href="{{linkurl}}">{{text}}</a>');
+            element = $compile('<svg><g svg-anchor="/foo/bar" text="foo/bar!"></g></svg>')($rootScope);
+            $rootScope.$digest();
+            var child = element.children().eq(0);
+            expect(nodeName_(child)).toMatch(/a/i);
+            expect(isSVGElement(child[0])).toBe(true);
+            expect(child[0].href.baseVal).toBe("/foo/bar");
+          });
+        });
+
+        if (supportsMathML()) {
+          // MathML is only natively supported in Firefox at the time of this test's writing,
+          // and even there, the browser does not export MathML element constructors globally.
+          it('should support MathML templates using directive.templateNamespace=math', function() {
             module(function() {
-              directive('svgAnchor', valueFn({
+              directive('pow', valueFn({
                 replace: true,
+                transclude: true,
                 templateUrl: 'template.html',
-                type: 'SVG',
+                templateNamespace: 'math',
                 scope: {
-                  linkurl: '@svgAnchor',
-                  text: '@?'
+                  pow: '@pow',
+                },
+                link: function(scope, elm, attr, ctrl, transclude) {
+                  transclude(function(node) {
+                    elm.prepend(node[0]);
+                  });
                 }
               }));
             });
             inject(function($compile, $rootScope, $templateCache) {
-              $templateCache.put('template.html', '<a xlink:href="{{linkurl}}">{{text}}</a>');
-              element = $compile('<svg><g svg-anchor="/foo/bar" text="foo/bar!"></g></svg>')($rootScope);
+              $templateCache.put('template.html', '<msup><mn>{{pow}}</mn></msup>');
+              element = $compile('<math><mn pow="2"><mn>8</mn></mn></math>')($rootScope);
               $rootScope.$digest();
               var child = element.children().eq(0);
-              expect(nodeName_(child)).toMatch(/a/i);
-              expect(child[0].constructor).toBe(window.SVGAElement);
-              expect(child[0].href.baseVal).toBe("/foo/bar");
+              expect(nodeName_(child)).toMatch(/msup/i);
+              expect(isUnknownElement(child[0])).toBe(false);
+              expect(isHTMLElement(child[0])).toBe(false);
             });
           });
         }
-
-        // MathML is only natively supported in Firefox at the time of this test's writing,
-        // and even there, the browser does not export MathML element constructors globally.
-        // So the test is slightly limited in what it does. But as browsers begin to
-        // implement MathML natively, this can be tightened up to be more meaningful.
-        it('should support MathML templates using directive.type=math', function() {
-          module(function() {
-            directive('pow', valueFn({
-              replace: true,
-              transclude: true,
-              templateUrl: 'template.html',
-              type: 'MATH',
-              scope: {
-                pow: '@pow',
-              },
-              link: function(scope, elm, attr, ctrl, transclude) {
-                transclude(function(node) {
-                  elm.prepend(node[0]);
-                });
-              }
-            }));
-          });
-          inject(function($compile, $rootScope, $templateCache) {
-            $templateCache.put('template.html', '<msup><mn>{{pow}}</mn></msup>');
-            element = $compile('<math><mn pow="2"><mn>8</mn></mn></math>')($rootScope);
-            $rootScope.$digest();
-            var child = element.children().eq(0);
-            expect(nodeName_(child)).toMatch(/msup/i);
-          });
-        });
       });
 
 
diff --git a/test/ng/directive/ngIfSpec.js b/test/ng/directive/ngIfSpec.js
index f952500ec90d..acbbb0627cc9 100755
--- a/test/ng/directive/ngIfSpec.js
+++ b/test/ng/directive/ngIfSpec.js
@@ -351,4 +351,23 @@ describe('ngIf animations', function () {
     });
   });
 
+  it('should work with svg elements when the svg container is transcluded', function() {
+    module(function($compileProvider) {
+      $compileProvider.directive('svgContainer', function() {
+        return {
+          template: '<svg ng-transclude></svg>',
+          replace: true,
+          transclude: true
+        };
+      });
+    });
+    inject(function($compile, $rootScope) {
+      element = $compile('<svg-container><circle ng-if="flag"></circle></svg-container>')($rootScope);
+      $rootScope.flag = true;
+      $rootScope.$apply();
+
+      var circle = element.find('circle');
+      expect(circle[0].toString()).toMatch(/SVG/);
+    });
+  });
 });
diff --git a/test/ng/directive/ngRepeatSpec.js b/test/ng/directive/ngRepeatSpec.js
index aeaeba3849a5..84d735f9b2dc 100644
--- a/test/ng/directive/ngRepeatSpec.js
+++ b/test/ng/directive/ngRepeatSpec.js
@@ -1387,4 +1387,24 @@ describe('ngRepeat animations', function() {
     })
   );
 
+  it('should work with svg elements when the svg container is transcluded', function() {
+    module(function($compileProvider) {
+      $compileProvider.directive('svgContainer', function() {
+        return {
+          template: '<svg ng-transclude></svg>',
+          replace: true,
+          transclude: true
+        };
+      });
+    });
+    inject(function($compile, $rootScope) {
+      element = $compile('<svg-container><circle ng-repeat="r in rows"></circle></svg-container>')($rootScope);
+      $rootScope.rows = [1];
+      $rootScope.$apply();
+
+      var circle = element.find('circle');
+      expect(circle[0].toString()).toMatch(/SVG/);
+    });
+  });
+
 });
diff --git a/test/ng/directive/ngSwitchSpec.js b/test/ng/directive/ngSwitchSpec.js
index 5e48d68f19f3..07cd625bc8a2 100644
--- a/test/ng/directive/ngSwitchSpec.js
+++ b/test/ng/directive/ngSwitchSpec.js
@@ -433,4 +433,25 @@ describe('ngSwitch animations', function() {
       expect(destroyed).toBe(true);
     });
   });
+
+  it('should work with svg elements when the svg container is transcluded', function() {
+    module(function($compileProvider) {
+      $compileProvider.directive('svgContainer', function() {
+        return {
+          template: '<svg ng-transclude></svg>',
+          replace: true,
+          transclude: true
+        };
+      });
+    });
+    inject(function($compile, $rootScope) {
+      element = $compile('<svg-container ng-switch="inc"><circle ng-switch-when="one"></circle>' +
+        '</svg-container>')($rootScope);
+      $rootScope.inc = 'one';
+      $rootScope.$apply();
+
+      var circle = element.find('circle');
+      expect(circle[0].toString()).toMatch(/SVG/);
+    });
+  });
 });