diff --git a/GPy/testing/unit_tests.py b/GPy/testing/unit_tests.py
index ff6abf33..246d40d1 100644
--- a/GPy/testing/unit_tests.py
+++ b/GPy/testing/unit_tests.py
@@ -23,7 +23,7 @@ class GradientTests(unittest.TestCase):
         self.X2D = np.random.uniform(-3., 3., (40, 2))
         self.Y2D = np.sin(self.X2D[:, 0:1]) * np.sin(self.X2D[:, 1:2]) + np.random.randn(40, 1) * 0.05
 
-    def check_model_with_white(self, kern, model_type='GPRegression', dimension=1, uncertain_inputs=False):
+    def check_model(self, kern, model_type='GPRegression', dimension=1, uncertain_inputs=False):
         # Get the correct gradients
         if dimension == 1:
             X = self.X1D
@@ -34,8 +34,8 @@ class GradientTests(unittest.TestCase):
         # Get model type (GPRegression, SparseGPRegression, etc)
         model_fit = getattr(GPy.models, model_type)
 
-        noise = GPy.kern.white(dimension)
-        kern = kern + noise
+        # noise = GPy.kern.white(dimension)
+        kern = kern #  + noise
         if uncertain_inputs:
             m = model_fit(X, Y, kernel=kern, X_variance=np.random.rand(X.shape[0], X.shape[1]))
         else:
@@ -47,135 +47,135 @@ class GradientTests(unittest.TestCase):
     def test_GPRegression_rbf_1d(self):
         ''' Testing the GP regression with rbf kernel with white kernel on 1d data '''
         rbf = GPy.kern.rbf(1)
-        self.check_model_with_white(rbf, model_type='GPRegression', dimension=1)
+        self.check_model(rbf, model_type='GPRegression', dimension=1)
 
     def test_GPRegression_rbf_2D(self):
-        ''' Testing the GP regression with rbf and white kernel on 2d data '''
+        ''' Testing the GP regression with rbf kernel on 2d data '''
         rbf = GPy.kern.rbf(2)
-        self.check_model_with_white(rbf, model_type='GPRegression', dimension=2)
+        self.check_model(rbf, model_type='GPRegression', dimension=2)
 
     def test_GPRegression_rbf_ARD_2D(self):
-        ''' Testing the GP regression with rbf and white kernel on 2d data '''
+        ''' Testing the GP regression with rbf kernel on 2d data '''
         k = GPy.kern.rbf(2, ARD=True)
-        self.check_model_with_white(k, model_type='GPRegression', dimension=2)
+        self.check_model(k, model_type='GPRegression', dimension=2)
 
     def test_GPRegression_mlp_1d(self):
         ''' Testing the GP regression with mlp kernel with white kernel on 1d data '''
         mlp = GPy.kern.mlp(1)
-        self.check_model_with_white(mlp, model_type='GPRegression', dimension=1)
+        self.check_model(mlp, model_type='GPRegression', dimension=1)
 
     def test_GPRegression_poly_1d(self):
         ''' Testing the GP regression with polynomial kernel with white kernel on 1d data '''
         mlp = GPy.kern.poly(1, degree=5)
-        self.check_model_with_white(mlp, model_type='GPRegression', dimension=1)
+        self.check_model(mlp, model_type='GPRegression', dimension=1)
 
     def test_GPRegression_matern52_1D(self):
         ''' Testing the GP regression with matern52 kernel on 1d data '''
         matern52 = GPy.kern.Matern52(1)
-        self.check_model_with_white(matern52, model_type='GPRegression', dimension=1)
+        self.check_model(matern52, model_type='GPRegression', dimension=1)
 
     def test_GPRegression_matern52_2D(self):
         ''' Testing the GP regression with matern52 kernel on 2d data '''
         matern52 = GPy.kern.Matern52(2)
-        self.check_model_with_white(matern52, model_type='GPRegression', dimension=2)
+        self.check_model(matern52, model_type='GPRegression', dimension=2)
 
     def test_GPRegression_matern52_ARD_2D(self):
         ''' Testing the GP regression with matern52 kernel on 2d data '''
         matern52 = GPy.kern.Matern52(2, ARD=True)
