From 46f38292215908c2a05d3d0eb6e02d4cfcc6ee2d Mon Sep 17 00:00:00 2001
From: arokem <arokem@gmail.com>
Date: Tue, 22 Nov 2016 13:49:30 -0800
Subject: [PATCH] Replace nose.tools with numpy.testing and assert_true with
 assert_

---
 popeye/tests/test_auditory.py         |  65 +++++++--------
 popeye/tests/test_auditory_bin.py     |  39 +++++----
 popeye/tests/test_auditory_bin_pct.py |  37 ++++-----
 popeye/tests/test_css.py              |  41 +++++----
 popeye/tests/test_css_nohrf.py        |  43 +++++-----
 popeye/tests/test_dog.py              |  46 +++++------
 popeye/tests/test_og.py               |  89 ++++++++++----------
 popeye/tests/test_ogb.py              |  58 +++++++------
 popeye/tests/test_ogb_nohrf.py        |  76 +++++++++--------
 popeye/tests/test_spinach.py          |  53 ++++++------
 popeye/tests/test_stimulus.py         |  71 ++++++++--------
 popeye/tests/test_strf.py             |  99 +++++++++++-----------
 popeye/tests/test_utilities.py        | 115 +++++++++++++-------------
 popeye/tests/test_xvalidation.py      |  67 ++++++++-------
 14 files changed, 440 insertions(+), 459 deletions(-)

diff --git a/popeye/tests/test_auditory.py b/popeye/tests/test_auditory.py
index 1648ae8..cc507fb 100644
--- a/popeye/tests/test_auditory.py
+++ b/popeye/tests/test_auditory.py
@@ -4,7 +4,6 @@
 from matplotlib.pyplot import specgram
 
 import numpy as np
-import nose.tools as nt
 import numpy.testing as npt
 from scipy.signal import chirp
 
@@ -13,7 +12,7 @@
 from popeye.auditory_stimulus import AuditoryStimulus
 
 def test_auditory_fit():
-    
+
     # stimulus features
     lo_freq = 200 # Hz
     hi_freq = 12000 # Hz
@@ -29,63 +28,63 @@ def test_auditory_fit():
     verbose = 0
     resample_factor = 10
     dtype = ctypes.c_double
-    
+
     # sample the time from 0-duration by the fs
     time = np.linspace(0,duration,duration*Fs)
-    
+
     # create a chirp stimulus
     ch = chirp(time, lo_freq, duration, hi_freq, method='quadratic')
     signal = np.concatenate((ch,ch[::-1]))
-        
+
     # instantiate an instance of the Stimulus class
     stimulus = AuditoryStimulus(signal, NFFT, Fs, noverlap, resample_factor, dtype, tr_length)
-    
+
     # initialize the gaussian model
     model = aud.AuditoryModel(stimulus, utils.double_gamma_hrf)
-    
+
     # generate a random pRF estimate
     center_freq = 8910.0
     sigma = 567.0
     beta = 0.88
     baseline = -1.5
     hrf_delay = -0.25
-    
+
     # create the "data"
     data = model.generate_prediction(center_freq, sigma, beta, baseline, hrf_delay)
-    
+
     # set search grid
     c_grid = (lo_freq,hi_freq)
     s_grid = (lo_freq,hi_freq)
     b_grid = (0.1,1)
     bl_grid = (-3,3)
     h_grid = (-3.0,3.0)
-    
+
     # set search bounds
     c_bound = (lo_freq,hi_freq)
     s_bound = (lo_freq,hi_freq)
     b_bound = (1e-8,None)
     bl_bound = (None,None)
     h_bound = (-4.0,4.0)
-    
+
     # loop over each voxel and set up a GaussianFit object
     grids = (c_grid, s_grid, b_grid, bl_grid, h_grid,)
     bounds = (c_bound, s_bound, b_bound, bl_bound, h_bound,)
-    
+
     # fit the response
     fit = aud.AuditoryFit(model, data, grids, bounds, Ns, voxel_index, auto_fit=True, verbose=1)
-    
+
     # assert equivalence
-    nt.assert_equal(np.round(fit.center_freq), center_freq)
-    nt.assert_equal(np.round(fit.sigma), sigma)
-    nt.assert_almost_equal(fit.beta, beta, 2)
-    nt.assert_almost_equal(fit.baseline, baseline, 2)
-    nt.assert_almost_equal(fit.hrf_delay, hrf_delay, 2)
-    
+    npt.assert_equal(np.round(fit.center_freq), center_freq)
+    npt.assert_equal(np.round(fit.sigma), sigma)
+    npt.assert_almost_equal(fit.beta, beta, 2)
+    npt.assert_almost_equal(fit.baseline, baseline, 2)
+    npt.assert_almost_equal(fit.hrf_delay, hrf_delay, 2)
+
     npt.assert_almost_equal((fit.center_freq0,fit.sigma0,fit.beta0,fit.baseline0,fit.hrf0),
                              (9050.0, 200.0, 0.32500000000000001, -1.5, 1.5))
-    
+
 def test_auditory_data_upsample():
-    
+
     lo_freq = 200 # Hz
     hi_freq = 12000 # Hz
     Fs = hi_freq*2 # Hz
@@ -100,50 +99,50 @@ def test_auditory_data_upsample():
     verbose = 0
     resample_factor = 10
     dtype = ctypes.c_double
-    
+
     # sample the time from 0-duration by the fs
     time = np.linspace(0,duration,duration*Fs)
-    
+
     # create a chirp stimulus
     ch = chirp(time, lo_freq, duration, hi_freq, method='quadratic')
     signal = np.concatenate((ch,ch[::-1]))
-        
+
     # instantiate an instance of the Stimulus class
     stimulus = AuditoryStimulus(signal, NFFT, Fs, noverlap, resample_factor, dtype, tr_length)
-    
+
     # initialize the gaussian model
     model = aud.AuditoryModel(stimulus, utils.double_gamma_hrf)
-    
+
     # generate a random pRF estimate
     center_freq = 5910.0
     sigma = 567.0
     beta = 0.88
     baseline = -1.5
     hrf_delay = -0.25
-    
+
     # create the "data"
     data = model.generate_prediction(center_freq, sigma, beta, baseline, hrf_delay)
     data = data[np.arange(0,len(data),2)]
-    
+
     # set search grid
     c_grid = (lo_freq,hi_freq)
     s_grid = (lo_freq,hi_freq)
     b_grid = (0.1,1)
     bl_grid = (-3,3)
     h_grid = (-3.0,3.0)
-    
+
     # set search bounds
     c_bound = (lo_freq,hi_freq)
     s_bound = (lo_freq,hi_freq)
     b_bound = (1e-8,None)
     bl_bound = (None,None)
     h_bound = (-4.0,4.0)
-    
+
     # loop over each voxel and set up a GaussianFit object
     grids = (c_grid, s_grid, b_grid, bl_grid, h_grid,)
     bounds = (c_bound, s_bound, b_bound, bl_bound, h_bound,)
-    
+
     # fit the response
     fit = aud.AuditoryFit(model, data, grids, bounds, Ns, voxel_index, auto_fit=False, verbose=1)
-    
-    nt.assert_equal(len(fit.data), len(data))
\ No newline at end of file
+
+    npt.assert_equal(len(fit.data), len(data))
diff --git a/popeye/tests/test_auditory_bin.py b/popeye/tests/test_auditory_bin.py
index 091a12c..bc0347b 100644
--- a/popeye/tests/test_auditory_bin.py
+++ b/popeye/tests/test_auditory_bin.py
@@ -4,7 +4,6 @@
 from matplotlib.pyplot import specgram
 
 import numpy as np
-import nose.tools as nt
 import numpy.testing as npt
 from scipy.signal import chirp
 
@@ -13,7 +12,7 @@
 from popeye.auditory_stimulus import AuditoryStimulus
 
 def test_auditory_fit():
-    
+
     # stimulus features
     lo_freq = 200 # Hz
     hi_freq = 12000 # Hz
@@ -29,57 +28,57 @@ def test_auditory_fit():
     verbose = 0
     resample_factor = 10
     dtype = ctypes.c_double
-    
+
     # sample the time from 0-duration by the fs
     time = np.linspace(0,duration,duration*Fs)
-    
+
     # create a chirp stimulus
     ch = chirp(time, lo_freq, duration, hi_freq, method='quadratic')
     signal = np.concatenate((ch,ch[::-1]))
-        
+
     # instantiate an instance of the Stimulus class
     stimulus = AuditoryStimulus(signal, NFFT, Fs, noverlap, resample_factor, dtype, tr_length)
-    
+
     # initialize the gaussian model
     model = aud.AuditoryModel(stimulus, utils.double_gamma_hrf)
-    
+
     # generate a random pRF estimate
     center_freq = 8910.0
     sigma = 567.0
     beta = 0.88
     baseline = -1.5
     hrf_delay = -0.25
-    
+
     # create the "data"
     data = model.generate_prediction(center_freq, sigma, beta, baseline, hrf_delay)
-    
+
     # set search grid
     c_grid = (lo_freq,hi_freq)
     s_grid = (lo_freq,hi_freq)
     b_grid = (0.1,1)
     bl_grid = (-3,3)
     h_grid = (-3.0,3.0)
-    
+
     # set search bounds
     c_bound = (lo_freq,hi_freq)
     s_bound = (lo_freq,hi_freq)
     b_bound = (1e-8,None)
     bl_bound = (None,None)
     h_bound = (-4.0,4.0)
-    
+
     # loop over each voxel and set up a GaussianFit object
     grids = (c_grid, s_grid, b_grid, bl_grid, h_grid,)
     bounds = (c_bound, s_bound, b_bound, bl_bound, h_bound,)
-    
+
     # fit the response
     fit = aud.AuditoryFit(model, data, grids, bounds, Ns, voxel_index, auto_fit=True, verbose=1)
-    
+
     # assert equivalence
