Index: interfaces/python/test_cvec.py
===================================================================
--- interfaces/python/test_cvec.py	(revision 1a6ef2cc59efef576596a70614b44f301bf649f9)
+++ interfaces/python/test_cvec.py	(revision 1a6ef2cc59efef576596a70614b44f301bf649f9)
@@ -0,0 +1,50 @@
+from numpy.testing import TestCase, run_module_suite
+from numpy.testing import assert_equal, assert_almost_equal
+from _aubio import cvec
+from numpy import array, shape, pi
+
+class aubio_cvec_test_case(TestCase):
+
+    def test_vector_created_with_zeroes(self):
+        a = cvec(10)
+        a
+        shape(a.norm)
+        shape(a.phas)
+        a.norm[0]
+        assert_equal(a.norm, 0.)
+        assert_equal(a.phas, 0.)
+
+    def test_vector_assign_element(self):
+        a = cvec()
+        a.norm[0] = 1
+        assert_equal(a.norm[0], 1)
+        a.phas[0] = 1
+        assert_equal(a.phas[0], 1)
+
+    def test_vector_assign_element_end(self):
+        a = cvec()
+        a.norm[-1] = 1
+        assert_equal(a.norm[-1], 1)
+        assert_equal(a.norm[len(a.norm)-1], 1)
+        a.phas[-1] = 1
+        assert_equal(a.phas[-1], 1)
+        assert_equal(a.phas[len(a.phas)-1], 1)
+
+    def test_assign_cvec_norm_slice(self):
+        spec = cvec(1024)
+        spec.norm[40:100] = 100
+        assert_equal (spec.norm[0:40], 0)
+        assert_equal (spec.norm[40:100], 100)
+        assert_equal (spec.norm[100:-1], 0)
+        assert_equal (spec.phas, 0)
+
+    def test_assign_cvec_phas_slice(self):
+        spec = cvec(1024)
+        spec.phas[39:-1] = -pi
+        assert_equal (spec.phas[0:39], 0)
+        assert_equal (spec.phas[39:-1], -pi)
+        assert_equal (spec.norm, 0)
+
+if __name__ == '__main__':
+    from unittest import main
+    main()
Index: interfaces/python/test_fft.py
===================================================================
--- interfaces/python/test_fft.py	(revision 84e0606b011337625ca664ea1a26162a884b6009)
+++ interfaces/python/test_fft.py	(revision 1a6ef2cc59efef576596a70614b44f301bf649f9)
@@ -2,5 +2,6 @@
 from numpy.testing import assert_equal, assert_almost_equal
 # WARNING: numpy also has an fft object
-from _aubio import fft, fvec, cvec
+from _aubio import fft, cvec
+from aubio import fvec
 from numpy import array, shape
 from math import pi
@@ -10,26 +11,22 @@
   def test_members(self):
     f = fft()
-    assert_equal ([f.win_s, f.channels], [1024, 1])
-    f = fft(2048, 4)
-    assert_equal ([f.win_s, f.channels], [2048, 4])
+    assert_equal (f.win_s, 1024)
 
   def test_output_dimensions(self):
     """ check the dimensions of output """
-    win_s, chan = 1024, 3
-    timegrain = fvec(win_s, chan)
-    f = fft(win_s, chan)
+    win_s = 1024
+    timegrain = fvec(win_s)
+    f = fft(win_s)
     fftgrain = f (timegrain)
-    assert_equal (array(fftgrain), 0)
-    assert_equal (shape(fftgrain), (chan * 2, win_s/2+1))
     assert_equal (fftgrain.norm, 0)
-    assert_equal (shape(fftgrain.norm), (chan, win_s/2+1))
+    assert_equal (shape(fftgrain.norm), (win_s/2+1,))
     assert_equal (fftgrain.phas, 0)
-    assert_equal (shape(fftgrain.phas), (chan, win_s/2+1))
+    assert_equal (shape(fftgrain.phas), (win_s/2+1,))
 
   def test_zeros(self):
     """ check the transform of zeros """
-    win_s, chan = 512, 3
-    timegrain = fvec(win_s, chan)
-    f = fft(win_s, chan)
+    win_s = 512
+    timegrain = fvec(win_s)
+    f = fft(win_s)
     fftgrain = f(timegrain)
     assert_equal ( fftgrain.norm == 0, True )
@@ -40,12 +37,12 @@
     from random import random
     from math import floor
-    win_s, chan = 256, 1
+    win_s = 256
     i = floor(random()*win_s)
     impulse = pi * random() 