-        self.check_model_with_white(matern52, model_type='GPRegression', dimension=2)
+        self.check_model(matern52, model_type='GPRegression', dimension=2)
 
     def test_GPRegression_matern32_1D(self):
         ''' Testing the GP regression with matern32 kernel on 1d data '''
         matern32 = GPy.kern.Matern32(1)
-        self.check_model_with_white(matern32, model_type='GPRegression', dimension=1)
+        self.check_model(matern32, model_type='GPRegression', dimension=1)
 
     def test_GPRegression_matern32_2D(self):
         ''' Testing the GP regression with matern32 kernel on 2d data '''
         matern32 = GPy.kern.Matern32(2)
-        self.check_model_with_white(matern32, model_type='GPRegression', dimension=2)
+        self.check_model(matern32, model_type='GPRegression', dimension=2)
 
     def test_GPRegression_matern32_ARD_2D(self):
         ''' Testing the GP regression with matern32 kernel on 2d data '''
         matern32 = GPy.kern.Matern32(2, ARD=True)
-        self.check_model_with_white(matern32, model_type='GPRegression', dimension=2)
+        self.check_model(matern32, model_type='GPRegression', dimension=2)
 
     def test_GPRegression_exponential_1D(self):
         ''' Testing the GP regression with exponential kernel on 1d data '''
         exponential = GPy.kern.exponential(1)
-        self.check_model_with_white(exponential, model_type='GPRegression', dimension=1)
+        self.check_model(exponential, model_type='GPRegression', dimension=1)
 
     def test_GPRegression_exponential_2D(self):
         ''' Testing the GP regression with exponential kernel on 2d data '''
         exponential = GPy.kern.exponential(2)
-        self.check_model_with_white(exponential, model_type='GPRegression', dimension=2)
+        self.check_model(exponential, model_type='GPRegression', dimension=2)
 
     def test_GPRegression_exponential_ARD_2D(self):
         ''' Testing the GP regression with exponential kernel on 2d data '''
         exponential = GPy.kern.exponential(2, ARD=True)
-        self.check_model_with_white(exponential, model_type='GPRegression', dimension=2)
+        self.check_model(exponential, model_type='GPRegression', dimension=2)
 
     def test_GPRegression_bias_kern_1D(self):
         ''' Testing the GP regression with bias kernel on 1d data '''
         bias = GPy.kern.bias(1)
-        self.check_model_with_white(bias, model_type='GPRegression', dimension=1)
+        self.check_model(bias, model_type='GPRegression', dimension=1)
 
     def test_GPRegression_bias_kern_2D(self):
         ''' Testing the GP regression with bias kernel on 2d data '''
         bias = GPy.kern.bias(2)
-        self.check_model_with_white(bias, model_type='GPRegression', dimension=2)
+        self.check_model(bias, model_type='GPRegression', dimension=2)
 
     def test_GPRegression_linear_kern_1D_ARD(self):
         ''' Testing the GP regression with linear kernel on 1d data '''
         linear = GPy.kern.linear(1, ARD=True)
-        self.check_model_with_white(linear, model_type='GPRegression', dimension=1)
+        self.check_model(linear, model_type='GPRegression', dimension=1)
 
     def test_GPRegression_linear_kern_2D_ARD(self):
         ''' Testing the GP regression with linear kernel on 2d data '''
         linear = GPy.kern.linear(2, ARD=True)
-        self.check_model_with_white(linear, model_type='GPRegression', dimension=2)
+        self.check_model(linear, model_type='GPRegression', dimension=2)
 
     def test_GPRegression_linear_kern_1D(self):
         ''' Testing the GP regression with linear kernel on 1d data '''
         linear = GPy.kern.linear(1)
-        self.check_model_with_white(linear, model_type='GPRegression', dimension=1)
+        self.check_model(linear, model_type='GPRegression', dimension=1)
 
     def test_GPRegression_linear_kern_2D(self):
         ''' Testing the GP regression with linear kernel on 2d data '''
         linear = GPy.kern.linear(2)
