diff --git a/Eigen/src/Core/Matrix.h b/Eigen/src/Core/Matrix.h
index 2fc38c812..cdc76c120 100644
--- a/Eigen/src/Core/Matrix.h
+++ b/Eigen/src/Core/Matrix.h
@@ -651,13 +651,12 @@ class Matrix
       m_storage.data()[1] = y;
     }
     
-    template<typename MatrixType, typename OtherDerived, bool IsSameType, bool IsDynamicSize>
+    template<typename MatrixType, typename OtherDerived, bool IsSameType>
     friend struct ei_matrix_swap_impl;
 };
 
 template<typename MatrixType, typename OtherDerived,
-         bool IsSameType = ei_is_same_type<MatrixType, OtherDerived>::ret,
-         bool IsDynamicSize = MatrixType::SizeAtCompileTime==Dynamic>
+         bool IsSameType = ei_is_same_type<MatrixType, OtherDerived>::ret>
 struct ei_matrix_swap_impl
 {
   static inline void run(MatrixType& matrix, MatrixBase<OtherDerived>& other)
@@ -667,10 +666,11 @@ struct ei_matrix_swap_impl
 };
 
 template<typename MatrixType, typename OtherDerived>
-struct ei_matrix_swap_impl<MatrixType, OtherDerived, true, true>
+struct ei_matrix_swap_impl<MatrixType, OtherDerived, true>
 {
   static inline void run(MatrixType& matrix, MatrixBase<OtherDerived>& other)
   {
+    ei_assert(matrix.rows() == other.rows() && matrix.cols() == other.cols());
     matrix.m_storage.swap(other.derived().m_storage);
   }
 };
@@ -679,6 +679,7 @@ template<typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int
 template<typename OtherDerived>
 inline void Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols>::swap(const MatrixBase<OtherDerived>& other)
 {
+  
   ei_matrix_swap_impl<Matrix, OtherDerived>::run(*this, *const_cast<MatrixBase<OtherDerived>*>(&other));
 }
 
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 56d36aa70..6bbf82144 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -148,6 +148,7 @@ ei_add_test(sparse_product)
 ei_add_test(sparse_solvers " " "${SPARSE_LIBS}")
 ei_add_test(umeyama)
 ei_add_test(householder)
+ei_add_test(swap)
 
 ei_add_property(EIGEN_TESTING_SUMMARY "CXX:               ${CMAKE_CXX_COMPILER}\n")
 if(CMAKE_COMPILER_IS_GNUCXX)
diff --git a/test/basicstuff.cpp b/test/basicstuff.cpp
index 52aff93ee..29df99f9e 100644
--- a/test/basicstuff.cpp
+++ b/test/basicstuff.cpp
@@ -99,15 +99,6 @@ template<typename MatrixType> void basicStuff(const MatrixType& m)
   MatrixType m4;
   VERIFY_IS_APPROX(m4 = m1,m1);
 
-  // test swap
-  m3 = m1;
-  m1.swap(m2);
-  VERIFY_IS_APPROX(m3, m2);
-  if(rows*cols>=3)
-  {
-    VERIFY_IS_NOT_APPROX(m3, m1);
-  }
-
   m3.real() = m1.real();
   VERIFY_IS_APPROX(static_cast<const MatrixType&>(m3).real(), static_cast<const MatrixType&>(m1).real());
   VERIFY_IS_APPROX(static_cast<const MatrixType&>(m3).real(), m1.real());
diff --git a/test/swap.cpp b/test/swap.cpp
new file mode 100644
index 000000000..8b325992c
--- /dev/null
+++ b/test/swap.cpp
@@ -0,0 +1,98 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2009 Benoit Jacob <jacob.benoit.1@gmail.com>
+//
+// Eigen is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 3 of the License, or (at your option) any later version.
+//
+// Alternatively, you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as
+// published by the Free Software Foundation; either version 2 of
+// the License, or (at your option) any later version.
+//
+// Eigen is distributed in the hope that it will be useful, but WITHOUT ANY
+// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+// FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License or the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License and a copy of the GNU General Public License along with
+// Eigen. If not, see <http://www.gnu.org/licenses/>.
+
+#define EIGEN_NO_STATIC_ASSERT
+#include "main.h"
+
+template<typename T>
+struct other_matrix_type
+{
+  typedef int type;
+};
+
+template<typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols>
+struct other_matrix_type<Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols> >
+{
+  typedef Matrix<_Scalar, _Rows, _Cols, _Options^RowMajor, _MaxRows, _MaxCols> type;
+};
+
+template<typename MatrixType> void swap(const MatrixType& m)
+{
+  typedef typename other_matrix_type<MatrixType>::type OtherMatrixType;
+  typedef typename MatrixType::Scalar Scalar;
+
+  ei_assert((!ei_is_same_type<MatrixType,OtherMatrixType>::ret));
+  int rows = m.rows();
+  int cols = m.cols();
+  
+  // construct 3 matrix guaranteed to be distinct
+  MatrixType m1 = MatrixType::Random(rows,cols);
+  MatrixType m2 = MatrixType::Random(rows,cols) + Scalar(100) * MatrixType::Identity(rows,cols);
+  OtherMatrixType m3 = OtherMatrixType::Random(rows,cols) + Scalar(200) * OtherMatrixType::Identity(rows,cols);
+  
+  MatrixType m1_copy = m1;
+  MatrixType m2_copy = m2;
+  OtherMatrixType m3_copy = m3;
+  
+  // test swapping 2 matrices of same type
+  m1.swap(m2);
+  VERIFY_IS_APPROX(m1,m2_copy);
+  VERIFY_IS_APPROX(m2,m1_copy);
+  m1 = m1_copy;
+  m2 = m2_copy;
+  
+  // test swapping 2 matrices of different types
+  m1.swap(m3);
+  VERIFY_IS_APPROX(m1,m3_copy);
+  VERIFY_IS_APPROX(m3,m1_copy);
+  m1 = m1_copy;
+  m3 = m3_copy;
+  
+  // test swapping matrix with expression
+  m1.swap(m2.block(0,0,rows,cols));
+  VERIFY_IS_APPROX(m1,m2_copy);
+  VERIFY_IS_APPROX(m2,m1_copy);
+  m1 = m1_copy;
+  m2 = m2_copy;
+
+  // test swapping two expressions of different types
+  m1.transpose().swap(m3.transpose());
+  VERIFY_IS_APPROX(m1,m3_copy);
+  VERIFY_IS_APPROX(m3,m1_copy);
+  m1 = m1_copy;
+  m3 = m3_copy;
+  
+  // test assertion on mismatching size -- matrix case
+  VERIFY_RAISES_ASSERT(m1.swap(m1.row(0)));
+  // test assertion on mismatching size -- xpr case
+  VERIFY_RAISES_ASSERT(m1.row(0).swap(m1));
+}
+
+void test_swap()
+{
+  CALL_SUBTEST( swap(Matrix3f()) ); // fixed size, no vectorization 
+  CALL_SUBTEST( swap(Matrix4d()) ); // fixed size, possible vectorization 
+  CALL_SUBTEST( swap(MatrixXd(3,3)) ); // dyn size, no vectorization 
+  CALL_SUBTEST( swap(MatrixXf(30,30)) ); // dyn size, possible vectorization 
+}