-    f = fft(win_s, chan)
-    timegrain = fvec(win_s, chan)
-    timegrain[0][i] = impulse 
+    f = fft(win_s)
+    timegrain = fvec(win_s)
+    timegrain[i] = impulse 
     fftgrain = f ( timegrain )
-    #self.plot_this ( fftgrain.phas[0] )
+    #self.plot_this ( fftgrain.phas )
     assert_almost_equal ( fftgrain.norm, impulse, decimal = 6 )
     assert_equal ( fftgrain.phas <= pi, True)
@@ -56,22 +53,22 @@
     from random import random
     from math import floor
-    win_s, chan = 256, 1
+    win_s = 256
     i = 0 
     impulse = -10. 
-    f = fft(win_s, chan)
-    timegrain = fvec(win_s, chan)
-    timegrain[0][i] = impulse 
+    f = fft(win_s)
+    timegrain = fvec(win_s)
+    timegrain[i] = impulse 
     fftgrain = f ( timegrain )
-    #self.plot_this ( fftgrain.phas[0] )
+    #self.plot_this ( fftgrain.phas )
     assert_almost_equal ( fftgrain.norm, abs(impulse), decimal = 6 )
     if impulse < 0:
       # phase can be pi or -pi, as it is not unwrapped
-      assert_almost_equal ( abs(fftgrain.phas[0][1:-1]) , pi, decimal = 6 )
-      assert_almost_equal ( fftgrain.phas[0][0], pi, decimal = 6)
-      assert_almost_equal ( fftgrain.phas[0][-1], pi, decimal = 6)
+      assert_almost_equal ( abs(fftgrain.phas[1:-1]) , pi, decimal = 6 )
+      assert_almost_equal ( fftgrain.phas[0], pi, decimal = 6)
+      assert_almost_equal ( fftgrain.phas[-1], pi, decimal = 6)
     else:
-      assert_equal ( fftgrain.phas[0][1:-1] == 0, True)
-      assert_equal ( fftgrain.phas[0][0] == 0, True)
-      assert_equal ( fftgrain.phas[0][-1] == 0, True)
+      assert_equal ( fftgrain.phas[1:-1] == 0, True)
+      assert_equal ( fftgrain.phas[0] == 0, True)
+      assert_equal ( fftgrain.phas[-1] == 0, True)
     # now check the resynthesis
     synthgrain = f.rdo ( fftgrain )
@@ -83,23 +80,22 @@
 
   def test_impulse_at_zero(self):
-    """ check the transform of one impulse at a index 0 in one channel """
-    win_s, chan = 1024, 2
+    """ check the transform of one impulse at a index 0 """
+    win_s = 1024
     impulse = pi
-    f = fft(win_s, chan)
-    timegrain = fvec(win_s, chan)
-    timegrain[0][0] = impulse 
+    f = fft(win_s)
+    timegrain = fvec(win_s)
+    timegrain[0] = impulse 
     fftgrain = f ( timegrain )
     #self.plot_this ( fftgrain.phas )
     assert_equal ( fftgrain.phas[0], 0)
     assert_equal ( fftgrain.phas[1], 0)
-    assert_almost_equal ( fftgrain.norm[0], impulse, decimal = 6 )
-    assert_equal ( fftgrain.norm[0], impulse)
+    assert_almost_equal (fftgrain.norm[0], impulse, decimal = 6 )
 
   def test_rdo_before_do(self):
     """ check running fft.rdo before fft.do works """
-    win_s, chan = 1024, 2
+    win_s = 1024
     impulse = pi
-    f = fft(win_s, chan)
-    fftgrain = cvec(win_s, chan)
+    f = fft(win_s)
+    fftgrain = cvec(win_s)
     t = f.rdo( fftgrain )
     assert_equal ( t, 0 )
Index: interfaces/python/test_filter.py
===================================================================
--- interfaces/python/test_filter.py	(revision 84e0606b011337625ca664ea1a26162a884b6009)
+++ interfaces/python/test_filter.py	(revision 1a6ef2cc59efef576596a70614b44f301bf649f9)
@@ -2,4 +2,5 @@
 from numpy.testing import assert_equal, assert_almost_equal
 from _aubio import *
+from aubio import fvec
 from numpy import array
 
@@ -12,29 +13,29 @@
   def test_members(self):
     f = digital_filter()
