Workaround a bunch of stupid warnings in unit tests

20 files changed, 352 insertions, 321 deletions

diff --git a/test/cholesky.cpp b/test/cholesky.cpp
index a3b16bfc2..d084ec72c 100644
--- a/test/cholesky.cpp
+++ b/test/cholesky.cpp
@@ -82,14 +82,14 @@ template<typename MatrixType> void cholesky(const MatrixType& m)
     symm += a1 * a1.adjoint();
   }
 
-  SquareMatrixType symmUp = symm.template triangularView<Upper>();
-  SquareMatrixType symmLo = symm.template triangularView<Lower>();
-
   // to test if really Cholesky only uses the upper triangular part, uncomment the following
   // FIXME: currently that fails !!
   //symm.template part<StrictlyLower>().setZero();
 
   {
+    SquareMatrixType symmUp = symm.template triangularView<Upper>();
+    SquareMatrixType symmLo = symm.template triangularView<Lower>();
+    
     LLT<SquareMatrixType,Lower> chollo(symmLo);
     VERIFY_IS_APPROX(symm, chollo.reconstructedMatrix());
     vecX = chollo.solve(vecB);
@@ -113,6 +113,21 @@ template<typename MatrixType> void cholesky(const MatrixType& m)
     VERIFY_IS_APPROX(MatrixType(chollo.matrixU().transpose().conjugate()), MatrixType(chollo.matrixL()));
     VERIFY_IS_APPROX(MatrixType(cholup.matrixL().transpose().conjugate()), MatrixType(cholup.matrixU()));
     VERIFY_IS_APPROX(MatrixType(cholup.matrixU().transpose().conjugate()), MatrixType(cholup.matrixL()));
+    
+    // test some special use cases of SelfCwiseBinaryOp:
+    MatrixType m1 = MatrixType::Random(rows,cols), m2(rows,cols);
+    m2 = m1;
+    m2 += symmLo.template selfadjointView<Lower>().llt().solve(matB);
+    VERIFY_IS_APPROX(m2, m1 + symmLo.template selfadjointView<Lower>().llt().solve(matB));
+    m2 = m1;
+    m2 -= symmLo.template selfadjointView<Lower>().llt().solve(matB);
+    VERIFY_IS_APPROX(m2, m1 - symmLo.template selfadjointView<Lower>().llt().solve(matB));
+    m2 = m1;
+    m2.noalias() += symmLo.template selfadjointView<Lower>().llt().solve(matB);
+    VERIFY_IS_APPROX(m2, m1 + symmLo.template selfadjointView<Lower>().llt().solve(matB));
+    m2 = m1;
+    m2.noalias() -= symmLo.template selfadjointView<Lower>().llt().solve(matB);
+    VERIFY_IS_APPROX(m2, m1 - symmLo.template selfadjointView<Lower>().llt().solve(matB));
   }
 
   // LDLT
@@ -166,21 +181,6 @@ template<typename MatrixType> void cholesky(const MatrixType& m)
       symm = -symm;
   }
 
-  // test some special use cases of SelfCwiseBinaryOp:
-  MatrixType m1 = MatrixType::Random(rows,cols), m2(rows,cols);
-  m2 = m1;
-  m2 += symmLo.template selfadjointView<Lower>().llt().solve(matB);
-  VERIFY_IS_APPROX(m2, m1 + symmLo.template selfadjointView<Lower>().llt().solve(matB));
-  m2 = m1;
-  m2 -= symmLo.template selfadjointView<Lower>().llt().solve(matB);
-  VERIFY_IS_APPROX(m2, m1 - symmLo.template selfadjointView<Lower>().llt().solve(matB));
-  m2 = m1;
-  m2.noalias() += symmLo.template selfadjointView<Lower>().llt().solve(matB);
-  VERIFY_IS_APPROX(m2, m1 + symmLo.template selfadjointView<Lower>().llt().solve(matB));
-  m2 = m1;
-  m2.noalias() -= symmLo.template selfadjointView<Lower>().llt().solve(matB);
-  VERIFY_IS_APPROX(m2, m1 - symmLo.template selfadjointView<Lower>().llt().solve(matB));
-
   // update/downdate
   CALL_SUBTEST(( test_chol_update<SquareMatrixType,LLT>(symm)  ));
   CALL_SUBTEST(( test_chol_update<SquareMatrixType,LDLT>(symm) ));