-    nt.assert_equal(np.round(fit.center_freq), center_freq)
-    nt.assert_equal(np.round(fit.sigma), sigma)
-    nt.assert_almost_equal(fit.beta, beta, 2)
-    nt.assert_almost_equal(fit.baseline, baseline, 2)
-    nt.assert_almost_equal(fit.hrf_delay, hrf_delay, 2)
-    
+    npt.assert_equal(np.round(fit.center_freq), center_freq)
+    npt.assert_equal(np.round(fit.sigma), sigma)
+    npt.assert_almost_equal(fit.beta, beta, 2)
+    npt.assert_almost_equal(fit.baseline, baseline, 2)
+    npt.assert_almost_equal(fit.hrf_delay, hrf_delay, 2)
+
     npt.assert_almost_equal((fit.center_freq0,fit.sigma0,fit.beta0,fit.baseline0,fit.hrf0),
-                            (9050.0, 200.0, 0.77500000000000002, -1.5, 0.0))
\ No newline at end of file
+                            (9050.0, 200.0, 0.77500000000000002, -1.5, 0.0))
diff --git a/popeye/tests/test_auditory_bin_pct.py b/popeye/tests/test_auditory_bin_pct.py
index b8457ec..950c9f6 100644
--- a/popeye/tests/test_auditory_bin_pct.py
+++ b/popeye/tests/test_auditory_bin_pct.py
@@ -4,7 +4,6 @@
 from matplotlib.pyplot import specgram
 
 import numpy as np
-import nose.tools as nt
 import numpy.testing as npt
 from scipy.signal import chirp
 
@@ -13,7 +12,7 @@
 from popeye.auditory_stimulus import AuditoryStimulus
 
 def test_auditory_fit():
-    
+
     # stimulus features
     lo_freq = 200 # Hz
     hi_freq = 12000 # Hz
@@ -29,53 +28,53 @@ def test_auditory_fit():
     verbose = 0
     resample_factor = 10
     dtype = ctypes.c_double
-    
+
     # sample the time from 0-duration by the fs
     time = np.linspace(0,duration,duration*Fs)
-    
+
     # create a chirp stimulus
     ch = chirp(time, lo_freq, duration, hi_freq, method='quadratic')
     signal = np.concatenate((ch,ch[::-1]))
-        
+
     # instantiate an instance of the Stimulus class
     stimulus = AuditoryStimulus(signal, NFFT, Fs, noverlap, resample_factor, dtype, tr_length)
-    
+
     # initialize the gaussian model
     model = aud.AuditoryModel(stimulus, utils.double_gamma_hrf)
-    
+
     # generate a random pRF estimate
     center_freq = 8910.0
     sigma = 567.0
     beta = 0.88
     hrf_delay = -0.25
-    
+
     # create the "data"
     data = model.generate_prediction(center_freq, sigma, beta, hrf_delay)
-    
+
     # set search grid
     c_grid = (lo_freq,hi_freq)
     s_grid = (lo_freq,hi_freq)
     b_grid = (0.1,1)
     h_grid = (-3.0,3.0)
-    
+
     # set search bounds
     c_bound = (lo_freq,hi_freq)
     s_bound = (lo_freq,hi_freq)
     b_bound = (1e-8,None)
     h_bound = (-4.0,4.0)
-    
+
     # loop over each voxel and set up a GaussianFit object
     grids = (c_grid, s_grid, b_grid, h_grid,)
     bounds = (c_bound, s_bound, b_bound, h_bound,)
-    
+
     # fit the response
     fit = aud.AuditoryFit(model, data, grids, bounds, Ns, voxel_index, auto_fit=True, verbose=1)
-    
+
     # assert equivalence
-    nt.assert_equal(np.round(fit.center_freq), center_freq)
-    nt.assert_equal(np.round(fit.sigma), sigma)
-    nt.assert_almost_equal(fit.beta, beta, 2)
-    nt.assert_almost_equal(fit.hrf_delay, hrf_delay, 2)
-    
+    npt.assert_equal(np.round(fit.center_freq), center_freq)
+    npt.assert_equal(np.round(fit.sigma), sigma)
+    npt.assert_almost_equal(fit.beta, beta, 2)
+    npt.assert_almost_equal(fit.hrf_delay, hrf_delay, 2)
+
     npt.assert_almost_equal((fit.center_freq0,fit.sigma0,fit.beta0,fit.hrf0),
-                            (9050.0, 200.0, 0.77500000000000002, 0.0))
\ No newline at end of file
+                            (9050.0, 200.0, 0.77500000000000002, 0.0))
diff --git a/popeye/tests/test_css.py b/popeye/tests/test_css.py
index 882e8da..96ecacd 100644
--- a/popeye/tests/test_css.py
+++ b/popeye/tests/test_css.py
@@ -4,14 +4,13 @@
 
 import numpy as np
 import numpy.testing as npt
-import nose.tools as nt
 
 import popeye.utilities as utils
 from popeye import css
 from popeye.visual_stimulus import VisualStimulus, simulate_bar_stimulus, resample_stimulus
 
 def test_css_fit():
-    
+
     viewing_distance = 38
     screen_width = 25
     thetas = np.arange(0,360,90)
@@ -28,18 +27,18 @@ def test_css_fit():
     voxel_index = (1,2,3)
     auto_fit = True
     verbose = 1
-    
+
     # create the sweeping bar stimulus in memory