-    assert_equal ([f.channels, f.order], [1, 7])
-    f = digital_filter(5, 2)
-    assert_equal ([f.channels, f.order], [2, 5])
+    assert_equal (f.order, 7)
+    f = digital_filter(5)
+    assert_equal (f.order, 5)
     f(fvec())
   
   def test_cweighting_error(self):
-    f = digital_filter (2, 1)
+    f = digital_filter (2)
     self.assertRaises ( ValueError, f.set_c_weighting, 44100 )
-    f = digital_filter (8, 1)
+    f = digital_filter (8)
     self.assertRaises ( ValueError, f.set_c_weighting, 44100 )
-    f = digital_filter (5, 1)
+    f = digital_filter (5)
     self.assertRaises ( ValueError, f.set_c_weighting, 4000 )
-    f = digital_filter (5, 1)
+    f = digital_filter (5)
     self.assertRaises ( ValueError, f.set_c_weighting, 193000 )
-    f = digital_filter (7, 1)
+    f = digital_filter (7)
     self.assertRaises ( ValueError, f.set_a_weighting, 193000 )
-    f = digital_filter (5, 1)
+    f = digital_filter (5)
     self.assertRaises ( ValueError, f.set_a_weighting, 192000 )
 
   def test_c_weighting(self):
     expected = array_from_text_file('c_weighting_test_simple.expected')
-    f = digital_filter(5, 1)
+    f = digital_filter(5)
     f.set_c_weighting(44100)
     v = fvec(32)
-    v[0][12] = .5
+    v[12] = .5
     u = f(v)
     assert_almost_equal (expected[1], u)
@@ -42,8 +43,8 @@
   def test_a_weighting(self):
     expected = array_from_text_file('a_weighting_test_simple.expected')
-    f = digital_filter(7, 1)
+    f = digital_filter(7)
     f.set_a_weighting(44100)
     v = fvec(32)
-    v[0][12] = .5
+    v[12] = .5
     u = f(v)
     assert_almost_equal (expected[1], u)
@@ -51,8 +52,8 @@
   def test_a_weighting_parted(self):
     expected = array_from_text_file('a_weighting_test_simple.expected')
-    f = digital_filter(7, 1)
+    f = digital_filter(7)
     f.set_a_weighting(44100)
     v = fvec(16)
-    v[0][12] = .5
+    v[12] = .5
     u = f(v)
     assert_almost_equal (expected[1][:16], u)
Index: interfaces/python/test_filterbank.py
===================================================================
--- interfaces/python/test_filterbank.py	(revision 84e0606b011337625ca664ea1a26162a884b6009)
+++ interfaces/python/test_filterbank.py	(revision 1a6ef2cc59efef576596a70614b44f301bf649f9)
@@ -3,4 +3,5 @@
 from numpy import array, shape
 from _aubio import *
+#from aubio import cvec
 
 class aubio_filter_test_case(TestCase):
@@ -11,4 +12,5 @@
     a = f.get_coeffs()
     a.T
+    assert_equal(shape (a), (40, 512/2 + 1) )
 
   def test_other_slaney(self):
@@ -23,5 +25,5 @@
       #print "sum is", sum(sum(a))
 
-  def test_triangle_freqs(self):
+  def test_triangle_freqs_zeros(self):
     f = filterbank(9, 1024)
     freq_list = [40, 80, 200, 400, 800, 1600, 3200, 6400, 12800, 15000, 24000]
@@ -29,8 +31,17 @@
     f.set_triangle_bands(freqs, 48000)
     f.get_coeffs().T
-    assert_equal ( f(cvec(1024)), [0] * 9)
+    assert_equal ( f(cvec(1024)), 0)
+
+  def test_triangle_freqs_ones(self):
+    f = filterbank(9, 1024)
+    freq_list = [40, 80, 200, 400, 800, 1600, 3200, 6400, 12800, 15000, 24000]
+    freqs = array(freq_list, dtype = 'float32')
+    f.set_triangle_bands(freqs, 48000)
+    f.get_coeffs().T
     spec = cvec(1024)
-    spec[0][40:100] = 100
-    #print f(spec)
+    spec.norm[:] = 1
+    assert_almost_equal ( f(spec),
+            [ 0.02070313,  0.02138672,  0.02127604,  0.02135417, 
+        0.02133301, 0.02133301,  0.02133311,  0.02133334,  0.02133345])
 
 if __name__ == '__main__':