@@ -304,7 +304,8 @@ template<typename MatrixType> void cholesky_verify_assert()
 
 void test_cholesky()
 {
-  int s;
+  int s = 0;
+  s = s; // shuts down ICC's remark #593: variable "s" was set but never used
   for(int i = 0; i < g_repeat; i++) {
     CALL_SUBTEST_1( cholesky(Matrix<double,1,1>()) );
     CALL_SUBTEST_3( cholesky(Matrix2d()) );
diff --git a/test/determinant.cpp b/test/determinant.cpp
index edf83fda9..81ab4b084 100644
--- a/test/determinant.cpp
+++ b/test/determinant.cpp
@@ -53,8 +53,9 @@ template<typename MatrixType> void determinant(const MatrixType& m)
 
 void test_determinant()
 {
-  int s;
   for(int i = 0; i < g_repeat; i++) {
+    int s = 0;
+    s = s; // shuts down ICC's remark #593: variable "s" was set but never used
     CALL_SUBTEST_1( determinant(Matrix<float, 1, 1>()) );
     CALL_SUBTEST_2( determinant(Matrix<double, 2, 2>()) );
     CALL_SUBTEST_3( determinant(Matrix<double, 3, 3>()) );
@@ -62,6 +63,6 @@ void test_determinant()
     CALL_SUBTEST_5( determinant(Matrix<std::complex<double>, 10, 10>()) );
     s = internal::random<int>(1,EIGEN_TEST_MAX_SIZE/4);
     CALL_SUBTEST_6( determinant(MatrixXd(s, s)) );
+    EIGEN_UNUSED_VARIABLE(s)
   }
-  EIGEN_UNUSED_VARIABLE(s)
 }
diff --git a/test/eigensolver_complex.cpp b/test/eigensolver_complex.cpp
index 817fbf2c2..9a52cfa5e 100644
--- a/test/eigensolver_complex.cpp
+++ b/test/eigensolver_complex.cpp
@@ -101,7 +101,8 @@ template<typename MatrixType> void eigensolver_verify_assert(const MatrixType& m
 
 void test_eigensolver_complex()
 {
-  int s;
+  int s = 0;
+  s = s; // shuts down ICC's remark #593: variable "s" was set but never used
   for(int i = 0; i < g_repeat; i++) {
     CALL_SUBTEST_1( eigensolver(Matrix4cf()) );
     s = internal::random<int>(1,EIGEN_TEST_MAX_SIZE/4);
@@ -109,7 +110,6 @@ void test_eigensolver_complex()
     CALL_SUBTEST_3( eigensolver(Matrix<std::complex<float>, 1, 1>()) );
     CALL_SUBTEST_4( eigensolver(Matrix3f()) );
   }
-
   CALL_SUBTEST_1( eigensolver_verify_assert(Matrix4cf()) );
   s = internal::random<int>(1,EIGEN_TEST_MAX_SIZE/4);
   CALL_SUBTEST_2( eigensolver_verify_assert(MatrixXcd(s,s)) );
@@ -117,7 +117,7 @@ void test_eigensolver_complex()
   CALL_SUBTEST_4( eigensolver_verify_assert(Matrix3f()) );
 
   // Test problem size constructors
-  CALL_SUBTEST_5(ComplexEigenSolver<MatrixXf>(s));
+  CALL_SUBTEST_5(ComplexEigenSolver<MatrixXf> tmp(s));
   
   EIGEN_UNUSED_VARIABLE(s)
 }
diff --git a/test/eigensolver_generalized_real.cpp b/test/eigensolver_generalized_real.cpp
index b8775871d..c4dc8a775 100644
--- a/test/eigensolver_generalized_real.cpp
+++ b/test/eigensolver_generalized_real.cpp
@@ -43,8 +43,9 @@ template<typename MatrixType> void generalized_eigensolver_real(const MatrixType
 
 void test_eigensolver_generalized_real()
 {
-  int s;
   for(int i = 0; i < g_repeat; i++) {
+    int s = 0;
+    s = s; // shuts down ICC's remark #593: variable "s" was set but never used
     CALL_SUBTEST_1( generalized_eigensolver_real(Matrix4f()) );
     s = internal::random<int>(1,EIGEN_TEST_MAX_SIZE/4);
     CALL_SUBTEST_2( generalized_eigensolver_real(MatrixXd(s,s)) );
@@ -54,7 +55,6 @@ void test_eigensolver_generalized_real()
     CALL_SUBTEST_2( generalized_eigensolver_real(MatrixXd(2,2)) );
     CALL_SUBTEST_3( generalized_eigensolver_real(Matrix<double,1,1>()) );
     CALL_SUBTEST_4( generalized_eigensolver_real(Matrix2d()) );
+    EIGEN_UNUSED_VARIABLE(s)
   }
-  
-  EIGEN_UNUSED_VARIABLE(s)
 }
diff --git a/test/eigensolver_generic.cpp b/test/eigensolver_generic.cpp
index a8bbf9007..0e1e508ae 100644
--- a/test/eigensolver_generic.cpp
+++ b/test/eigensolver_generic.cpp
@@ -88,7 +88,8 @@ template<typename MatrixType> void eigensolver_verify_assert(const MatrixType& m
 
 void test_eigensolver_generic()
 {
-  int s;
+  int s = 0;
+  s = s; // shuts down ICC's remark #593: variable "s" was set but never used
   for(int i = 0; i < g_repeat; i++) {
     CALL_SUBTEST_1( eigensolver(Matrix4f()) );
     s = internal::random<int>(1,EIGEN_TEST_MAX_SIZE/4);
@@ -108,7 +109,7 @@ void test_eigensolver_generic()
   CALL_SUBTEST_4( eigensolver_verify_assert(Matrix2d()) );
 
   // Test problem size constructors
-  CALL_SUBTEST_5(EigenSolver<MatrixXf>(s));
+  CALL_SUBTEST_5(EigenSolver<MatrixXf> tmp(s));
 
   // regression test for bug 410
   CALL_SUBTEST_2(
diff --git a/test/eigensolver_selfadjoint.cpp b/test/eigensolver_selfadjoint.cpp
index 55b7eea8d..67d4c543b 100644
--- a/test/eigensolver_selfadjoint.cpp
+++ b/test/eigensolver_selfadjoint.cpp
@@ -110,7 +110,8 @@ template<typename MatrixType> void selfadjointeigensolver(const MatrixType& m)
 
 void test_eigensolver_selfadjoint()
 {
-  int s;
+  int s = 0;
+  s = s; // shuts down ICC's remark #593: variable "s" was set but never used
   for(int i = 0; i < g_repeat; i++) {
     // very important to test 3x3 and 2x2 matrices since we provide special paths for them
     CALL_SUBTEST_1( selfadjointeigensolver(Matrix2d()) );
@@ -135,8 +136,8 @@ void test_eigensolver_selfadjoint()
 
   // Test problem size constructors
   s = internal::random<int>(1,EIGEN_TEST_MAX_SIZE/4);
-  CALL_SUBTEST_8(SelfAdjointEigenSolver<MatrixXf>(s));
-  CALL_SUBTEST_8(Tridiagonalization<MatrixXf>(s));
+  CALL_SUBTEST_8(SelfAdjointEigenSolver<MatrixXf> tmp1(s));
+  CALL_SUBTEST_8(Tridiagonalization<MatrixXf> tmp2(s));
   
   EIGEN_UNUSED_VARIABLE(s)
 }
diff --git a/test/evaluators.cpp b/test/evaluators.cpp
index 3081d7858..e3922c1be 100644
--- a/test/evaluators.cpp
+++ b/test/evaluators.cpp
@@ -29,25 +29,27 @@ void test_evaluators()
   VERIFY_IS_APPROX(w,v_const.transpose().eval());
 
   // Testing Array evaluator
-  ArrayXXf a(2,3);
-  ArrayXXf b(3,2);
-  a << 1,2,3, 4,5,6;
-  const ArrayXXf a_const(a);
+  {
+    ArrayXXf a(2,3);
+    ArrayXXf b(3,2);
+    a << 1,2,3, 4,5,6;
+    const ArrayXXf a_const(a);
 
-  VERIFY_IS_APPROX_EVALUATOR(b, a.transpose());
+    VERIFY_IS_APPROX_EVALUATOR(b, a.transpose());
 
-  VERIFY_IS_APPROX_EVALUATOR(b, a_const.transpose());
+    VERIFY_IS_APPROX_EVALUATOR(b, a_const.transpose());
 
-  // Testing CwiseNullaryOp evaluator
-  copy_using_evaluator(w, RowVector2d::Random());
-  VERIFY((w.array() >= -1).all() && (w.array() <= 1).all()); // not easy to test ...
+    // Testing CwiseNullaryOp evaluator
+    copy_using_evaluator(w, RowVector2d::Random());
+    VERIFY((w.array() >= -1).all() && (w.array() <= 1).all()); // not easy to test ...
 
-  VERIFY_IS_APPROX_EVALUATOR(w, RowVector2d::Zero());
+    VERIFY_IS_APPROX_EVALUATOR(w, RowVector2d::Zero());
 
-  VERIFY_IS_APPROX_EVALUATOR(w, RowVector2d::Constant(3));
-  
-  // mix CwiseNullaryOp and transpose
-  VERIFY_IS_APPROX_EVALUATOR(w, Vector2d::Zero().transpose());
+    VERIFY_IS_APPROX_EVALUATOR(w, RowVector2d::Constant(3));
+    
+    // mix CwiseNullaryOp and transpose
+    VERIFY_IS_APPROX_EVALUATOR(w, Vector2d::Zero().transpose());
+  }
 
   {
     // test product expressions
@@ -114,164 +116,171 @@ void test_evaluators()
     VERIFY_IS_APPROX_EVALUATOR2(resXX, prod(mXX,mXX), mXX*mXX);
   }
 
-  // this does not work because Random is eval-before-nested: 
-  // copy_using_evaluator(w, Vector2d::Random().transpose());
-  
-  // test CwiseUnaryOp
-  VERIFY_IS_APPROX_EVALUATOR(v2, 3 * v);
-  VERIFY_IS_APPROX_EVALUATOR(w, (3 * v).transpose());
-  VERIFY_IS_APPROX_EVALUATOR(b, (a + 3).transpose());
-  VERIFY_IS_APPROX_EVALUATOR(b, (2 * a_const + 3).transpose());
-
-  // test CwiseBinaryOp
-  VERIFY_IS_APPROX_EVALUATOR(v2, v + Vector2d::Ones());
-  VERIFY_IS_APPROX_EVALUATOR(w, (v + Vector2d::Ones()).transpose().cwiseProduct(RowVector2d::Constant(3)));
-
-  // dynamic matrices and arrays
-  MatrixXd mat1(6,6), mat2(6,6);
-  VERIFY_IS_APPROX_EVALUATOR(mat1, MatrixXd::Identity(6,6));
-  VERIFY_IS_APPROX_EVALUATOR(mat2, mat1);
-  copy_using_evaluator(mat2.transpose(), mat1);
-  VERIFY_IS_APPROX(mat2.transpose(), mat1);
-
-  ArrayXXd arr1(6,6), arr2(6,6);
-  VERIFY_IS_APPROX_EVALUATOR(arr1, ArrayXXd::Constant(6,6, 3.0));
-  VERIFY_IS_APPROX_EVALUATOR(arr2, arr1);
-  
-  // test automatic resizing
-  mat2.resize(3,3);
-  VERIFY_IS_APPROX_EVALUATOR(mat2, mat1);
-  arr2.resize(9,9);
-  VERIFY_IS_APPROX_EVALUATOR(arr2, arr1);
-
-  // test direct traversal
-  Matrix3f m3;
-  Array33f a3;
-  VERIFY_IS_APPROX_EVALUATOR(m3, Matrix3f::Identity());  // matrix, nullary
-  // TODO: find a way to test direct traversal with array
-  VERIFY_IS_APPROX_EVALUATOR(m3.transpose(), Matrix3f::Identity().transpose());  // transpose
-  VERIFY_IS_APPROX_EVALUATOR(m3, 2 * Matrix3f::Identity());  // unary
-  VERIFY_IS_APPROX_EVALUATOR(m3, Matrix3f::Identity() + Matrix3f::Zero());  // binary
-  VERIFY_IS_APPROX_EVALUATOR(m3.block(0,0,2,2), Matrix3f::Identity().block(1,1,2,2));  // block
-
-  // test linear traversal
-  VERIFY_IS_APPROX_EVALUATOR(m3, Matrix3f::Zero());  // matrix, nullary
-  VERIFY_IS_APPROX_EVALUATOR(a3, Array33f::Zero());  // array
-  VERIFY_IS_APPROX_EVALUATOR(m3.transpose(), Matrix3f::Zero().transpose());  // transpose
-  VERIFY_IS_APPROX_EVALUATOR(m3, 2 * Matrix3f::Zero());  // unary
-  VERIFY_IS_APPROX_EVALUATOR(m3, Matrix3f::Zero() + m3);  // binary  
-
-  // test inner vectorization
-  Matrix4f m4, m4src = Matrix4f::Random();
-  Array44f a4, a4src = Matrix4f::Random();
-  VERIFY_IS_APPROX_EVALUATOR(m4, m4src);  // matrix
-  VERIFY_IS_APPROX_EVALUATOR(a4, a4src);  // array
-  VERIFY_IS_APPROX_EVALUATOR(m4.transpose(), m4src.transpose());  // transpose
-  // TODO: find out why Matrix4f::Zero() does not allow inner vectorization
-  VERIFY_IS_APPROX_EVALUATOR(m4, 2 * m4src);  // unary
-  VERIFY_IS_APPROX_EVALUATOR(m4, m4src + m4src);  // binary
-
-  // test linear vectorization
-  MatrixXf mX(6,6), mXsrc = MatrixXf::Random(6,6);
-  ArrayXXf aX(6,6), aXsrc = ArrayXXf::Random(6,6);
-  VERIFY_IS_APPROX_EVALUATOR(mX, mXsrc);  // matrix
-  VERIFY_IS_APPROX_EVALUATOR(aX, aXsrc);  // array
-  VERIFY_IS_APPROX_EVALUATOR(mX.transpose(), mXsrc.transpose());  // transpose
-  VERIFY_IS_APPROX_EVALUATOR(mX, MatrixXf::Zero(6,6));  // nullary
-  VERIFY_IS_APPROX_EVALUATOR(mX, 2 * mXsrc);  // unary
-  VERIFY_IS_APPROX_EVALUATOR(mX, mXsrc + mXsrc);  // binary
-
-  // test blocks and slice vectorization
-  VERIFY_IS_APPROX_EVALUATOR(m4, (mXsrc.block<4,4>(1,0)));
-  VERIFY_IS_APPROX_EVALUATOR(aX, ArrayXXf::Constant(10, 10, 3.0).block(2, 3, 6, 6));
-
-  Matrix4f m4ref = m4;
-  copy_using_evaluator(m4.block(1, 1, 2, 3), m3.bottomRows(2));
-  m4ref.block(1, 1, 2, 3) = m3.bottomRows(2);
-  VERIFY_IS_APPROX(m4, m4ref);
-
-  mX.setIdentity(20,20);
-  MatrixXf mXref = MatrixXf::Identity(20,20);
-  mXsrc = MatrixXf::Random(9,12);
-  copy_using_evaluator(mX.block(4, 4, 9, 12), mXsrc);
-  mXref.block(4, 4, 9, 12) = mXsrc;
-  VERIFY_IS_APPROX(mX, mXref);
-
-  // test Map
-  const float raw[3] = {1,2,3};
-  float buffer[3] = {0,0,0};
-  Vector3f v3;
-  Array3f a3f;
-  VERIFY_IS_APPROX_EVALUATOR(v3, Map<const Vector3f>(raw));
-  VERIFY_IS_APPROX_EVALUATOR(a3f, Map<const Array3f>(raw));
-  Vector3f::Map(buffer) = 2*v3;
-  VERIFY(buffer[0] == 2);
-  VERIFY(buffer[1] == 4);
-  VERIFY(buffer[2] == 6);
-
-  // test CwiseUnaryView
-  mat1.setRandom();
-  mat2.setIdentity();
-  MatrixXcd matXcd(6,6), matXcd_ref(6,6);
-  copy_using_evaluator(matXcd.real(), mat1);
-  copy_using_evaluator(matXcd.imag(), mat2);
-  matXcd_ref.real() = mat1;
-  matXcd_ref.imag() = mat2;
-  VERIFY_IS_APPROX(matXcd, matXcd_ref);
-
-  // test Select
-  VERIFY_IS_APPROX_EVALUATOR(aX, (aXsrc > 0).select(aXsrc, -aXsrc));
-
-  // test Replicate
-  mXsrc = MatrixXf::Random(6, 6);
-  VectorXf vX = VectorXf::Random(6);
-  mX.resize(6, 6);
-  VERIFY_IS_APPROX_EVALUATOR(mX, mXsrc.colwise() + vX);
-  matXcd.resize(12, 12);
-  VERIFY_IS_APPROX_EVALUATOR(matXcd, matXcd_ref.replicate(2,2));
-  VERIFY_IS_APPROX_EVALUATOR(matXcd, (matXcd_ref.replicate<2,2>()));
-
-  // test partial reductions
-  VectorXd vec1(6);
-  VERIFY_IS_APPROX_EVALUATOR(vec1, mat1.rowwise().sum());
-  VERIFY_IS_APPROX_EVALUATOR(vec1, mat1.colwise().sum().transpose());
-
-  // test MatrixWrapper and ArrayWrapper
-  mat1.setRandom(6,6);
-  arr1.setRandom(6,6);
-  VERIFY_IS_APPROX_EVALUATOR(mat2, arr1.matrix());
-  VERIFY_IS_APPROX_EVALUATOR(arr2, mat1.array());
-  VERIFY_IS_APPROX_EVALUATOR(mat2, (arr1 + 2).matrix());
-  VERIFY_IS_APPROX_EVALUATOR(arr2, mat1.array() + 2);
-  mat2.array() = arr1 * arr1;
-  VERIFY_IS_APPROX(mat2, (arr1 * arr1).matrix());
-  arr2.matrix() = MatrixXd::Identity(6,6);
-  VERIFY_IS_APPROX(arr2, MatrixXd::Identity(6,6).array());
-
-  // test Reverse
-  VERIFY_IS_APPROX_EVALUATOR(arr2, arr1.reverse());
-  VERIFY_IS_APPROX_EVALUATOR(arr2, arr1.colwise().reverse());
-  VERIFY_IS_APPROX_EVALUATOR(arr2, arr1.rowwise().reverse());
-  arr2.reverse() = arr1;
-  VERIFY_IS_APPROX(arr2, arr1.reverse());
-  mat2.array() = mat1.array().reverse();
-  VERIFY_IS_APPROX(mat2.array(), mat1.array().reverse());
-
-  // test Diagonal
-  VERIFY_IS_APPROX_EVALUATOR(vec1, mat1.diagonal());
-  vec1.resize(5);
-  VERIFY_IS_APPROX_EVALUATOR(vec1, mat1.diagonal(1));
-  VERIFY_IS_APPROX_EVALUATOR(vec1, mat1.diagonal<-1>());
-  vec1.setRandom();
-
-  mat2 = mat1;
-  copy_using_evaluator(mat1.diagonal(1), vec1);
-  mat2.diagonal(1) = vec1;
-  VERIFY_IS_APPROX(mat1, mat2);
-
-  copy_using_evaluator(mat1.diagonal<-1>(), mat1.diagonal(1));
-  mat2.diagonal<-1>() = mat2.diagonal(1);
-  VERIFY_IS_APPROX(mat1, mat2);
+  {
+    ArrayXXf a(2,3);
+    ArrayXXf b(3,2);
+    a << 1,2,3, 4,5,6;
+    const ArrayXXf a_const(a);
+    
+    // this does not work because Random is eval-before-nested: 
+    // copy_using_evaluator(w, Vector2d::Random().transpose());
+    
+    // test CwiseUnaryOp
+    VERIFY_IS_APPROX_EVALUATOR(v2, 3 * v);
+    VERIFY_IS_APPROX_EVALUATOR(w, (3 * v).transpose());
+    VERIFY_IS_APPROX_EVALUATOR(b, (a + 3).transpose());
+    VERIFY_IS_APPROX_EVALUATOR(b, (2 * a_const + 3).transpose());
+
+    // test CwiseBinaryOp
+    VERIFY_IS_APPROX_EVALUATOR(v2, v + Vector2d::Ones());
+    VERIFY_IS_APPROX_EVALUATOR(w, (v + Vector2d::Ones()).transpose().cwiseProduct(RowVector2d::Constant(3)));
+
+    // dynamic matrices and arrays
+    MatrixXd mat1(6,6), mat2(6,6);
+    VERIFY_IS_APPROX_EVALUATOR(mat1, MatrixXd::Identity(6,6));
+    VERIFY_IS_APPROX_EVALUATOR(mat2, mat1);
+    copy_using_evaluator(mat2.transpose(), mat1);
+    VERIFY_IS_APPROX(mat2.transpose(), mat1);
+
+    ArrayXXd arr1(6,6), arr2(6,6);
+    VERIFY_IS_APPROX_EVALUATOR(arr1, ArrayXXd::Constant(6,6, 3.0));
+    VERIFY_IS_APPROX_EVALUATOR(arr2, arr1);
+    
+    // test automatic resizing
+    mat2.resize(3,3);
+    VERIFY_IS_APPROX_EVALUATOR(mat2, mat1);
+    arr2.resize(9,9);
+    VERIFY_IS_APPROX_EVALUATOR(arr2, arr1);
+
+    // test direct traversal
+    Matrix3f m3;
+    Array33f a3;
+    VERIFY_IS_APPROX_EVALUATOR(m3, Matrix3f::Identity());  // matrix, nullary
+    // TODO: find a way to test direct traversal with array
+    VERIFY_IS_APPROX_EVALUATOR(m3.transpose(), Matrix3f::Identity().transpose());  // transpose
+    VERIFY_IS_APPROX_EVALUATOR(m3, 2 * Matrix3f::Identity());  // unary
+    VERIFY_IS_APPROX_EVALUATOR(m3, Matrix3f::Identity() + Matrix3f::Zero());  // binary
+    VERIFY_IS_APPROX_EVALUATOR(m3.block(0,0,2,2), Matrix3f::Identity().block(1,1,2,2));  // block
+
+    // test linear traversal
+    VERIFY_IS_APPROX_EVALUATOR(m3, Matrix3f::Zero());  // matrix, nullary
+    VERIFY_IS_APPROX_EVALUATOR(a3, Array33f::Zero());  // array
+    VERIFY_IS_APPROX_EVALUATOR(m3.transpose(), Matrix3f::Zero().transpose());  // transpose
+    VERIFY_IS_APPROX_EVALUATOR(m3, 2 * Matrix3f::Zero());  // unary
+    VERIFY_IS_APPROX_EVALUATOR(m3, Matrix3f::Zero() + m3);  // binary  
+
+    // test inner vectorization
+    Matrix4f m4, m4src = Matrix4f::Random();
+    Array44f a4, a4src = Matrix4f::Random();
+    VERIFY_IS_APPROX_EVALUATOR(m4, m4src);  // matrix
+    VERIFY_IS_APPROX_EVALUATOR(a4, a4src);  // array
+    VERIFY_IS_APPROX_EVALUATOR(m4.transpose(), m4src.transpose());  // transpose
+    // TODO: find out why Matrix4f::Zero() does not allow inner vectorization
+    VERIFY_IS_APPROX_EVALUATOR(m4, 2 * m4src);  // unary
+    VERIFY_IS_APPROX_EVALUATOR(m4, m4src + m4src);  // binary
+
+    // test linear vectorization
+    MatrixXf mX(6,6), mXsrc = MatrixXf::Random(6,6);
+    ArrayXXf aX(6,6), aXsrc = ArrayXXf::Random(6,6);
+    VERIFY_IS_APPROX_EVALUATOR(mX, mXsrc);  // matrix
+    VERIFY_IS_APPROX_EVALUATOR(aX, aXsrc);  // array
+    VERIFY_IS_APPROX_EVALUATOR(mX.transpose(), mXsrc.transpose());  // transpose
+    VERIFY_IS_APPROX_EVALUATOR(mX, MatrixXf::Zero(6,6));  // nullary
+    VERIFY_IS_APPROX_EVALUATOR(mX, 2 * mXsrc);  // unary
+    VERIFY_IS_APPROX_EVALUATOR(mX, mXsrc + mXsrc);  // binary
+
+    // test blocks and slice vectorization
+    VERIFY_IS_APPROX_EVALUATOR(m4, (mXsrc.block<4,4>(1,0)));
+    VERIFY_IS_APPROX_EVALUATOR(aX, ArrayXXf::Constant(10, 10, 3.0).block(2, 3, 6, 6));
+
+    Matrix4f m4ref = m4;
+    copy_using_evaluator(m4.block(1, 1, 2, 3), m3.bottomRows(2));
+    m4ref.block(1, 1, 2, 3) = m3.bottomRows(2);
+    VERIFY_IS_APPROX(m4, m4ref);
+
+    mX.setIdentity(20,20);
+    MatrixXf mXref = MatrixXf::Identity(20,20);
+    mXsrc = MatrixXf::Random(9,12);
+    copy_using_evaluator(mX.block(4, 4, 9, 12), mXsrc);
+    mXref.block(4, 4, 9, 12) = mXsrc;
+    VERIFY_IS_APPROX(mX, mXref);
+
+    // test Map
+    const float raw[3] = {1,2,3};
+    float buffer[3] = {0,0,0};
+    Vector3f v3;
+    Array3f a3f;
+    VERIFY_IS_APPROX_EVALUATOR(v3, Map<const Vector3f>(raw));
+    VERIFY_IS_APPROX_EVALUATOR(a3f, Map<const Array3f>(raw));
+    Vector3f::Map(buffer) = 2*v3;
+    VERIFY(buffer[0] == 2);
+    VERIFY(buffer[1] == 4);
+    VERIFY(buffer[2] == 6);
+
+    // test CwiseUnaryView
+    mat1.setRandom();
+    mat2.setIdentity();
+    MatrixXcd matXcd(6,6), matXcd_ref(6,6);
+    copy_using_evaluator(matXcd.real(), mat1);
+    copy_using_evaluator(matXcd.imag(), mat2);
+    matXcd_ref.real() = mat1;
+    matXcd_ref.imag() = mat2;
+    VERIFY_IS_APPROX(matXcd, matXcd_ref);
+
+    // test Select
+    VERIFY_IS_APPROX_EVALUATOR(aX, (aXsrc > 0).select(aXsrc, -aXsrc));
+
+    // test Replicate
+    mXsrc = MatrixXf::Random(6, 6);
+    VectorXf vX = VectorXf::Random(6);
+    mX.resize(6, 6);
+    VERIFY_IS_APPROX_EVALUATOR(mX, mXsrc.colwise() + vX);
+    matXcd.resize(12, 12);
+    VERIFY_IS_APPROX_EVALUATOR(matXcd, matXcd_ref.replicate(2,2));
+    VERIFY_IS_APPROX_EVALUATOR(matXcd, (matXcd_ref.replicate<2,2>()));
+
+    // test partial reductions
+    VectorXd vec1(6);
+    VERIFY_IS_APPROX_EVALUATOR(vec1, mat1.rowwise().sum());
+    VERIFY_IS_APPROX_EVALUATOR(vec1, mat1.colwise().sum().transpose());
+
+    // test MatrixWrapper and ArrayWrapper
+    mat1.setRandom(6,6);
+    arr1.setRandom(6,6);
+    VERIFY_IS_APPROX_EVALUATOR(mat2, arr1.matrix());
+    VERIFY_IS_APPROX_EVALUATOR(arr2, mat1.array());
+    VERIFY_IS_APPROX_EVALUATOR(mat2, (arr1 + 2).matrix());
+    VERIFY_IS_APPROX_EVALUATOR(arr2, mat1.array() + 2);
+    mat2.array() = arr1 * arr1;
+    VERIFY_IS_APPROX(mat2, (arr1 * arr1).matrix());
+    arr2.matrix() = MatrixXd::Identity(6,6);
+    VERIFY_IS_APPROX(arr2, MatrixXd::Identity(6,6).array());
+
+    // test Reverse
+    VERIFY_IS_APPROX_EVALUATOR(arr2, arr1.reverse());
+    VERIFY_IS_APPROX_EVALUATOR(arr2, arr1.colwise().reverse());
+    VERIFY_IS_APPROX_EVALUATOR(arr2, arr1.rowwise().reverse());
+    arr2.reverse() = arr1;
+    VERIFY_IS_APPROX(arr2, arr1.reverse());
+    mat2.array() = mat1.array().reverse();
+    VERIFY_IS_APPROX(mat2.array(), mat1.array().reverse());
+
+    // test Diagonal
+    VERIFY_IS_APPROX_EVALUATOR(vec1, mat1.diagonal());
+    vec1.resize(5);
+    VERIFY_IS_APPROX_EVALUATOR(vec1, mat1.diagonal(1));
+    VERIFY_IS_APPROX_EVALUATOR(vec1, mat1.diagonal<-1>());
+    vec1.setRandom();
+
+    mat2 = mat1;
+    copy_using_evaluator(mat1.diagonal(1), vec1);
+    mat2.diagonal(1) = vec1;
+    VERIFY_IS_APPROX(mat1, mat2);
+
+    copy_using_evaluator(mat1.diagonal<-1>(), mat1.diagonal(1));
+    mat2.diagonal<-1>() = mat2.diagonal(1);
+    VERIFY_IS_APPROX(mat1, mat2);
+  }
   
   {
     // test swapping
diff --git a/test/inverse.cpp b/test/inverse.cpp
index 8978a1877..8dd35f6ac 100644
--- a/test/inverse.cpp
+++ b/test/inverse.cpp
@@ -86,14 +86,15 @@ template<typename MatrixType> void inverse(const MatrixType& m)
 
 void test_inverse()
 {
-  int s;
+  int s = 0;
+  s = s; // ICC shuts down ICC's remark #593: variable "s" was set but never used
   for(int i = 0; i < g_repeat; i++) {
     CALL_SUBTEST_1( inverse(Matrix<double,1,1>()) );
     CALL_SUBTEST_2( inverse(Matrix2d()) );
     CALL_SUBTEST_3( inverse(Matrix3f()) );
     CALL_SUBTEST_4( inverse(Matrix4f()) );
     CALL_SUBTEST_4( inverse(Matrix<float,4,4,DontAlign>()) );
-    s = internal::random<int>(50,320);
+    s = internal::random<int>(50,320); 
     CALL_SUBTEST_5( inverse(MatrixXf(s,s)) );
     s = internal::random<int>(25,100);
     CALL_SUBTEST_6( inverse(MatrixXcd(s,s)) );
diff --git a/test/jacobisvd.cpp b/test/jacobisvd.cpp
index 26da05037..8fda8d261 100644
--- a/test/jacobisvd.cpp
+++ b/test/jacobisvd.cpp
@@ -96,6 +96,10 @@ void jacobisvd_test_all_computation_options(const MatrixType& m)
   jacobisvd_check_full(m, fullSvd);
   jacobisvd_solve<MatrixType, QRPreconditioner>(m, ComputeFullU | ComputeFullV);
 
+  #if defined __INTEL_COMPILER
+  // remark #111: statement is unreachable
+  #pragma warning disable 111
+  #endif
   if(QRPreconditioner == FullPivHouseholderQRPreconditioner)
     return;
 
@@ -257,7 +261,7 @@ void jacobisvd_preallocate()
   MatrixXf m = v.asDiagonal();
 
   internal::set_is_malloc_allowed(false);
-  VERIFY_RAISES_ASSERT(VectorXf v(10);)
+  VERIFY_RAISES_ASSERT(VectorXf tmp(10);)
   JacobiSVD<MatrixXf> svd;
   internal::set_is_malloc_allowed(true);
   svd.compute(m);
@@ -320,6 +324,8 @@ void test_jacobisvd()
 
     int r = internal::random<int>(1, 30),
         c = internal::random<int>(1, 30);
+    r = r; // shuts down ICC's remark #593: variable "s" was set but never used
+    c = c;
     CALL_SUBTEST_7(( jacobisvd<MatrixXf>(MatrixXf(r,c)) ));
     CALL_SUBTEST_8(( jacobisvd<MatrixXcd>(MatrixXcd(r,c)) ));
     (void) r;
diff --git a/test/main.h b/test/main.h
index 93163c3cb..1094b6b36 100644
--- a/test/main.h
+++ b/test/main.h
@@ -49,11 +49,6 @@
 
 #define DEFAULT_REPEAT 10
 
-#ifdef __ICC
-// disable warning #279: controlling expression is constant
-#pragma warning disable 279
-#endif
-
 namespace Eigen
 {
   static std::vector<std::string> g_test_stack;
@@ -170,7 +165,7 @@ namespace Eigen
 #define EIGEN_INTERNAL_DEBUGGING
 #include <Eigen/QR> // required for createRandomPIMatrixOfRank
 
-static inline void verify_impl(bool condition, const char *testname, const char *file, int line, const char *condition_as_string)
+inline void verify_impl(bool condition, const char *testname, const char *file, int line, const char *condition_as_string)
 {
   if (!condition)
   {
@@ -297,7 +292,7 @@ inline bool test_isUnitary(const MatrixBase<Derived>& m)
 }
 
 template<typename T, typename U>
-static bool test_is_equal(const T& actual, const U& expected)
+inline bool test_is_equal(const T& actual, const U& expected)
 {
     if (actual==expected)
         return true;
@@ -313,8 +308,11 @@ static bool test_is_equal(const T& actual, const U& expected)
   * A partial isometry is a matrix all of whose singular values are either 0 or 1.
   * This is very useful to test rank-revealing algorithms.
   */
+// Forward declaration to avoid ICC warning
 template<typename MatrixType>
-static void createRandomPIMatrixOfRank(typename MatrixType::Index desired_rank, typename MatrixType::Index rows, typename MatrixType::Index cols, MatrixType& m)
+void createRandomPIMatrixOfRank(typename MatrixType::Index desired_rank, typename MatrixType::Index rows, typename MatrixType::Index cols, MatrixType& m);
+template<typename MatrixType>
+void createRandomPIMatrixOfRank(typename MatrixType::Index desired_rank, typename MatrixType::Index rows, typename MatrixType::Index cols, MatrixType& m)
 {
   typedef typename internal::traits<MatrixType>::Index Index;
   typedef typename internal::traits<MatrixType>::Scalar Scalar;
@@ -351,8 +349,11 @@ static void createRandomPIMatrixOfRank(typename MatrixType::Index desired_rank,
   m = qra.householderQ() * d * qrb.householderQ();
 }
 
+// Forward declaration to avoid ICC warning
+template<typename PermutationVectorType>
+void randomPermutationVector(PermutationVectorType& v, typename PermutationVectorType::Index size);
 template<typename PermutationVectorType>
-static void randomPermutationVector(PermutationVectorType& v, typename PermutationVectorType::Index size)
+void randomPermutationVector(PermutationVectorType& v, typename PermutationVectorType::Index size)
 {
   typedef typename PermutationVectorType::Index Index;
   typedef typename PermutationVectorType::Scalar Scalar;
@@ -392,7 +393,7 @@ void EIGEN_CAT(test_,EIGEN_TEST_FUNC)();
 
 using namespace Eigen;
 
-static void set_repeat_from_string(const char *str)
+inline void set_repeat_from_string(const char *str)
 {
   errno = 0;
   g_repeat = int(strtoul(str, 0, 10));
@@ -404,7 +405,7 @@ static void set_repeat_from_string(const char *str)
   g_has_set_repeat = true;
 }
 
-static void set_seed_from_string(const char *str)
+inline void set_seed_from_string(const char *str)
 {
   errno = 0;
   g_seed = int(strtoul(str, 0, 10));
@@ -488,5 +489,7 @@ int main(int argc, char *argv[])
   //  -> this warning is raised even for legal usage as: g_test_stack.push_back("foo"); where g_test_stack is a std::vector<std::string>
   // remark #1418: external function definition with no prior declaration
   //  -> this warning is raised for all our test functions. Declaring them static would fix the issue.
-  #pragma warning disable 383 1418
+  // warning #279: controlling expression is constant
+  // remark #1572: floating-point equality and inequality comparisons are unreliable
+  #pragma warning disable 279 383 1418 1572
 #endif
diff --git a/test/product_notemporary.cpp b/test/product_notemporary.cpp
index a30a8b4c7..258d238e2 100644
--- a/test/product_notemporary.cpp
+++ b/test/product_notemporary.cpp
@@ -9,7 +9,7 @@
 
 static int nb_temporaries;
 
-void on_temporary_creation(int size) {
+inline void on_temporary_creation(int size) {
   // here's a great place to set a breakpoint when debugging failures in this test!
   if(size!=0) nb_temporaries++;
 }
diff --git a/test/product_selfadjoint.cpp b/test/product_selfadjoint.cpp
index 58e2ea90d..e3e2b2cf1 100644
--- a/test/product_selfadjoint.cpp
+++ b/test/product_selfadjoint.cpp
@@ -62,7 +62,8 @@ template<typename MatrixType> void product_selfadjoint(const MatrixType& m)
 
 void test_product_selfadjoint()
 {
-  int s;
+  int s = 0;
+  s = s; // shuts down ICC's remark #593: variable "s" was set but never used
   for(int i = 0; i < g_repeat ; i++) {
     CALL_SUBTEST_1( product_selfadjoint(Matrix<float, 1, 1>()) );
     CALL_SUBTEST_2( product_selfadjoint(Matrix<float, 2, 2>()) );
diff --git a/test/product_trmv.cpp b/test/product_trmv.cpp
index 435018e8e..50a414b29 100644
--- a/test/product_trmv.cpp
+++ b/test/product_trmv.cpp
@@ -73,7 +73,8 @@ template<typename MatrixType> void trmv(const MatrixType& m)
 
 void test_product_trmv()
 {
-  int s;
+  int s = 0;
+  s = s; // shuts down ICC's remark #593: variable "s" was set but never used
   for(int i = 0; i < g_repeat ; i++) {
     CALL_SUBTEST_1( trmv(Matrix<float, 1, 1>()) );
     CALL_SUBTEST_2( trmv(Matrix<float, 2, 2>()) );
diff --git a/test/real_qz.cpp b/test/real_qz.cpp
index b48bac361..ed11e17f3 100644
--- a/test/real_qz.cpp
+++ b/test/real_qz.cpp
@@ -48,7 +48,8 @@ template<typename MatrixType> void real_qz(const MatrixType& m)
 
 void test_real_qz()
 {
-  int s;
+  int s = 0;
+  s = s; // shuts down ICC's remark #593: variable "s" was set but never used
   for(int i = 0; i < g_repeat; i++) {
     CALL_SUBTEST_1( real_qz(Matrix4f()) );
     s = internal::random<int>(1,EIGEN_TEST_MAX_SIZE/4);
diff --git a/test/redux.cpp b/test/redux.cpp
index bf68d2212..26082527e 100644
--- a/test/redux.cpp
+++ b/test/redux.cpp
@@ -133,6 +133,7 @@ void test_redux()
 {
   // the max size cannot be too large, otherwise reduxion operations obviously generate large errors.
   int maxsize = (std::min)(100,EIGEN_TEST_MAX_SIZE);
+  maxsize = maxsize; // shuts down ICC's remark #593: variable "s" was set but never used
   EIGEN_UNUSED_VARIABLE(maxsize);
   for(int i = 0; i < g_repeat; i++) {
     CALL_SUBTEST_1( matrixRedux(Matrix<float, 1, 1>()) );
diff --git a/test/ref.cpp b/test/ref.cpp
index 7c0ccafcf..65b4f5a3e 100644
--- a/test/ref.cpp
+++ b/test/ref.cpp
@@ -14,7 +14,7 @@
 
 static int nb_temporaries;
 
-void on_temporary_creation(int size) {
+inline void on_temporary_creation(int size) {
   // here's a great place to set a breakpoint when debugging failures in this test!
   if(size!=0) nb_temporaries++;
 }
diff --git a/test/selfadjoint.cpp b/test/selfadjoint.cpp
index 32791eeb5..ab8eb8173 100644
--- a/test/selfadjoint.cpp
+++ b/test/selfadjoint.cpp
@@ -46,7 +46,8 @@ void test_selfadjoint()
 {
   for(int i = 0; i < g_repeat ; i++)
   {
-    int s = internal::random<int>(1,EIGEN_TEST_MAX_SIZE); EIGEN_UNUSED_VARIABLE(s);
+    int s = internal::random<int>(1,EIGEN_TEST_MAX_SIZE);
+    s = s; // shuts down ICC's remark #593: variable "s" was set but never used
 
     CALL_SUBTEST_1( selfadjoint(Matrix<float, 1, 1>()) );
     CALL_SUBTEST_2( selfadjoint(Matrix<float, 2, 2>()) );
diff --git a/test/sparse_basic.cpp b/test/sparse_basic.cpp
index e300f2537..6954ba7f9 100644
--- a/test/sparse_basic.cpp
+++ b/test/sparse_basic.cpp
@@ -25,71 +25,73 @@ template<typename SparseMatrixType> void sparse_basic(const SparseMatrixType& re
   typedef Matrix<Scalar,Dynamic,1> DenseVector;
   Scalar eps = 1e-6;
 
-  SparseMatrixType m(rows, cols);
-  DenseMatrix refMat = DenseMatrix::Zero(rows, cols);
-  DenseVector vec1 = DenseVector::Random(rows);
   Scalar s1 = internal::random<Scalar>();
-
-  std::vector<Vector2i> zeroCoords;
-  std::vector<Vector2i> nonzeroCoords;
-  initSparse<Scalar>(density, refMat, m, 0, &zeroCoords, &nonzeroCoords);
-
-  if (zeroCoords.size()==0 || nonzeroCoords.size()==0)
-    return;
-
-  // test coeff and coeffRef
-  for (int i=0; i<(int)zeroCoords.size(); ++i)
   {
-    VERIFY_IS_MUCH_SMALLER_THAN( m.coeff(zeroCoords[i].x(),zeroCoords[i].y()), eps );
-    if(internal::is_same<SparseMatrixType,SparseMatrix<Scalar,Flags> >::value)
-      VERIFY_RAISES_ASSERT( m.coeffRef(zeroCoords[0].x(),zeroCoords[0].y()) = 5 );
-  }
-  VERIFY_IS_APPROX(m, refMat);
+    SparseMatrixType m(rows, cols);
+    DenseMatrix refMat = DenseMatrix::Zero(rows, cols);
+    DenseVector vec1 = DenseVector::Random(rows);
 
-  m.coeffRef(nonzeroCoords[0].x(), nonzeroCoords[0].y()) = Scalar(5);
-  refMat.coeffRef(nonzeroCoords[0].x(), nonzeroCoords[0].y()) = Scalar(5);
+    std::vector<Vector2i> zeroCoords;
+    std::vector<Vector2i> nonzeroCoords;
+    initSparse<Scalar>(density, refMat, m, 0, &zeroCoords, &nonzeroCoords);
 
-  VERIFY_IS_APPROX(m, refMat);
-  /*
-  // test InnerIterators and Block expressions
-  for (int t=0; t<10; ++t)
-  {
-    int j = internal::random<int>(0,cols-1);
-    int i = internal::random<int>(0,rows-1);
-    int w = internal::random<int>(1,cols-j-1);
-    int h = internal::random<int>(1,rows-i-1);
+    if (zeroCoords.size()==0 || nonzeroCoords.size()==0)
+      return;
 
-//     VERIFY_IS_APPROX(m.block(i,j,h,w), refMat.block(i,j,h,w));
-    for(int c=0; c<w; c++)
+    // test coeff and coeffRef
+    for (int i=0; i<(int)zeroCoords.size(); ++i)
     {
-      VERIFY_IS_APPROX(m.block(i,j,h,w).col(c), refMat.block(i,j,h,w).col(c));
-      for(int r=0; r<h; r++)
+      VERIFY_IS_MUCH_SMALLER_THAN( m.coeff(zeroCoords[i].x(),zeroCoords[i].y()), eps );
+      if(internal::is_same<SparseMatrixType,SparseMatrix<Scalar,Flags> >::value)
+        VERIFY_RAISES_ASSERT( m.coeffRef(zeroCoords[0].x(),zeroCoords[0].y()) = 5 );
+    }
+    VERIFY_IS_APPROX(m, refMat);
+
+    m.coeffRef(nonzeroCoords[0].x(), nonzeroCoords[0].y()) = Scalar(5);
+    refMat.coeffRef(nonzeroCoords[0].x(), nonzeroCoords[0].y()) = Scalar(5);
+
+    VERIFY_IS_APPROX(m, refMat);
+      /*
+      // test InnerIterators and Block expressions
+      for (int t=0; t<10; ++t)
       {
-//         VERIFY_IS_APPROX(m.block(i,j,h,w).col(c).coeff(r), refMat.block(i,j,h,w).col(c).coeff(r));
+        int j = internal::random<int>(0,cols-1);
+        int i = internal::random<int>(0,rows-1);
+        int w = internal::random<int>(1,cols-j-1);
+        int h = internal::random<int>(1,rows-i-1);
+
+    //     VERIFY_IS_APPROX(m.block(i,j,h,w), refMat.block(i,j,h,w));
+        for(int c=0; c<w; c++)
+        {
+          VERIFY_IS_APPROX(m.block(i,j,h,w).col(c), refMat.block(i,j,h,w).col(c));
+          for(int r=0; r<h; r++)
+          {
+    //         VERIFY_IS_APPROX(m.block(i,j,h,w).col(c).coeff(r), refMat.block(i,j,h,w).col(c).coeff(r));
+          }
+        }
+    //     for(int r=0; r<h; r++)
+    //     {
+    //       VERIFY_IS_APPROX(m.block(i,j,h,w).row(r), refMat.block(i,j,h,w).row(r));
+    //       for(int c=0; c<w; c++)
+    //       {
+    //         VERIFY_IS_APPROX(m.block(i,j,h,w).row(r).coeff(c), refMat.block(i,j,h,w).row(r).coeff(c));
+    //       }
+    //     }
       }
-    }
-//     for(int r=0; r<h; r++)
-//     {
-//       VERIFY_IS_APPROX(m.block(i,j,h,w).row(r), refMat.block(i,j,h,w).row(r));
-//       for(int c=0; c<w; c++)
-//       {
-//         VERIFY_IS_APPROX(m.block(i,j,h,w).row(r).coeff(c), refMat.block(i,j,h,w).row(r).coeff(c));
-//       }
-//     }
-  }
 
-  for(int c=0; c<cols; c++)
-  {
-    VERIFY_IS_APPROX(m.col(c) + m.col(c), (m + m).col(c));
-    VERIFY_IS_APPROX(m.col(c) + m.col(c), refMat.col(c) + refMat.col(c));
-  }
+      for(int c=0; c<cols; c++)
+      {
+        VERIFY_IS_APPROX(m.col(c) + m.col(c), (m + m).col(c));
+        VERIFY_IS_APPROX(m.col(c) + m.col(c), refMat.col(c) + refMat.col(c));
+      }
 
-  for(int r=0; r<rows; r++)
-  {
-    VERIFY_IS_APPROX(m.row(r) + m.row(r), (m + m).row(r));
-    VERIFY_IS_APPROX(m.row(r) + m.row(r), refMat.row(r) + refMat.row(r));
-  }
-  */
+      for(int r=0; r<rows; r++)
+      {
+        VERIFY_IS_APPROX(m.row(r) + m.row(r), (m + m).row(r));
+        VERIFY_IS_APPROX(m.row(r) + m.row(r), refMat.row(r) + refMat.row(r));
+      }
+      */
+    }
 
     // test insert (inner random)
     {
diff --git a/test/sparse_solver.h b/test/sparse_solver.h
index 645a965bb..d84aff070 100644
--- a/test/sparse_solver.h
+++ b/test/sparse_solver.h
@@ -17,53 +17,54 @@ void check_sparse_solving(Solver& solver, const typename Solver::MatrixType& A,
   typedef typename Mat::Scalar Scalar;
 
   DenseRhs refX = dA.lu().solve(db);
+  {
+    Rhs x(b.rows(), b.cols());
+    Rhs oldb = b;
 
-  Rhs x(b.rows(), b.cols());
-  Rhs oldb = b;
+    solver.compute(A);
+    if (solver.info() != Success)
+    {
+      std::cerr << "sparse solver testing: factorization failed (check_sparse_solving)\n";
+      exit(0);
+      return;
+    }
+    x = solver.solve(b);
+    if (solver.info() != Success)
+    {
+      std::cerr << "sparse solver testing: solving failed\n";
+      return;
+    }
+    VERIFY(oldb.isApprox(b) && "sparse solver testing: the rhs should not be modified!");
 
-  solver.compute(A);
-  if (solver.info() != Success)
-  {
-    std::cerr << "sparse solver testing: factorization failed (check_sparse_solving)\n";
-    exit(0);
-    return;
-  }
-  x = solver.solve(b);
-  if (solver.info() != Success)
-  {
-    std::cerr << "sparse solver testing: solving failed\n";
-    return;
-  }
-  VERIFY(oldb.isApprox(b) && "sparse solver testing: the rhs should not be modified!");
+    VERIFY(x.isApprox(refX,test_precision<Scalar>()));
+    x.setZero();
+    // test the analyze/factorize API
+    solver.analyzePattern(A);
+    solver.factorize(A);
+    if (solver.info() != Success)
+    {
+      std::cerr << "sparse solver testing: factorization failed (check_sparse_solving)\n";
+      exit(0);
+      return;
+    }
+    x = solver.solve(b);
+    if (solver.info() != Success)
+    {
+      std::cerr << "sparse solver testing: solving failed\n";
+      return;
+    }
+    VERIFY(oldb.isApprox(b) && "sparse solver testing: the rhs should not be modified!");
 
-  VERIFY(x.isApprox(refX,test_precision<Scalar>()));
-  x.setZero();
-  // test the analyze/factorize API
-  solver.analyzePattern(A);
-  solver.factorize(A);
-  if (solver.info() != Success)
-  {
-    std::cerr << "sparse solver testing: factorization failed (check_sparse_solving)\n";
-    exit(0);
-    return;
-  }
-  x = solver.solve(b);
-  if (solver.info() != Success)
-  {
-    std::cerr << "sparse solver testing: solving failed\n";
-    return;
+    VERIFY(x.isApprox(refX,test_precision<Scalar>()));
   }
-  VERIFY(oldb.isApprox(b) && "sparse solver testing: the rhs should not be modified!");
-
-  VERIFY(x.isApprox(refX,test_precision<Scalar>()));
   
-  // test Block as the result and rhs:
+  // test dense Block as the result and rhs:
   {
     DenseRhs x(db.rows(), db.cols());
-    DenseRhs b(db), oldb(db);
+    DenseRhs oldb(db);
     x.setZero();
-    x.block(0,0,x.rows(),x.cols()) = solver.solve(b.block(0,0,b.rows(),b.cols()));
-    VERIFY(oldb.isApprox(b) && "sparse solver testing: the rhs should not be modified!");
+    x.block(0,0,x.rows(),x.cols()) = solver.solve(db.block(0,0,db.rows(),db.cols()));
+    VERIFY(oldb.isApprox(db) && "sparse solver testing: the rhs should not be modified!");
     VERIFY(x.isApprox(refX,test_precision<Scalar>()));
   }
 }
diff --git a/test/triangular.cpp b/test/triangular.cpp
index a2a7a1475..78b2c31f7 100644
--- a/test/triangular.cpp
+++ b/test/triangular.cpp
@@ -211,8 +211,8 @@ void test_triangular()
   int maxsize = (std::min)(EIGEN_TEST_MAX_SIZE,20);
   for(int i = 0; i < g_repeat ; i++)
   {
-    int r = internal::random<int>(2,maxsize); EIGEN_UNUSED_VARIABLE(r);
-    int c = internal::random<int>(2,maxsize); EIGEN_UNUSED_VARIABLE(c);
+    int r = internal::random<int>(2,maxsize); r=r; // shuts down ICC's remark #593: variable "s" was set but never used
+    int c = internal::random<int>(2,maxsize); c=c;
 
     CALL_SUBTEST_1( triangular_square(Matrix<float, 1, 1>()) );
     CALL_SUBTEST_2( triangular_square(Matrix<float, 2, 2>()) );