scikit-learn
diff --git a/‎sklearn/linear_model/base.py
+4-4 b/‎sklearn/linear_model/base.py
+4-4
diff --git a/‎sklearn/linear_model/tests/test_base.py
+15-10 b/‎sklearn/linear_model/tests/test_base.py
+15-10
@@ -436,14 +436,14 @@ def fit(self, X, y, sample_weight=None):
                 sample_weight).ndim > 1):
             sample_weight = column_or_1d(sample_weight, warn=True)
 
-        X, y, X_mean, y_mean, X_std = self._center_data(
-            X, y, self.fit_intercept, self.normalize, self.copy_X,
-            sample_weight=sample_weight)
-
         if sample_weight is not None:
             # Sample weight can be implemented via a simple rescaling.
             X, y = _rescale_data(X, y, sample_weight)
 
+        X, y, X_mean, y_mean, X_std = self._center_data(
+            X, y, self.fit_intercept, self.normalize, self.copy_X,
+            sample_weight=None)
+
         if sp.issparse(X):
             if y.ndim < 2:
                 out = sparse_lsqr(X, y)
 
@@ -16,6 +16,7 @@
 from sklearn.utils.testing import assert_greater
 from sklearn.datasets.samples_generator import make_sparse_uncorrelated
 from sklearn.datasets.samples_generator import make_regression
+from sklearn.metrics import r2_score
 
 
 def test_linear_regression():
@@ -44,28 +45,33 @@ def test_linear_regression():
 
 def test_linear_regression_sample_weights():
     rng = np.random.RandomState(0)
+    n_samples, n_features = 6, 50  # over-determined system
 
-    for n_samples, n_features in ((6, 5), (5, 10)):
+    for fit_intercept in [True, False]:
         y = rng.randn(n_samples)
         X = rng.randn(n_samples, n_features)
         sample_weight = 1.0 + rng.rand(n_samples)
 
-        clf = LinearRegression()
-        clf.fit(X, y, sample_weight)
-        coefs1 = clf.coef_
+        reg = LinearRegression(fit_intercept=fit_intercept)
+        reg.fit(X, y, sample_weight=sample_weight)
+        coefs1 = reg.coef_
+        intercept1 = reg.intercept_
 
-        assert_equal(clf.coef_.shape, (X.shape[1], ))
-        assert_greater(clf.score(X, y), 0.9)
-        assert_array_almost_equal(clf.predict(X), y)
+        assert_equal(reg.coef_.shape, (X.shape[1], ))
+        assert_greater(reg.score(X, y, sample_weight=sample_weight), 0.9)
+        assert_greater(r2_score(y, reg.predict(X),
+                       sample_weight=sample_weight), 0.9)  # same as above
 
         # Sample weight can be implemented via a simple rescaling
         # for the square loss.
         scaled_y = y * np.sqrt(sample_weight)
         scaled_X = X * np.sqrt(sample_weight)[:, np.newaxis]
-        clf.fit(X, y)
-        coefs2 = clf.coef_
+        reg.fit(scaled_X, scaled_y)
+        coefs2 = reg.coef_
+        intercept2 = reg.intercept_
 
         assert_array_almost_equal(coefs1, coefs2)
+        assert_array_almost_equal(intercept1, intercept2)
 
 
 def test_raises_value_error_if_sample_weights_greater_than_1d():
@@ -321,4 +327,3 @@ def test_rescale_data():
     rescaled_y2 = y * np.sqrt(sample_weight)
     assert_array_almost_equal(rescaled_X, rescaled_X2)
     assert_array_almost_equal(rescaled_y, rescaled_y2)
-