Index: interfaces/python/test_fvec.py
===================================================================
--- interfaces/python/test_fvec.py	(revision 84e0606b011337625ca664ea1a26162a884b6009)
+++ interfaces/python/test_fvec.py	(revision 1a6ef2cc59efef576596a70614b44f301bf649f9)
@@ -2,11 +2,15 @@
 from numpy.testing import assert_equal, assert_almost_equal
 from _aubio import *
-from numpy import array
+from aubio import fvec
+from numpy import array, shape
 
 class aubio_fvec_test_case(TestCase):
 
-
     def test_vector_created_with_zeroes(self):
-        a = fvec()
+        a = fvec(10)
+        a
+        shape(a)
+        a[0]
+        #del a
         assert_equal(array(a), 0.)
 
@@ -20,15 +24,16 @@
         a[-1] = 1
         assert_equal(a[-1], 1)
-        assert_equal(a[a.length-1], 1)
+        assert_equal(a[len(a)-1], 1)
 
     def test_vector(self):
         a = fvec()
-        a, a.length
+        a, len(a) #a.length
         a[0]
         array(a)
         a = fvec(10)
         a = fvec(1)
+        a.T
         array(a).T
-        a[0] = range(a.length)
+        a = range(len(a))
 
     def test_wrong_values(self):
Index: interfaces/python/test_onsetdetection.py
===================================================================
--- interfaces/python/test_onsetdetection.py	(revision 84e0606b011337625ca664ea1a26162a884b6009)
+++ interfaces/python/test_onsetdetection.py	(revision 1a6ef2cc59efef576596a70614b44f301bf649f9)
@@ -2,5 +2,5 @@
 from numpy.testing import assert_equal, assert_almost_equal
 # WARNING: numpy also has an fft object
-from _aubio import cvec, specdesc
+from _aubio import specdesc, cvec
 from numpy import array, shape, arange, zeros, log
 from math import pi
@@ -10,9 +10,6 @@
     def test_members(self):
         o = specdesc()
-        assert_equal ([o.buf_size, o.channels, o.method],
-            [1024, 1, "default"])
-        o = specdesc("complex", 512, 2)
-        assert_equal ([o.buf_size, o.channels, o.method],
-            [512, 2, "complex"])
+        assert_equal ([o.buf_size, o.method],
+            [1024, "default"])
 
     def test_hfc(self):
@@ -22,5 +19,5 @@
         a = arange(c.length, dtype='float32')
         c.norm = a
-        assert_equal (a, c.norm[0])
+        assert_equal (a, c.norm)
         assert_equal ( sum(a*(a+1)), o(c))
 
@@ -31,5 +28,5 @@
         a = arange(c.length, dtype='float32')
         c.norm = a
-        assert_equal (a, c.norm[0])
+        assert_equal (a, c.norm)
         # the previous run was on zeros, so previous frames are still 0
         # so we have sqrt ( abs ( r2 ^ 2) ) == r2
Index: interfaces/python/test_phasevoc.py
===================================================================
--- interfaces/python/test_phasevoc.py	(revision 84e0606b011337625ca664ea1a26162a884b6009)
+++ interfaces/python/test_phasevoc.py	(revision 1a6ef2cc59efef576596a70614b44f301bf649f9)
@@ -1,4 +1,5 @@
 from numpy.testing import TestCase, run_module_suite
 from numpy.testing import assert_equal, assert_almost_equal
+from aubio import fvec
 from _aubio import *
 from numpy import array, shape
@@ -26,11 +27,11 @@
   def test_steps_two_channels(self):
     """ check the resynthesis of steps is correct """
-    f = pvoc(1024, 512, 2)
-    t1 = fvec(512, 2)
-    t2 = fvec(512, 2)
+    f = pvoc(1024, 512)
+    t1 = fvec(512)
+    t2 = fvec(512)
     # positive step in first channel
-    t1[0][100:200] = .1
+    t1[100:200] = .1
     # positive step in second channel
-    t1[1][20:50] = -.1
+    t1[20:50] = -.1
     s1 = f(t1)
     r1 = f.rdo(s1)
@@ -42,10 +43,9 @@
   def test_steps_three_random_channels(self):
     from random import random
-    f = pvoc(64, 16, 3)
-    t0 = fvec(16, 3)
-    t1 = fvec(16, 3)
-    for i in xrange(3):
-      for j in xrange(16):
-        t1[i][j] = random() * 2. - 1.
+    f = pvoc(64, 16)
+    t0 = fvec(16)
+    t1 = fvec(16)
+    for i in xrange(16):
+        t1[i] = random() * 2. - 1.
     t2 = f.rdo(f(t1))
     t2 = f.rdo(f(t0))