-    bar = simulate_bar_stimulus(pixels_across, pixels_down, viewing_distance, 
+    bar = simulate_bar_stimulus(pixels_across, pixels_down, viewing_distance,
                                 screen_width, thetas, num_bar_steps, num_blank_steps, ecc)
-    
+
     # create an instance of the Stimulus class
     stimulus = VisualStimulus(bar, viewing_distance, screen_width, scale_factor, tr_length, dtype)
-    
+
     # initialize the gaussian model
     model = css.CompressiveSpatialSummationModel(stimulus, utils.spm_hrf)
     model.hrf_delay = 0.2
-    
+
     # generate a random pRF estimate
     x = -2.24
     y = 1.58
@@ -48,10 +47,10 @@ def test_css_fit():
     beta = 1.0
     baseline = 0.0
     hrf_delay = 0.25
-    
+
     # create the "data"
     data =  model.generate_prediction(x, y, sigma, n, beta, baseline, hrf_delay)
-    
+
     # set search grid
     x_grid = (-3,2)
     y_grid = (-3,2)
@@ -60,7 +59,7 @@ def test_css_fit():
     b_grid = (0.01,1)
     bl_grid = (-2,2)
     h_grid = (-2.0,2.0)
-    
+
     # set search bounds
     x_bound = (-10,10)
     y_bound =  (-10,10)
@@ -69,25 +68,25 @@ def test_css_fit():
     b_bound = (1e-8,1e5)
     bl_bound = (None,None)
     h_bound = (-3.0,3.0)
-    
+
     # loop over each voxel and set up a GaussianFit object
     grids = (x_grid, y_grid, s_grid, n_grid, b_grid, bl_grid, h_grid,)
     bounds = (x_bound, y_bound, s_bound, n_bound, b_bound, bl_bound, h_bound,)
-    
+
     # fit the response
     fit = css.CompressiveSpatialSummationFit(model, data, grids, bounds, Ns, voxel_index, auto_fit, 1)
-    
+
     # coarse fit
     npt.assert_almost_equal((fit.x0,fit.y0,fit.s0,fit.n0,fit.beta0,fit.baseline0,fit.hrf0),(-3,2,1.73916969,0.9,1,0,0))
-    
+
     # fine fit
-    nt.assert_almost_equal(fit.x, x, 1)
-    nt.assert_almost_equal(fit.y, y, 1)
-    nt.assert_almost_equal(fit.sigma, sigma, 1)
-    nt.assert_almost_equal(fit.n, n, 1)
-    nt.assert_almost_equal(fit.beta, beta, 1)
-    nt.assert_almost_equal(fit.baseline, baseline, 1)
-    
+    npt.assert_almost_equal(fit.x, x, 1)
+    npt.assert_almost_equal(fit.y, y, 1)
+    npt.assert_almost_equal(fit.sigma, sigma, 1)
+    npt.assert_almost_equal(fit.n, n, 1)
+    npt.assert_almost_equal(fit.beta, beta, 1)
+    npt.assert_almost_equal(fit.baseline, baseline, 1)
+
     # overloaded
     npt.assert_almost_equal(fit.overloaded_estimate, [2.5272803327894771,
                                                       2.7411676344231712,
diff --git a/popeye/tests/test_css_nohrf.py b/popeye/tests/test_css_nohrf.py
index b81ec01..f0b4e5f 100644
--- a/popeye/tests/test_css_nohrf.py
+++ b/popeye/tests/test_css_nohrf.py
@@ -4,14 +4,13 @@
 
 import numpy as np
 import numpy.testing as npt
-import nose.tools as nt
 
 import popeye.utilities as utils
 import popeye.css_nohrf as css
 from popeye.visual_stimulus import VisualStimulus, simulate_bar_stimulus, resample_stimulus
 
 def test_css_fit():
-    
+
     viewing_distance = 38
     screen_width = 25
     thetas = np.arange(0,360,90)
@@ -28,18 +27,18 @@ def test_css_fit():
     voxel_index = (1,2,3)
     auto_fit = True
     verbose = 1
-    
+
     # create the sweeping bar stimulus in memory
-    bar = simulate_bar_stimulus(pixels_across, pixels_down, viewing_distance, 
+    bar = simulate_bar_stimulus(pixels_across, pixels_down, viewing_distance,
                                 screen_width, thetas, num_bar_steps, num_blank_steps, ecc)
-    
+
     # create an instance of the Stimulus class
     stimulus = VisualStimulus(bar, viewing_distance, screen_width, scale_factor, tr_length, dtype)
-    
+
     # initialize the gaussian model
     model = css.CompressiveSpatialSummationModel(stimulus, utils.spm_hrf)
     model.hrf_delay = 0.2
-    
+
     # generate a random pRF estimate
     x = -2.24
     y = 1.58
@@ -47,10 +46,10 @@ def test_css_fit():
     n = 0.90
     beta = 1.0
     baseline = 0.0
-    
+
     # create the "data"
     data =  model.generate_prediction(x, y, sigma, n, beta, baseline)
-    
+
     # set search grid
     x_grid = (-3,2)
     y_grid = (-3,2)
@@ -59,7 +58,7 @@ def test_css_fit():
     b_grid = (0.01,1)
     bl_grid = (-2,2)
     h_grid = (-4.0,4.0)
-    
+
     # set search bounds
     x_bound = (-10,10)
     y_bound =  (-10,10)
@@ -68,29 +67,29 @@ def test_css_fit():
     b_bound = (1e-8,1e5)
     bl_bound = (None,None)
     h_bound = (-5.0,5.0)
-    
+
     # loop over each voxel and set up a GaussianFit object
     grids = (x_grid, y_grid, s_grid, n_grid, b_grid, bl_grid,)
     bounds = (x_bound, y_bound, s_bound, n_bound, b_bound, bl_bound,)
-    
+
     # fit the response
     fit = css.CompressiveSpatialSummationFit(model, data, grids, bounds, Ns, voxel_index, auto_fit, 1)
-    
+
     # fine
-    nt.assert_almost_equal(fit.x, x, 1)
-    nt.assert_almost_equal(fit.y, y, 1)
-    nt.assert_almost_equal(fit.sigma, sigma, 1)
-    nt.assert_almost_equal(fit.n, n, 1)
-    nt.assert_almost_equal(fit.beta, beta, 1)
-    nt.assert_almost_equal(fit.baseline, baseline, 1)
-    
+    npt.assert_almost_equal(fit.x, x, 1)
+    npt.assert_almost_equal(fit.y, y, 1)
+    npt.assert_almost_equal(fit.sigma, sigma, 1)
+    npt.assert_almost_equal(fit.n, n, 1)
+    npt.assert_almost_equal(fit.beta, beta, 1)
+    npt.assert_almost_equal(fit.baseline, baseline, 1)
+
     # coarse
     npt.assert_almost_equal((fit.x0,fit.y0,fit.s0,fit.n0,fit.beta0,fit.baseline0),(2.0, -0.5, 0.72833937882323319, 0.10000000000000001, 1.0, 0.0))
-    
+
     # overloaded
     npt.assert_almost_equal(fit.overloaded_estimate,[2.5272803327899305,
                                                      2.7411676344232436,
                                                      1.2965338406630695,
                                                      0.89999999997351177,
                                                      0.99999999998062961,
-                                                     3.5926082629195817e-13])
\ No newline at end of file
+                                                     3.5926082629195817e-13])
diff --git a/popeye/tests/test_dog.py b/popeye/tests/test_dog.py
index d3cfce3..aeff95c 100644
--- a/popeye/tests/test_dog.py
+++ b/popeye/tests/test_dog.py
@@ -2,7 +2,6 @@
 
 import numpy as np
 import numpy.testing as npt
-import nose.tools as nt
 from scipy.integrate import simps
 
 import popeye.utilities as utils
@@ -10,7 +9,7 @@
 from popeye.visual_stimulus import VisualStimulus, simulate_bar_stimulus
 
 def test_dog():
-    
+
     # stimulus features
     viewing_distance = 38
     screen_width = 25
@@ -27,18 +26,18 @@ def test_dog():
     voxel_index = (1,2,3)
     auto_fit = True
     verbose = 1
-    
+
     # create the sweeping bar stimulus in memory
-    bar = simulate_bar_stimulus(pixels_across, pixels_down, viewing_distance, 
+    bar = simulate_bar_stimulus(pixels_across, pixels_down, viewing_distance,
                                 screen_width, thetas, num_bar_steps, num_blank_steps, ecc)
-    
+
     # create an instance of the Stimulus class
     stimulus = VisualStimulus(bar, viewing_distance, screen_width, scale_factor, tr_length, dtype)
-    
+
     # initialize the gaussian model
     model = dog.DifferenceOfGaussiansModel(stimulus, utils.spm_hrf)
     model.hrf_delay = 0.2
-    
+
     # set the pRF params
     x = -1.4
     y = 1.5
@@ -46,10 +45,10 @@ def test_dog():
     sigma_ratio = 2.0
     volume_ratio = 0.5
     hrf_delay = -0.2
-    
+
     # create "data"
     data = model.generate_prediction(x, y, sigma, sigma_ratio, volume_ratio,)
-    
+
     # set up the grids
     x_grid = slice(-10,10,3)
     y_grid = slice(-10,10,3)
@@ -57,7 +56,7 @@ def test_dog():
     sr_grid = slice(1.0,5.0,3)
     vr_grid = slice(0.01,0.99,3)
     grids = (x_grid, y_grid, s_grid, sr_grid, vr_grid,)
-    
+
     # set up the bounds
     x_bound = (-ecc,ecc)
     y_bound = (-ecc,ecc)
@@ -65,29 +64,28 @@ def test_dog():
     sr_bound = (1.0,None)
     vr_bound = (1e-8,1.0)
     bounds = (x_bound, y_bound, s_bound, sr_bound, vr_bound,)
-    
+
     # fit it
     fit = dog.DifferenceOfGaussiansFit(model, data, grids, bounds, voxel_index)
-    
+
     # coarse fit
-    nt.assert_almost_equal((fit.x0,fit.y0,fit.s0,fit.sr0,fit.vr0),(-1.0, 2.0, 0.72833937882323319, 1.0, 0.01))
-    
+    npt.assert_almost_equal((fit.x0,fit.y0,fit.s0,fit.sr0,fit.vr0),(-1.0, 2.0, 0.72833937882323319, 1.0, 0.01))
+
     # fine fit
-    nt.assert_almost_equal(fit.x, x)
-    nt.assert_almost_equal(fit.y, y)
-    nt.assert_almost_equal(fit.sigma, sigma)
-    nt.assert_almost_equal(fit.sigma_ratio, sigma_ratio)
-    nt.assert_almost_equal(fit.volume_ratio, volume_ratio)
-    
+    npt.assert_almost_equal(fit.x, x)
+    npt.assert_almost_equal(fit.y, y)
+    npt.assert_almost_equal(fit.sigma, sigma)
+    npt.assert_almost_equal(fit.sigma_ratio, sigma_ratio)
+    npt.assert_almost_equal(fit.volume_ratio, volume_ratio)
+
     # test the RF
     rf = fit.model.receptive_field(*fit.estimate)
     est = fit.estimate.copy()
     est[2] *= 2
     rf_new = fit.model.receptive_field(*est)
-    value_1 = np.sqrt(simps(simps(rf))) 
+    value_1 = np.sqrt(simps(simps(rf)))
     value_2 = np.sqrt(simps(simps(rf_new)))
-    nt.assert_almost_equal(value_2/value_1,sigma_ratio,1)
-    
+    npt.assert_almost_equal(value_2/value_1,sigma_ratio,1)
+
     # polar coordinates
     npt.assert_almost_equal([fit.theta,fit.rho],[np.arctan2(y,x),np.sqrt(x**2+y**2)])
-    
\ No newline at end of file
diff --git a/popeye/tests/test_og.py b/popeye/tests/test_og.py
index 9fda0fc..08856ba 100644
--- a/popeye/tests/test_og.py
+++ b/popeye/tests/test_og.py
@@ -4,7 +4,6 @@
 
 import numpy as np
 import numpy.testing as npt
-import nose.tools as nt
 from scipy.signal import fftconvolve
 import statsmodels.api as sm
 
@@ -14,7 +13,7 @@
 from popeye.spinach import generate_og_receptive_field
 
 def test_og_fit():
-    
+
     # stimulus features
     viewing_distance = 38
     screen_width = 25
@@ -32,67 +31,67 @@ def test_og_fit():
     voxel_index = (1,2,3)
     auto_fit = True
     verbose = 1
-    
+
     # create the sweeping bar stimulus in memory
-    bar = simulate_bar_stimulus(pixels_across, pixels_down, viewing_distance, 
+    bar = simulate_bar_stimulus(pixels_across, pixels_down, viewing_distance,
                                 screen_width, thetas, num_bar_steps, num_blank_steps, ecc)
-                                
+
     # create an instance of the Stimulus class
     stimulus = VisualStimulus(bar, viewing_distance, screen_width, scale_factor, tr_length, dtype)
-    
+
     # initialize the gaussian model
     model = og.GaussianModel(stimulus, utils.double_gamma_hrf)
-    
+
     # generate a random pRF estimate
     x = -5.24
     y = 2.58
     sigma = 1.24
     beta = 2.5
     hrf_delay = -0.25
-    
+
     # create the "data"
     data = model.generate_prediction(x, y, sigma, beta, hrf_delay)
-    
+
     # set search grid
     x_grid = (-10,10)
     y_grid = (-10,10)
     s_grid = (0.25,5.25)
     b_grid = (0.1,1.0)
     h_grid = (-4.0,4.0)
-    
+
     # set search bounds
     x_bound = (-12.0,12.0)
     y_bound = (-12.0,12.0)
     s_bound = (0.001,12.0)
     b_bound = (1e-8,1e2)
     h_bound = (-5.0,5.0)
-    
+
     # loop over each voxel and set up a GaussianFit object
     grids = (x_grid, y_grid, s_grid, b_grid, h_grid)
     bounds = (x_bound, y_bound, s_bound, b_bound, h_bound)
-    
+
     # fit the response
     fit = og.GaussianFit(model, data, grids, bounds, Ns, voxel_index, auto_fit, verbose)
-    
+
     # coarse fit
-    nt.assert_almost_equal((fit.x0,fit.y0,fit.s0,fit.beta0,fit.hrf0),(-10.0, 0.0, 2.75, 1.0, 0.0))
-    
+    npt.assert_almost_equal((fit.x0,fit.y0,fit.s0,fit.beta0,fit.hrf0),(-10.0, 0.0, 2.75, 1.0, 0.0))
+
     # assert equivalence
-    nt.assert_almost_equal(fit.x, x, 2)
-    nt.assert_almost_equal(fit.y, y, 2)
-    nt.assert_almost_equal(fit.sigma, sigma, 2)
-    nt.assert_almost_equal(fit.beta, beta, 2)
-    nt.assert_almost_equal(fit.hrf_delay, hrf_delay, 2)
-    
+    npt.assert_almost_equal(fit.x, x, 2)
+    npt.assert_almost_equal(fit.y, y, 2)
+    npt.assert_almost_equal(fit.sigma, sigma, 2)
+    npt.assert_almost_equal(fit.beta, beta, 2)
+    npt.assert_almost_equal(fit.hrf_delay, hrf_delay, 2)
+
     # test receptive field
     rf = generate_og_receptive_field(x, y, sigma, fit.model.stimulus.deg_x, fit.model.stimulus.deg_y)
-    nt.assert_almost_equal(rf.sum(), fit.receptive_field.sum()) 
-    
+    npt.assert_almost_equal(rf.sum(), fit.receptive_field.sum())
+
     # test model == fit RF
-    nt.assert_almost_equal(fit.model.generate_receptive_field(x,y,sigma).sum(), fit.receptive_field.sum()) 
+    npt.assert_almost_equal(fit.model.generate_receptive_field(x,y,sigma).sum(), fit.receptive_field.sum())
 
 def test_og_nuisance_fit():
-    
+
     # stimulus features
     viewing_distance = 38
     screen_width = 25
@@ -110,64 +109,64 @@ def test_og_nuisance_fit():
     voxel_index = (1,2,3)
     auto_fit = True
     verbose = 1
-    
+
     # create the sweeping bar stimulus in memory
-    bar = simulate_bar_stimulus(pixels_across, pixels_down, viewing_distance, 
+    bar = simulate_bar_stimulus(pixels_across, pixels_down, viewing_distance,
                                 screen_width, thetas, num_bar_steps, num_blank_steps, ecc)
-                                
+
     # create an instance of the Stimulus class
     stimulus = VisualStimulus(bar, viewing_distance, screen_width, scale_factor, tr_length, dtype)
-    
+
     # initialize the gaussian model
     model = og.GaussianModel(stimulus, utils.spm_hrf)
-    
+
     # generate a random pRF estimate
     x = -5.24
     y = 2.58
     sigma = 1.24
     beta = 2.5
     hrf_delay = -0.25
-    
+
     # create the "data"
     data = model.generate_prediction(x, y, sigma, beta, hrf_delay)
-    
+
     # create nuisance signal
     step = np.zeros(len(data))
     step[30:-30] = 1
-    
+
     # add to data
     data += step
-    
+
     # create design matrix
     nuisance = sm.add_constant(step)
-    
+
     # recreate model with nuisance
     model = og.GaussianModel(stimulus, utils.spm_hrf, nuisance)
-    
+
     # set search grid
     x_grid = (-10,10)
     y_grid = (-10,10)
     s_grid = (0.25,5.25)
     b_grid = (0.1,1.0)
     h_grid = (-4.0,4.0)
-    
+
     # set search bounds
     x_bound = (-12.0,12.0)
     y_bound = (-12.0,12.0)
     s_bound = (0.001,12.0)
     b_bound = (1e-8,1e2)
     h_bound = (-5.0,5.0)
-    
+
     # loop over each voxel and set up a GaussianFit object
     grids = (x_grid, y_grid, s_grid, b_grid, h_grid)
     bounds = (x_bound, y_bound, s_bound, b_bound, h_bound)
-    
+
     # fit the response
     fit = og.GaussianFit(model, data, grids, bounds, Ns, voxel_index, auto_fit, verbose)
-    
+
     # assert equivalence
-    nt.assert_almost_equal(fit.x, x, 2)
-    nt.assert_almost_equal(fit.y, y, 2)
-    nt.assert_almost_equal(fit.sigma, sigma, 2)
-    nt.assert_almost_equal(fit.beta, beta, 2)
-    nt.assert_almost_equal(fit.hrf_delay, hrf_delay, 2)
\ No newline at end of file
+    npt.assert_almost_equal(fit.x, x, 2)
+    npt.assert_almost_equal(fit.y, y, 2)
+    npt.assert_almost_equal(fit.sigma, sigma, 2)
+    npt.assert_almost_equal(fit.beta, beta, 2)
+    npt.assert_almost_equal(fit.hrf_delay, hrf_delay, 2)
diff --git a/popeye/tests/test_ogb.py b/popeye/tests/test_ogb.py
index 0959c46..451ed86 100644
--- a/popeye/tests/test_ogb.py
+++ b/popeye/tests/test_ogb.py
@@ -4,7 +4,6 @@
 
 import numpy as np
 import numpy.testing as npt
-import nose.tools as nt
 from scipy.signal import fftconvolve
 
 import popeye.utilities as utils
@@ -12,7 +11,7 @@
 from popeye.visual_stimulus import VisualStimulus, simulate_bar_stimulus
 from popeye.spinach import generate_og_receptive_field
 def test_ogb_fit():
-    
+
     # stimulus features
     viewing_distance = 38
     screen_width = 25
@@ -30,18 +29,18 @@ def test_ogb_fit():
     voxel_index = (1,2,3)
     auto_fit = True
     verbose = 1
-    
+
     # create the sweeping bar stimulus in memory
-    bar = simulate_bar_stimulus(pixels_across, pixels_down, viewing_distance, 
+    bar = simulate_bar_stimulus(pixels_across, pixels_down, viewing_distance,
                                 screen_width, thetas, num_bar_steps, num_blank_steps, ecc)
-    
+
     # create an instance of the Stimulus class
     stimulus = VisualStimulus(bar, viewing_distance, screen_width, scale_factor, tr_length, dtype)
-    
+
     # initialize the gaussian model
     model = ogb.GaussianModel(stimulus, utils.double_gamma_hrf)
     model.tr_length = 1.0
-    
+
     # generate a random pRF estimate
     x = -2.2
     y = 2.6
@@ -49,10 +48,10 @@ def test_ogb_fit():
     beta = 85
     baseline = 0.5
     hrf_delay = -0.3
-    
+
     # create data
     data = model.generate_prediction(x, y, sigma, beta, baseline, hrf_delay)
-    
+
     # set search grid
     x_grid = (-5,5)
     y_grid = (-5,5)
@@ -60,7 +59,7 @@ def test_ogb_fit():
     b_grid = (1,100)
     bl_grid = (-1,1)
     h_grid = (-4.0,4.0)
-    
+
     # set search bounds
     x_bound = (-12.0,12.0)
     y_bound = (-12.0,12.0)
@@ -68,33 +67,32 @@ def test_ogb_fit():
     b_bound = (1e-8,None)
     bl_bound = (-1,1)
     h_bound = (-5.0,5.0)
-    
+
     # loop over each voxel and set up a GaussianFit object
     grids = (x_grid, y_grid, s_grid, b_grid, bl_grid, h_grid)
     bounds = (x_bound, y_bound, s_bound, b_bound, bl_bound, h_bound)
-    
+
     # fit the response
     fit = ogb.GaussianFit(model, data, grids, bounds, Ns, voxel_index, auto_fit, verbose)
-    
+
     # test ballpark
-    nt.assert_almost_equal(fit.x0, 0, 1)
-    nt.assert_almost_equal(fit.y0, 0, 1)
-    nt.assert_almost_equal(fit.s0, 2.8, 1)
-    nt.assert_almost_equal(fit.beta0, 100, 1)
-    nt.assert_almost_equal(fit.baseline0, -1, 1)
-    nt.assert_almost_equal(fit.hrf0, 0, 1)
-    
+    npt.assert_almost_equal(fit.x0, 0, 1)
+    npt.assert_almost_equal(fit.y0, 0, 1)
+    npt.assert_almost_equal(fit.s0, 2.8, 1)
+    npt.assert_almost_equal(fit.beta0, 100, 1)
+    npt.assert_almost_equal(fit.baseline0, -1, 1)
+    npt.assert_almost_equal(fit.hrf0, 0, 1)
+
     # test final estimate
-    nt.assert_almost_equal(fit.x, x, 1)
-    nt.assert_almost_equal(fit.y, y, 1)
-    nt.assert_almost_equal(fit.sigma, sigma, 1)
-    nt.assert_almost_equal(np.round(fit.beta), beta, 1)
-    nt.assert_almost_equal(fit.hrf_delay, hrf_delay, 1)
-    
+    npt.assert_almost_equal(fit.x, x, 1)
+    npt.assert_almost_equal(fit.y, y, 1)
+    npt.assert_almost_equal(fit.sigma, sigma, 1)
+    npt.assert_almost_equal(np.round(fit.beta), beta, 1)
+    npt.assert_almost_equal(fit.hrf_delay, hrf_delay, 1)
+
     # test receptive field
     rf = generate_og_receptive_field(x, y, sigma, fit.model.stimulus.deg_x, fit.model.stimulus.deg_y)
-    nt.assert_almost_equal(rf.sum(), fit.receptive_field.sum())
-    
+    npt.assert_almost_equal(rf.sum(), fit.receptive_field.sum())
+
     # test HRF
-    nt.assert_almost_equal(fit.hemodynamic_response.sum(), fit.model.hrf_model(fit.hrf_delay, fit.model.stimulus.tr_length).sum())
-    
\ No newline at end of file
+    npt.assert_almost_equal(fit.hemodynamic_response.sum(), fit.model.hrf_model(fit.hrf_delay, fit.model.stimulus.tr_length).sum())
diff --git a/popeye/tests/test_ogb_nohrf.py b/popeye/tests/test_ogb_nohrf.py
index 12c7001..a06569a 100644
--- a/popeye/tests/test_ogb_nohrf.py
+++ b/popeye/tests/test_ogb_nohrf.py
@@ -4,7 +4,6 @@
 
 import numpy as np
 import numpy.testing as npt
-import nose.tools as nt
 from scipy.signal import fftconvolve
 
 import popeye.utilities as utils
@@ -12,7 +11,7 @@
 from popeye.visual_stimulus import VisualStimulus, simulate_bar_stimulus
 
 def test_ogb_manual_grids():
-    
+
     # stimulus features
     viewing_distance = 38
     screen_width = 25
@@ -30,7 +29,7 @@ def test_ogb_manual_grids():
     voxel_index = (1,2,3)
     auto_fit = True
     verbose = 1
-    
+
     # insert blanks
     thetas = list(thetas)
     thetas.insert(0,-1)
@@ -40,56 +39,56 @@ def test_ogb_manual_grids():
     thetas.insert(11,-1)
     thetas.append(-1)
     thetas = np.array(thetas)
-    
+
     # create the sweeping bar stimulus in memory
-    bar = simulate_bar_stimulus(pixels_across, pixels_down, viewing_distance, 
+    bar = simulate_bar_stimulus(pixels_across, pixels_down, viewing_distance,
                                 screen_width, thetas, num_bar_steps, num_blank_steps, ecc)
-    
+
     # create an instance of the Stimulus class
     stimulus = VisualStimulus(bar, viewing_distance, screen_width, scale_factor, tr_length, dtype)
-    
+
     # initialize the gaussian model
     model = ogb.GaussianModel(stimulus, utils.spm_hrf)
     model.tr_length = 1.0
     model.hrf_delay = 0.0
-    
+
     # generate a random pRF estimate
     x = -2.2
     y = 2.6
     sigma = 0.8
     beta = 85
     baseline = 0.5
-    
+
     # create data
     data = model.generate_prediction(x, y, sigma, beta, baseline,)
-    
+
     # set search grid
     x_grid = slice(-5,5,3)
     y_grid = slice(-5,5,3)
     s_grid = slice(1/stimulus.ppd,5.25,5)
     b_grid = slice(1,100,2)
     bl_grid = slice(-1,1,3)
-    
+
     # set search bounds
     x_bound = (-12.0,12.0)
     y_bound = (-12.0,12.0)
     s_bound = (1/stimulus.ppd,12.0)
     b_bound = (1e-8,None)
     bl_bound = (-1,1)
-    
+
     # loop over each voxel and set up a GaussianFit object
-    grids = (x_grid, y_grid, s_grid, b_grid, bl_grid,) 
+    grids = (x_grid, y_grid, s_grid, b_grid, bl_grid,)
     bounds = (x_bound, y_bound, s_bound, b_bound, bl_bound,)
-    
+
     # fit the response
     fit = ogb.GaussianFit(model, data, grids, bounds, Ns, voxel_index, auto_fit, verbose)
-    
+
     # assert equivalence
-    nt.assert_almost_equal(fit.x, x, 1)
-    nt.assert_almost_equal(fit.y, y, 1)
-    nt.assert_almost_equal(fit.sigma, sigma, 1)
-    nt.assert_almost_equal(np.round(fit.beta), beta, 1)
-    
+    npt.assert_almost_equal(fit.x, x, 1)
+    npt.assert_almost_equal(fit.y, y, 1)
+    npt.assert_almost_equal(fit.sigma, sigma, 1)
+    npt.assert_almost_equal(np.round(fit.beta), beta, 1)
+
     npt.assert_almost_equal(fit.overloaded_estimate,[2.2730532583028005,
                                                      3.4058772731826976,
                                                      0.79999999999807414,
@@ -98,7 +97,7 @@ def test_ogb_manual_grids():
 
 
 def test_ogb_fit():
-    
+
     # stimulus features
     viewing_distance = 38
     screen_width = 25
@@ -116,7 +115,7 @@ def test_ogb_fit():
     voxel_index = (1,2,3)
     auto_fit = True
     verbose = 1
-    
+
     # insert blanks
     thetas = list(thetas)
     thetas.insert(0,-1)
@@ -126,56 +125,55 @@ def test_ogb_fit():
     thetas.insert(11,-1)
     thetas.append(-1)
     thetas = np.array(thetas)
-    
+
     # create the sweeping bar stimulus in memory
-    bar = simulate_bar_stimulus(pixels_across, pixels_down, viewing_distance, 
+    bar = simulate_bar_stimulus(pixels_across, pixels_down, viewing_distance,
                                 screen_width, thetas, num_bar_steps, num_blank_steps, ecc)
-    
+
     # create an instance of the Stimulus class
     stimulus = VisualStimulus(bar, viewing_distance, screen_width, scale_factor, tr_length, dtype)
-    
+
     # initialize the gaussian model
     model = ogb.GaussianModel(stimulus, utils.spm_hrf)
     model.tr_length = 1.0
     model.hrf_delay = 0.0
-    
+
     # generate a random pRF estimate
     x = -2.2
     y = 2.6
     sigma = 0.8
     beta = 85
     baseline = 0.5
-    
+
     # create data
     data = model.generate_prediction(x, y, sigma, beta, baseline,)
-    
+
     # set search grid
     x_grid = (-5,5)
     y_grid = (-5,5)
     s_grid = (1/stimulus.ppd,5.25)
     b_grid = (1,100)
     bl_grid = (-1,1)
-    
+
     # set search bounds
     x_bound = (-12.0,12.0)
     y_bound = (-12.0,12.0)
     s_bound = (1/stimulus.ppd,12.0)
     b_bound = (1e-8,None)
     bl_bound = (-1,1)
-    
+
     # loop over each voxel and set up a GaussianFit object
     grids = (x_grid, y_grid, s_grid, b_grid, bl_grid,)
     bounds = (x_bound, y_bound, s_bound, b_bound, bl_bound,)
-    
+
     # fit the response
     fit = ogb.GaussianFit(model, data, grids, bounds, Ns, voxel_index, auto_fit, verbose)
-    
+
     # coarse
     npt.assert_almost_equal((fit.x0,fit.y0,fit.s0,fit.beta0,fit.baseline0),(0.0, 0.0, 2.9891696894116166, 50.5, 1.0))
-    
+
     # assert equivalence
-    nt.assert_almost_equal(fit.x, x, 1)
-    nt.assert_almost_equal(fit.y, y, 1)
-    nt.assert_almost_equal(fit.sigma, sigma, 1)
-    nt.assert_almost_equal(fit.beta, beta, 1)
-    
\ No newline at end of file
+    npt.assert_almost_equal(fit.x, x, 1)
+    npt.assert_almost_equal(fit.y, y, 1)
+    npt.assert_almost_equal(fit.sigma, sigma, 1)
+    npt.assert_almost_equal(fit.beta, beta, 1)
diff --git a/popeye/tests/test_spinach.py b/popeye/tests/test_spinach.py
index ce5031a..444b548 100644
--- a/popeye/tests/test_spinach.py
+++ b/popeye/tests/test_spinach.py
@@ -1,6 +1,5 @@
 import numpy as np
 import numpy.testing as npt
-import nose.tools as nt
 
 import popeye.utilities as utils
 import popeye.spinach as spin
@@ -16,24 +15,24 @@ def test_generate_og_receptive_field():
     xcenter = 0 # x coordinate of the pRF center
     ycenter = 0 # y coordinate of the pRF center
     sigma = 1 # width of the pRF
-    
-    test_value = 6 # this is the sum of a gaussian given 1 ppd 
+
+    test_value = 6 # this is the sum of a gaussian given 1 ppd
                    # and a 1 sigma prf centered on (0,0)
-                   
+
     # generate the visuotopic coordinates
     dx,dy = generate_coordinate_matrices(xpixels,
                                          ypixels,
                                          ppd,
                                          scale_factor)
-    
+
     # generate a pRF at (0,0) and 1 sigma wide
     rf = generate_og_receptive_field(xcenter, ycenter, sigma, dx, dy)
-    
+
     # divide by integral
     rf /= 2 * np.pi * sigma ** 2
-    
+
     # compare the volume of the pRF to a known value
-    nt.assert_almost_equal(np.sum(rf),1)
+    npt.assert_almost_equal(np.sum(rf),1)
 
 
 def test_generate_og_timeseries():
@@ -41,35 +40,35 @@ def test_generate_og_timeseries():
     ypixels = 100 # simulated screen height
     ppd = 1 # simulated visual angle
     scaleFactor = 1.0 # simulated stimulus resampling rate
-    
+
     xcenter = 0 # x coordinate of the pRF center
     ycenter = 0 # y coordinate of the pRF center
     sigma = 10 # width of the pRF
-    
+
     # generate the visuotopic coordinates
     dx,dy = generate_coordinate_matrices(xpixels,
                                          ypixels,
                                          ppd,
                                          scaleFactor)
-    
+
     timeseries_length = 15 # number of frames to simulate our stimulus array
-    
+
     # initialize the stimulus array
     stim_arr = np.zeros((xpixels, ypixels, timeseries_length)).astype('uint8')
-    
+
     # make a circular mask appear for the first 5 frames
     xi,yi = np.nonzero(np.sqrt((dx-xcenter)**2 + (dy-ycenter)**2)<sigma)
     stim_arr[xi,yi,0:5] = 1
-    
+
     # make an annulus appear for the next 5 frames
     xi,yi = np.nonzero(np.sqrt((dx-xcenter)**2 + (dy-ycenter)**2)>sigma)
     stim_arr[xi,yi,5:10] = 1
-    
+
     # make a circular mask appear for the next 5 frames
     xi,yi = np.nonzero(np.sqrt((dx-xcenter)**2 + (dy-ycenter)**2)<sigma)
     stim_arr[xi,yi,10::] = 1
-    
-    
+
+
     # make the response prediction
     response = generate_og_timeseries(dx,
                                       dy,
@@ -77,23 +76,23 @@ def test_generate_og_timeseries():
                                       xcenter,
                                       ycenter,
                                       sigma)
-                                
+
     # make sure the RSS is 0
     step = np.array([0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0])
     rval = np.corrcoef(response, step)[0, 1]
-    
+
     # The voxel responds when the stimulus covers its PRF, so it perfectly
-    # correlates with a step function: 
-    nt.assert_equal(round(rval, 3), 1)
+    # correlates with a step function:
+    npt.assert_equal(round(rval, 3), 1)
 
 # def test_binner():
-#     
+#
 #     signal = np.ones(10)
 #     times = np.linspace(0,1,10)
 #     bins = np.arange(-0.5,1.5,0.5)
-#     
+#
 #     binned_signal = spin.binner(signal, times, bins)
-#     
-#     nt.assert_true(len(binned_signal), len(bins)-2)
-#     nt.assert_true(np.all(binned_signal==[5,5]))
-#     
+#
+#     npt.assert_true(len(binned_signal), len(bins)-2)
+#     npt.assert_true(np.all(binned_signal==[5,5]))
+#
diff --git a/popeye/tests/test_stimulus.py b/popeye/tests/test_stimulus.py
index 846f55b..fb6cb09 100644
--- a/popeye/tests/test_stimulus.py
+++ b/popeye/tests/test_stimulus.py
@@ -6,55 +6,53 @@
 import numpy as np
 import numpy.testing as npt
 
-import nose.tools as nt
-
 from popeye.visual_stimulus import pixels_per_degree, generate_coordinate_matrices, resample_stimulus, simulate_sinflicker_bar, simulate_bar_stimulus, VisualStimulus
 
 def test_pixels_per_degree():
-    
+
     pixels_across = 1
     screen_width = 1
     viewing_distance = 1
     ppd = pixels_per_degree(pixels_across, screen_width, viewing_distance)
-    
+
 def test_generate_coordinate_matrices():
-    
+
     # set some dummy display parameters
     pixels_across = 100
     pixels_down = 100
     ppd = 1.0
     scale_factor = 1.0
-    
+
     # generate coordinates
     deg_x, deg_y = generate_coordinate_matrices(pixels_across,pixels_down,ppd,scale_factor)
-    
+
     # assert
-    nt.assert_true(np.sum(deg_x[0,0:50]) == np.sum(deg_x[0,50::])*-1)
-    nt.assert_true(np.sum(deg_y[0:50,0]) == np.sum(deg_y[50::,0])*-1)
-    
+    npt.assert_(np.sum(deg_x[0,0:50]) == np.sum(deg_x[0,50::])*-1)
+    npt.assert_(np.sum(deg_y[0:50,0]) == np.sum(deg_y[50::,0])*-1)
+
     # try the same with an odd number of pixels
     pixels_across = 101
     pixels_down = 101
-    
+
     # generate coordinates
     deg_x, deg_y = generate_coordinate_matrices(pixels_across,pixels_down,ppd,scale_factor)
-    
+
     # assert
-    nt.assert_true(np.sum(deg_x[0,0:50]) == np.sum(deg_x[0,50::])*-1)
-    nt.assert_true(np.sum(deg_y[0:50,0]) == np.sum(deg_y[50::,0])*-1)
-    
+    npt.assert_(np.sum(deg_x[0,0:50]) == np.sum(deg_x[0,50::])*-1)
+    npt.assert_(np.sum(deg_y[0:50,0]) == np.sum(deg_y[50::,0])*-1)
+
     # try with another rescaling factor
     scale_factor = 0.5
-    
+
     # get the horizontal and vertical coordinate matrices
     deg_x, deg_y = generate_coordinate_matrices(pixels_across,pixels_down,ppd,scale_factor)
-    
+
     # assert
-    nt.assert_true(np.sum(deg_x[0,0:50]) == np.sum(deg_x[0,50::])*-1)
-    nt.assert_true(np.sum(deg_y[0:50,0]) == np.sum(deg_y[50::,0])*-1)
+    npt.assert_(np.sum(deg_x[0,0:50]) == np.sum(deg_x[0,50::])*-1)
+    npt.assert_(np.sum(deg_y[0:50,0]) == np.sum(deg_y[50::,0])*-1)
 
 def test_noresample_stimulus():
-    
+
     # stimulus features
     viewing_distance = 38
     screen_width = 25
@@ -72,53 +70,52 @@ def test_noresample_stimulus():
     voxel_index = (1,2,3)
     auto_fit = True
     verbose = 1
-    
+
     # create the sweeping bar stimulus in memory
-    bar = simulate_bar_stimulus(pixels_across, pixels_down, viewing_distance, 
+    bar = simulate_bar_stimulus(pixels_across, pixels_down, viewing_distance,
                                 screen_width, thetas, num_bar_steps, num_blank_steps, ecc)
-                                
+
     # create an instance of the Stimulus class
     stimulus = VisualStimulus(bar, viewing_distance, screen_width, scale_factor, tr_length, dtype)
-    
+
     # stimulus
     npt.assert_equal(stimulus.stim_arr.shape[0:2],stimulus.stim_arr0.shape[0:2])
     npt.assert_equal(stimulus.deg_x.shape,stimulus.deg_x0.shape)
     npt.assert_equal(stimulus.deg_y.shape,stimulus.deg_y0.shape)
 
 def test_resample_stimulus():
-    
+
     # set the downsampling rate
     scale_factor = 0.5
-    
+
     # create a stimulus
     stimulus = np.random.random((100,100,20))
-    
+
     # downsample the stimulus by 50%
     stimulus_coarse = resample_stimulus(stimulus,scale_factor)
-    
+
     # grab the stimulus dimensions
     stim_dims = np.shape(stimulus)
     stim_coarse_dims = np.shape(stimulus_coarse)
-    
+
     # assert
-    nt.assert_true(stim_coarse_dims[0]/stim_dims[0] == scale_factor)
-    nt.assert_true(stim_coarse_dims[1]/stim_dims[1] == scale_factor)
-    nt.assert_true(stim_coarse_dims[2] == stim_dims[2])
+    npt.assert_(stim_coarse_dims[0]/stim_dims[0] == scale_factor)
+    npt.assert_(stim_coarse_dims[1]/stim_dims[1] == scale_factor)
+    npt.assert_(stim_coarse_dims[2] == stim_dims[2])
 
 def test_simulate_sinflicker_bar():
-    
+
     # no blanks
     bar = simulate_sinflicker_bar(100,100,50,10,[0],1,10,5,1,1,60)
     y = utils.normalize(bar[1,1,:],0,1)
     t = np.linspace(0,1,60)
     yhat = utils.normalize(np.sin(2 * np.pi * t),0,1)
-    nt.assert_almost_equal(np.sum(yhat-y),0)
-    
+    npt.assert_almost_equal(np.sum(yhat-y),0)
+
     # blanks
     bar = simulate_sinflicker_bar(100,100,50,10,[0,-1],1,10,5,1,1,60)
     y = np.round(utils.normalize(bar[1,1,:],0,1),2)
     t = np.linspace(0,1,60)
     yhat = utils.normalize(np.sin(2 * np.pi * t),0,1)
     yhat = np.append(yhat,np.repeat(0.5,60))
-    nt.assert_almost_equal(np.sum(yhat-np.round(y,2)),0,1)
-    
\ No newline at end of file
+    npt.assert_almost_equal(np.sum(yhat-np.round(y,2)),0,1)
diff --git a/popeye/tests/test_strf.py b/popeye/tests/test_strf.py
index e8712a5..49221e0 100755
--- a/popeye/tests/test_strf.py
+++ b/popeye/tests/test_strf.py
@@ -1,25 +1,24 @@
 # from __future__ import division
-# 
+#
 # from itertools import repeat
 # import multiprocessing
-# 
+#
 # import numpy as np
 # import numpy.testing as npt
-# import nose.tools as nt
 # 
 # from scipy.signal import chirp
-# 
+#
 # import popeye.utilities as utils
 # import popeye.strf as strf
 # from popeye.auditory_stimulus import AuditoryStimulus
-# 
+#
 # # def test_brute_force_search():
 # #     """
-# #     Test voxel-wise strf estimation function in popeye.estimation 
-# #     using the stimulus and BOLD time-series data that ship with the 
+# #     Test voxel-wise strf estimation function in popeye.estimation
+# #     using the stimulus and BOLD time-series data that ship with the
 # #     popeye installation.
 # #     """
-# #     
+# #
 # #     # stimulus features
 # #     lo_freq = 100 # Hz
 # #     hi_freq = 1000 # Hz
@@ -28,47 +27,47 @@
 # #     tr_length = 1.0 # seconds
 # #     time_window = 0.5 # seconds
 # #     freq_window = 256 # this is 2x the number of freq bins we'll end up with in the spectrogram
-# #     
+# #
 # #     num_timepoints = np.floor(duration / tr_length)
-# #     
+# #
 # #     # sample the time from 0-duration by the fs
 # #     time = np.linspace(0,duration,duration*fs)
-# #     
+# #
 # #     # create the sweeping bar stimulus in memory
 # #     signal = chirp(time, lo_freq, duration, hi_freq, method='linear')
 # #     %
 # #     # instantiate an instance of the Stimulus class
 # #     stimulus = AuditoryStimulus(signal, tr_length, freq_window, time_window)
-# #     
+# #
 # #     # set up bounds for the grid search
 # #     bounds = ((lo_freq, hi_freq),(lo_freq, hi_freq),(-5,5))
-# #     
+# #
 # #     # initialize the strf model
 # #     strf_model = strf.SpectrotemporalModel(stimulus)
-# #     
+# #
 # #     # makeup a STRF estimate
 # #     freq_center = 550 # center frequency
 # #     freq_sigma = 100 # frequency dispersion
 # #     hrf_delay = 0.0 # seconds
-# #     
+# #
 # #     # generate the modeled BOLD response
 # #     response = strf.compute_model_ts(freq_center, freq_sigma, hrf_delay,
 # #                                      stimulus.time_coord, stimulus.freq_coord, stimulus.spectrogram,
 # #                                      tr_length, num_timepoints)
-# #     
+# #
 # #     # compute the initial guess with the adaptive brute-force grid-search
 # #     f0, fs0, hrf0 = strf.brute_force_search(bounds, response,
 # #                                             stimulus.time_coord,
 # #                                             stimulus.freq_coord,
 # #                                             stimulus.spectrogram,
 # #                                             tr_length, num_timepoints)
-# #                                                              
-# #         
+# #
+# #
 # #     # assert
 # #     npt.assert_equal([freq_center, freq_sigma, hrf_delay], [f0,fs0,hrf0])
-# 
+#
 # def test_strf_fit():
-#     
+#
 #     # stimulus features
 #     lo_freq = 200 # Hz
 #     hi_freq = 12000 # Hz
@@ -81,45 +80,45 @@
 #     scale_factor = 1.0 # how much to downsample the spectrotemporal space
 #     num_timepoints = np.floor(duration / tr_length)
 #     degrees = 0.0
-#     
+#
 #     # sample the time from 0-duration by the fs
 #     time = np.linspace(0,duration,duration*fs)
-#     
+#
 #     # create a chirp stimulus
 #     signal = chirp(time, lo_freq, duration, hi_freq)
-#     
+#
 #     # instantiate an instance of the Stimulus class
-#     stimulus = AuditoryStimulus(signal, tr_length, freq_window, time_window, sampling_rate=fs, 
+#     stimulus = AuditoryStimulus(signal, tr_length, freq_window, time_window, sampling_rate=fs,
 #                                 tr_sampling_rate=tr_sampling_rate, scale_factor=scale_factor)
-#     
-#     
+#
+#
 #     # set some parameters for the mock STRF
 #     freq_center = 5678 # center frequency
 #     freq_sigma = 234 # frequency dispersion
 #     hrf_delay = 0.987 # seconds
-#     
+#
 #     # initialize the strf model
 #     model = strf.SpectrotemporalModel(stimulus)
-#     
+#
 #     # generate the modeled BOLD response
 #     data = strf.compute_model_ts(freq_center, freq_sigma, hrf_delay,
-#                                  model.stimulus.time_coord, 
+#                                  model.stimulus.time_coord,
 #                                  model.stimulus.freq_coord,
 #                                  model.stimulus.spectrogram.astype('double'),
 #                                  tr_length, num_timepoints, norm_func=utils.zscore)
-#     
+#
 #     # set some searh parameters
 #     search_bounds = ((lo_freq, hi_freq),(lo_freq, hi_freq/2),(-5,5),)
 #     fit_bounds = ((lo_freq, hi_freq),(lo_freq, hi_freq/2),(-5,5),)
-#     
+#
 #     # fit the response
 #     fit = strf.SpectrotemporalFit(data, model, search_bounds, fit_bounds, tr_length)
-#     
+#
 #     # assert
 #     npt.assert_almost_equal(fit.estimate,[freq_center,freq_sigma,hrf_delay])
-# 
+#
 # def test_parallel_fit():
-#     
+#
 #     lo_freq = 200 # Hz
 #     hi_freq = 12000 # Hz
 #     fs = 44100.0 # Hz
@@ -132,39 +131,39 @@
 #     num_timepoints = np.floor(duration / tr_length)
 #     degrees = 0.0
 #     num_voxels = multiprocessing.cpu_count()
-#     
-#     
+#
+#
 #     # sample the time from 0-duration by the fs
 #     time = np.linspace(0,duration,duration*fs)
-#     
+#
 #     # create a chirp stimulus
 #     signal = chirp(time, lo_freq, duration, hi_freq)
-#     
+#
 #     # instantiate an instance of the Stimulus class
-#     stimulus = AuditoryStimulus(signal, tr_length, freq_window, time_window, sampling_rate=fs, 
+#     stimulus = AuditoryStimulus(signal, tr_length, freq_window, time_window, sampling_rate=fs,
 #                                 tr_sampling_rate=tr_sampling_rate, scale_factor=scale_factor)
-#     
-#     
+#
+#
 #     # invent a pRF estimate
 #     freq_center = 5678 # center frequency
 #     freq_sigma = 234 # frequency dispersion
 #     hrf_delay = 0.987 # seconds
-#     
+#
 #     # initialize the strf model
 #     model = strf.SpectrotemporalModel(stimulus)
-#     
+#
 #     # set some bounds
 #     search_bounds = [((lo_freq, hi_freq),(lo_freq, hi_freq/2),(-5,5),)]*num_voxels
 #     fit_bounds = [((lo_freq, hi_freq),(lo_freq, hi_freq/2),(-5,5),)]*num_voxels
-#     
+#
 #     # generate the modeled BOLD response
 #     response = strf.compute_model_ts(freq_center, freq_sigma, hrf_delay,
-#                                      model.stimulus.time_coord, 
+#                                      model.stimulus.time_coord,
 #                                      model.stimulus.freq_coord,
 #                                      model.stimulus.spectrogram.astype('double'),
 #                                      tr_length, num_timepoints, norm_func=utils.zscore)
-#     
-#     
+#
+#
 #     # package the data structure
 #     dat = zip(repeat(response,num_voxels),
 #               repeat(model,num_voxels),
@@ -174,15 +173,15 @@
 #               repeat(None,num_voxels),
 #               repeat(True,num_voxels),
 #               repeat(False,num_voxels))
-#               
+#
 #     # run analysis
 #     num_cpus = multiprocessing.cpu_count()-1
 #     pool = multiprocessing.Pool(num_cpus)
 #     output = pool.map(strf.parallel_fit,dat)
 #     pool.close()
 #     pool.join()
-#     
+#
 #     # assert equivalence
 #     for fit in output:
 #         npt.assert_almost_equal(fit.estimate,[freq_center,freq_sigma,hrf_delay])
-#     
+#
diff --git a/popeye/tests/test_utilities.py b/popeye/tests/test_utilities.py
index 0eaf913..458679c 100644
--- a/popeye/tests/test_utilities.py
+++ b/popeye/tests/test_utilities.py
@@ -7,7 +7,6 @@
     from io import StringIO
 
 import numpy as np
-import nose.tools as nt
 import numpy.testing as npt
 
 import nibabel
@@ -26,10 +25,10 @@ def test_distance_mask():
     amplitude=100
     dx,dy = np.meshgrid(np.linspace(-50,50,100),np.linspace(-50,50,100))
     mask = utils.distance_mask(x,y,sigma,dx,dy)
-    nt.assert_true(np.sqrt(np.sum(mask))==2)
-    nt.assert_true(np.max(mask)==1)
+    npt.assert_(np.sqrt(np.sum(mask))==2)
+    npt.assert_(np.max(mask)==1)
     mask = utils.distance_mask(x,y,sigma,dx,dy,amplitude)
-    nt.assert_true(np.max(mask)==amplitude)
+    npt.assert_(np.max(mask)==amplitude)
 
 
 def test_grid_slice():
@@ -270,7 +269,7 @@ def test_error_function():
 
     # assert parameter outside of bounds return inf
     params = (30.0,)
-    nt.assert_true(utils.error_function(params, bounds, response, func, verbose) == np.inf)
+    npt.assert_(utils.error_function(params, bounds, response, func, verbose) == np.inf)
 
     # # assert print is param and 0 error
     # params = (10.0,)
@@ -278,13 +277,13 @@ def test_error_function():
     # sys.stdout = out
     # x = utils.error_function(params, bounds, response, func, verbose)
     # output = out.getvalue().strip()
-    # nt.assert_true(output == '((10.0,), 0.0)')
+    # npt.assert_(output == '((10.0,), 0.0)')
 
     # test nan returns inf
     response = func(params)
     response[0] = np.nan
     err = utils.error_function(params, bounds, response, func, verbose)
-    nt.assert_equal(err,np.inf)
+    npt.assert_equal(err,np.inf)
 
 def test_gradient_descent_search():
 
@@ -384,9 +383,9 @@ def test_double_gamma_hrf():
     hrf_0 = utils.double_gamma_hrf(-1, tr_length, integrator=None)
     hrf_1 = utils.double_gamma_hrf(0, tr_length, integrator=None)
     hrf_2 = utils.double_gamma_hrf(1, tr_length, integrator=None)
-    nt.assert_true(hrf_0.sum()<hrf_1.sum())
-    nt.assert_true(hrf_1.sum()<hrf_2.sum())
-    nt.assert_true(hrf_0.sum()<hrf_2.sum())
+    npt.assert_(hrf_0.sum()<hrf_1.sum())
+    npt.assert_(hrf_1.sum()<hrf_2.sum())
+    npt.assert_(hrf_0.sum()<hrf_2.sum())
 
 
 def test_spm_hrf():
@@ -435,9 +434,9 @@ def test_randomize_voxels():
     rand_xi, rand_yi, rand_zi = xi[rand_ind], yi[rand_ind], zi[rand_ind]
 
     # assert that all members of the original and resorted indices are equal
-    nt.assert_true(set(xi) == set(rand_xi))
-    nt.assert_true(set(yi) == set(rand_yi))
-    nt.assert_true(set(zi) == set(rand_zi))
+    npt.assert_(set(xi) == set(rand_xi))
+    npt.assert_(set(yi) == set(rand_yi))
+    npt.assert_(set(zi) == set(rand_zi))
 
 def test_zscore():
 
@@ -465,8 +464,8 @@ def test_percent_change():
     x = np.array([[99, 100, 101], [4, 5, 6]])
     p = utils.percent_change(x)
 
-    nt.assert_equal(x.shape, p.shape)
-    nt.assert_almost_equal(p[0, 2], 1.0)
+    npt.assert_equal(x.shape, p.shape)
+    npt.assert_almost_equal(p[0, 2], 1.0)
 
     ts = np.arange(4 * 5).reshape(4, 5)
     ax = 0
@@ -562,11 +561,11 @@ def test_parallel_fit_Ns():
 
     # assert equivalence
     for fit in output:
-        nt.assert_almost_equal(fit.x, x, 2)
-        nt.assert_almost_equal(fit.y, y, 2)
-        nt.assert_almost_equal(fit.sigma, sigma, 2)
-        nt.assert_almost_equal(fit.beta, beta, 2)
-        nt.assert_almost_equal(fit.hrf_delay, hrf_delay, 2)
+        npt.assert_almost_equal(fit.x, x, 2)
+        npt.assert_almost_equal(fit.y, y, 2)
+        npt.assert_almost_equal(fit.sigma, sigma, 2)
+        npt.assert_almost_equal(fit.beta, beta, 2)
+        npt.assert_almost_equal(fit.hrf_delay, hrf_delay, 2)
 
 def test_parallel_fit():
 
@@ -636,10 +635,10 @@ def test_parallel_fit():
     fit = utils.parallel_fit(bundle[0])
 
     # assert equivalence
-    nt.assert_almost_equal(fit.x, x, 2)
-    nt.assert_almost_equal(fit.y, y, 2)
-    nt.assert_almost_equal(fit.sigma, sigma, 2)
-    nt.assert_almost_equal(fit.beta, beta, 2)
+    npt.assert_almost_equal(fit.x, x, 2)
+    npt.assert_almost_equal(fit.y, y, 2)
+    npt.assert_almost_equal(fit.sigma, sigma, 2)
+    npt.assert_almost_equal(fit.beta, beta, 2)
 
 def test_parallel_fit_manual_grids():
 
@@ -712,10 +711,10 @@ def test_parallel_fit_manual_grids():
 
     # assert equivalence
     for fit in output:
-        nt.assert_almost_equal(fit.x, x, 2)
-        nt.assert_almost_equal(fit.y, y, 2)
-        nt.assert_almost_equal(fit.sigma, sigma, 2)
-        nt.assert_almost_equal(fit.beta, beta, 2)
+        npt.assert_almost_equal(fit.x, x, 2)
+        npt.assert_almost_equal(fit.y, y, 2)
+        npt.assert_almost_equal(fit.sigma, sigma, 2)
+        npt.assert_almost_equal(fit.beta, beta, 2)
 
 def test_gaussian_2D():
 
@@ -736,29 +735,29 @@ def test_gaussian_2D():
     gy = np.exp(-((deg_y[:,0]-0)**2)/(2*10**2))
 
     # assertions
-    nt.assert_true(np.all(np.round(G[:,50],8) == np.round(gx,8)))
-    nt.assert_true(np.all(np.round(G[:,50],8) == np.round(gy,8)))
+    npt.assert_(np.all(np.round(G[:,50],8) == np.round(gx,8)))
+    npt.assert_(np.all(np.round(G[:,50],8) == np.round(gy,8)))
 
 def test_cartes_to_polar():
     cartes = np.array([5,0]).astype('double')
     polar = utils.cartes_to_polar(cartes)
-    nt.assert_equal(polar[...,0], 0)
-    nt.assert_equal(polar[...,1], 5)
+    npt.assert_equal(polar[...,0], 0)
+    npt.assert_equal(polar[...,1], 5)
 
     cartes = np.array([-5,0]).astype('double')
     polar = utils.cartes_to_polar(cartes)
-    nt.assert_equal(polar[...,0], np.pi)
-    nt.assert_equal(polar[...,1], 5)
+    npt.assert_equal(polar[...,0], np.pi)
+    npt.assert_equal(polar[...,1], 5)
 
     cartes = np.array([0,5]).astype('double')
     polar = utils.cartes_to_polar(cartes)
-    nt.assert_equal(polar[...,0], np.pi/2)
-    nt.assert_equal(polar[...,1], 5)
+    npt.assert_equal(polar[...,0], np.pi/2)
+    npt.assert_equal(polar[...,1], 5)
 
     cartes = np.array([0,-5]).astype('double')
     polar = utils.cartes_to_polar(cartes)
-    nt.assert_equal(polar[...,0], np.pi*3/2)
-    nt.assert_equal(polar[...,1], 5)
+    npt.assert_equal(polar[...,0], np.pi*3/2)
+    npt.assert_equal(polar[...,1], 5)
 
 def test_binner():
 
@@ -767,8 +766,8 @@ def test_binner():
     bins = np.arange(-0.5,1.5,0.5)
     binned_signal = utils.binner(signal, times, bins)
 
-    nt.assert_true(len(binned_signal), len(bins)-2)
-    nt.assert_true(np.all(binned_signal==[5,5]))
+    npt.assert_(len(binned_signal), len(bins)-2)
+    npt.assert_(np.all(binned_signal==[5,5]))
 
 def test_find_files():
 
@@ -777,7 +776,7 @@ def test_find_files():
 
     path = utils.find_files('/tmp/','test*.txt')
 
-    nt.assert_equal(path[0],'/tmp/test_abc.txt')
+    npt.assert_equal(path[0],'/tmp/test_abc.txt')
 
 def test_peakdet():
 
@@ -791,10 +790,10 @@ def test_peakdet():
 
     a,b = utils.peakdet(ts,0.5)
 
-    nt.assert_true(np.all(a[:,0] == peaks))
-    nt.assert_true(np.all(b[:,0] == troughs))
-    nt.assert_true(np.all(a[:,1] == 1))
-    nt.assert_true(np.all(b[:,1] == -1))
+    npt.assert_(np.all(a[:,0] == peaks))
+    npt.assert_(np.all(b[:,0] == troughs))
+    npt.assert_(np.all(a[:,1] == 1))
+    npt.assert_(np.all(b[:,1] == -1))
 
 
     a,b = utils.peakdet(ts,0.5)
@@ -803,19 +802,19 @@ def test_peakdet():
 #
 #     o = utils.ols(np.arange(100),np.arange(100))
 #
-#     nt.assert_equal(o.R2,1.0)
-#     nt.assert_almost_equal(np.sum(o.e),0.0)
-#     nt.assert_almost_equal(np.sum(o.se),0.0)
-#     nt.assert_true(o.F == np.inf)
-#     nt.assert_almost_equal(np.sum(o.b),1.0)
-#     nt.assert_true(o.df_e == len(np.arange(100-2)))
-#     nt.assert_almost_equal(o.p[1],0)
-#     nt.assert_true(o.ll() == (2987.7752827161585, -59.715505654323174, -59.663402250603411))
-#     nt.assert_true(o.nobs == 100)
+#     npt.assert_equal(o.R2,1.0)
+#     npt.assert_almost_equal(np.sum(o.e),0.0)
+#     npt.assert_almost_equal(np.sum(o.se),0.0)
+#     npt.assert_(o.F == np.inf)
+#     npt.assert_almost_equal(np.sum(o.b),1.0)
+#     npt.assert_(o.df_e == len(np.arange(100-2)))
+#     npt.assert_almost_equal(o.p[1],0)
+#     npt.assert_(o.ll() == (2987.7752827161585, -59.715505654323174, -59.663402250603411))
+#     npt.assert_(o.nobs == 100)
 #     omni_1 = o.omni()[0]
 #     omni_2 = o.omni()[1]
-#     nt.assert_almost_equal(omni_1,18.093297390235648)
-#     nt.assert_almost_equal(omni_2, 0.00011778511003501986)
-#     nt.assert_true(o.JB() == (5.0825725194665461,0.07876502232916649,0.16483617111543283,1.9458968022816807))
-#     nt.assert_true(o.dw() == 0.0051450432267976026)
+#     npt.assert_almost_equal(omni_1,18.093297390235648)
+#     npt.assert_almost_equal(omni_2, 0.00011778511003501986)
+#     npt.assert_(o.JB() == (5.0825725194665461,0.07876502232916649,0.16483617111543283,1.9458968022816807))
+#     npt.assert_(o.dw() == 0.0051450432267976026)
 #
diff --git a/popeye/tests/test_xvalidation.py b/popeye/tests/test_xvalidation.py
index 2222cb8..8258c19 100644
--- a/popeye/tests/test_xvalidation.py
+++ b/popeye/tests/test_xvalidation.py
@@ -5,7 +5,6 @@
 
 import numpy as np
 import numpy.testing as npt
-import nose.tools as nt
 import scipy.signal as ss
 
 
@@ -16,17 +15,17 @@
 from popeye.spinach import generate_og_timeseries
 
 # def test_coeff_of_determination():
-#     
+#
 #     # make up some data and a model
 #     data = np.arange(0,100)
 #     model = np.arange(0,100)
-#     
+#
 #     # compute cod
 #     cod = xval.coeff_of_determination(data,model)
-#     
+#
 #     # assert
 #     npt.assert_equal(cod, 100)
-    
+
 
 def test_kfold_xval_repeated_runs():
 
@@ -47,57 +46,57 @@ def test_kfold_xval_repeated_runs():
     voxel_index = (1,2,3)
     auto_fit = True
     verbose = 1
-    
+
     num_runs = 4
     folds = 2
-    
+
     # create the sweeping bar stimulus in memory
-    bar = simulate_bar_stimulus(pixels_across, pixels_down, viewing_distance, 
+    bar = simulate_bar_stimulus(pixels_across, pixels_down, viewing_distance,
                                 screen_width, thetas, num_bar_steps, num_blank_steps, ecc)
-    
+
     # create an instance of the Stimulus class
     stimulus = VisualStimulus(bar, viewing_distance, screen_width, scale_factor, tr_length, dtype)
-    
+
     # set up bounds for the grid search
     grids = ((-10,10),(-10,10),(0.25,5.25),(0.1,1e2),(-5,5))
     bounds = ((-12,12),(-12,12),(1/stimulus.ppd,12),(0.1,1e3),(-5,5))
-    
+
     # set the grid smaples
     Ns = 5
-    
+
     # initialize the gaussian model
     model = og.GaussianModel(stimulus, utils.double_gamma_hrf)
-    
+
     # generate a random pRF estimate
     x = -5.24
     y = 2.58
     sigma = 1.24
     beta = 2.5
     hrf_delay = -0.25
-    
+
     # create the args context for calling the Fit class
     fit_args = [grids, bounds, Ns, [0,0,0]]
     fit_kwargs = {'auto_fit': False, 'verbose' : 0}
-    
+
     # create a series of "runs"
     data = np.zeros((num_runs,stimulus.stim_arr.shape[-1]))
-    
+
     for r in range(num_runs):
-        
+
         # fill out the data list
         data[r,:] = model.generate_prediction(x, y, sigma, beta, hrf_delay)
-    
+
     # get predictions out for each of the folds ...
     models = (model,)
     predictions = xval.kfold_xval(models, data, og.GaussianFit, folds, fit_args, fit_kwargs)
-    
+
     # assert the coeff of determination is 100 for each prediction
     for p in predictions:
         cod = xval.coeff_of_determination(p.data,p.prediction)
         npt.assert_almost_equal(cod,100, 4)
 
 # def test_kfold_xval_unique_runs():
-#     
+#
 #     # stimulus features
 #     pixels_across = 800
 #     pixels_down = 600
@@ -112,47 +111,47 @@ def test_kfold_xval_repeated_runs():
 #     dtype = ctypes.c_short
 #     num_runs = 4
 #     folds = 2
-#     
+#
 #     # create the sweeping bar stimulus in memory
 #     bar = simulate_bar_stimulus(pixels_across, pixels_down, viewing_distance, screen_width, thetas, num_steps, ecc)
-#     
+#
 #     # create an instance of the Stimulus class
 #     stimulus = VisualStimulus(bar, viewing_distance, screen_width, scale_factor, dtype)
-#     
+#
 #     # set up bounds for the grid search
 #     grids = ((-10,10),(-10,10),(0.25,5.25),(0.1,1e2),(-5,5))
 #     bounds = ((-12,12),(-12,12),(1/stimulus.ppd,12),(0.1,1e3),(-5,5))
-#     
+#
 #     # initialize the gaussian model
 #     model = og.GaussianModel(stimulus)
-#     
+#
 #     # generate a random pRF estimate
 #     x = -5.24
 #     y = 2.58
 #     sigma = 1.24
 #     beta = 2.5
 #     hrf_delay = -0.25
-#     
+#
 #     # create the args context for calling the Fit class
 #     fit_args = [grids, bounds, tr_length, [0,0,0],]
 #     fit_kwargs = {'auto_fit': False, 'verbose' : False}
-#     
+#
 #     # create a series of "runs"
 #     data = np.zeros((stimulus.stim_arr.shape[-1],num_runs))
-#     
+#
 #     for r in range(num_runs):
-#         
+#
 #         # fill out the data list
 #         data[:,r] = og.compute_model_ts(x, y, sigma, beta, hrf_delay,
-#                                         stimulus.deg_x, stimulus.deg_y, 
+#                                         stimulus.deg_x, stimulus.deg_y,
 #                                         stimulus.stim_arr, tr_length)
-#     
-#     
+#
+#
 #     # get predictions out for each of the folds ...
 #     models = np.tile(model,num_runs)
 #     left_out_data, predictions = xval.kfold_xval(models, data, og.GaussianFit, folds, fit_args, fit_kwargs)
-#     
+#
 #     # assert the coeff of determination is 100 for each prediction
 #     for k in range(folds):
 #         cod = xval.coeff_of_determination(left_out_data[k], predictions[k])
-#         npt.assert_almost_equal(cod,100, 4)
\ No newline at end of file
+#         npt.assert_almost_equal(cod,100, 4)