-        self.check_model_with_white(linear, model_type='GPRegression', dimension=2)
+        self.check_model(linear, model_type='GPRegression', dimension=2)
 
     def test_SparseGPRegression_rbf_white_kern_1d(self):
         ''' Testing the sparse GP regression with rbf kernel with white kernel on 1d data '''
         rbf = GPy.kern.rbf(1)
-        self.check_model_with_white(rbf, model_type='SparseGPRegression', dimension=1)
+        self.check_model(rbf, model_type='SparseGPRegression', dimension=1)
 
     def test_SparseGPRegression_rbf_white_kern_2D(self):
-        ''' Testing the sparse GP regression with rbf and white kernel on 2d data '''
+        ''' Testing the sparse GP regression with rbf kernel on 2d data '''
         rbf = GPy.kern.rbf(2)
-        self.check_model_with_white(rbf, model_type='SparseGPRegression', dimension=2)
+        self.check_model(rbf, model_type='SparseGPRegression', dimension=2)
 
     def test_SparseGPRegression_rbf_linear_white_kern_1D(self):
-        ''' Testing the sparse GP regression with rbf and white kernel on 2d data '''
+        ''' Testing the sparse GP regression with rbf kernel on 2d data '''
         rbflin = GPy.kern.rbf(1) + GPy.kern.linear(1)
-        self.check_model_with_white(rbflin, model_type='SparseGPRegression', dimension=1)
+        self.check_model(rbflin, model_type='SparseGPRegression', dimension=1)
 
     def test_SparseGPRegression_rbf_linear_white_kern_2D(self):
-        ''' Testing the sparse GP regression with rbf and white kernel on 2d data '''
+        ''' Testing the sparse GP regression with rbf kernel on 2d data '''
         rbflin = GPy.kern.rbf(2) + GPy.kern.linear(2)
-        self.check_model_with_white(rbflin, model_type='SparseGPRegression', dimension=2)
+        self.check_model(rbflin, model_type='SparseGPRegression', dimension=2)
 
     def test_SparseGPRegression_rbf_linear_white_kern_2D_uncertain_inputs(self):
-        ''' Testing the sparse GP regression with rbf, linear and white kernel on 2d data with uncertain inputs'''
+        ''' Testing the sparse GP regression with rbf, linear kernel on 2d data with uncertain inputs'''
         rbflin = GPy.kern.rbf(2) + GPy.kern.linear(2)
-        self.check_model_with_white(rbflin, model_type='SparseGPRegression', dimension=2, uncertain_inputs=1)
+        self.check_model(rbflin, model_type='SparseGPRegression', dimension=2, uncertain_inputs=1)
 
     def test_SparseGPRegression_rbf_linear_white_kern_1D_uncertain_inputs(self):
-        ''' Testing the sparse GP regression with rbf, linear and white kernel on 1d data with uncertain inputs'''
+        ''' Testing the sparse GP regression with rbf, linear kernel on 1d data with uncertain inputs'''
         rbflin = GPy.kern.rbf(1) + GPy.kern.linear(1)
-        self.check_model_with_white(rbflin, model_type='SparseGPRegression', dimension=1, uncertain_inputs=1)
+        self.check_model(rbflin, model_type='SparseGPRegression', dimension=1, uncertain_inputs=1)
 
     def test_GPLVM_rbf_bias_white_kern_2D(self):
-        """ Testing GPLVM with rbf + bias and white kernel """
+        """ Testing GPLVM with rbf + bias kernel """
         N, input_dim, D = 50, 1, 2
         X = np.random.rand(N, input_dim)
         k = GPy.kern.rbf(input_dim, 0.5, 0.9 * np.ones((1,))) + GPy.kern.bias(input_dim, 0.1) + GPy.kern.white(input_dim, 0.05)
@@ -185,7 +185,7 @@ class GradientTests(unittest.TestCase):
         self.assertTrue(m.checkgrad())
 
     def test_GPLVM_rbf_linear_white_kern_2D(self):
-        """ Testing GPLVM with rbf + bias and white kernel """
+        """ Testing GPLVM with rbf + bias kernel """
         N, input_dim, D = 50, 1, 2
         X = np.random.rand(N, input_dim)
         k = GPy.kern.linear(input_dim) + GPy.kern.bias(input_dim, 0.1) + GPy.kern.white(input_dim, 0.05)